LegalizeDAG.cpp revision 5e3c5b4e13d45d631cddf42176b380f64fde918f
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/MachineFunction.h" 1645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 1702659d23637f69f90640bfa3e66919517103c57aJim Laskey#include "llvm/Support/MathExtras.h" 183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Target/TargetLowering.h" 19e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner#include "llvm/Target/TargetData.h" 200f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner#include "llvm/Target/TargetOptions.h" 21adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Constants.h" 233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include <iostream> 2482299e70977500209c951404e354510feffb8efaChris Lattner#include <set> 253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerusing namespace llvm; 263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// SelectionDAGLegalize - This takes an arbitrary SelectionDAG as input and 293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// hacks on it until the target machine can handle it. This involves 303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating value sizes the machine cannot handle (promoting small sizes to 313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// large sizes or splitting up large values into small values) as well as 323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating operations the machine cannot handle. 333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// This code also does a small amount of optimization and recognition of idioms 353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// as part of its processing. For example, if a target does not support a 363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 'setcc' instruction efficiently, but does support 'brcc' instruction, this 373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// will attempt merge setcc and brc instructions into brcc's. 383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnernamespace { 403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerclass SelectionDAGLegalize { 413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner TargetLowering &TLI; 423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SelectionDAG &DAG; 433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizeAction - This enum indicates what action we should take for each 453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type the can occur in the program. 463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner enum LegalizeAction { 473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Legal, // The target natively supports this value type. 483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Promote, // This should be promoted to the next larger type. 493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Expand, // This integer type should be broken into smaller pieces. 503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner }; 513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ValueTypeActions - This is a bitvector that contains two bits for each 533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type, where the two bits correspond to the LegalizeAction enum. 543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// This can be queried with "getTypeAction(VT)". 556a648614e88586e85a36ceb5c1d3b84e4f55b458Nate Begeman unsigned long long ValueTypeActions; 563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// NeedsAnotherIteration - This is set when we expand a large integer 583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// operation into smaller integer operations, but the smaller operations are 593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// not set. This occurs only rarely in practice, for targets that don't have 603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 32-bit or larger integer registers. 613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool NeedsAnotherIteration; 623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizedNodes - For nodes that are of legal width, and that have more 643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates what regularized operand to use. This 653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// allows us to avoid legalizing the same thing more than once. 663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, SDOperand> LegalizedNodes; 673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6803c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// PromotedNodes - For nodes that are below legal width, and that have more 6903c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// than one use, this map indicates what promoted value to use. This allows 7003c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// us to avoid promoting the same thing more than once. 7103c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::map<SDOperand, SDOperand> PromotedNodes; 7203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ExpandedNodes - For nodes that need to be expanded, and which have more 743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates which which operands are the expanded 753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// version of the input. This allows us to avoid expanding the same node 763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// more than once. 773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> > ExpandedNodes; 783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 798afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner void AddLegalizedOperand(SDOperand From, SDOperand To) { 808afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner bool isNew = LegalizedNodes.insert(std::make_pair(From, To)).second; 818afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner assert(isNew && "Got into the map somehow?"); 828afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner } 8303c8546ec57523970874917854a2fb77b1ff598eChris Lattner void AddPromotedOperand(SDOperand From, SDOperand To) { 8403c8546ec57523970874917854a2fb77b1ff598eChris Lattner bool isNew = PromotedNodes.insert(std::make_pair(From, To)).second; 8503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isNew && "Got into the map somehow?"); 8603c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 878afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner 883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerpublic: 893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 909c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(SelectionDAG &DAG); 913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Run - While there is still lowering to do, perform a pass over the DAG. 933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Most regularization can be done in a single pass, but targets that require 943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// large values to be split into registers multiple times (e.g. i64 -> 4x 953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// i16) require iteration for these values (the first iteration will demote 963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// to i32, the second will demote to i16). 973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void Run() { 983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner do { 993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NeedsAnotherIteration = false; 1003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeDAG(); 1013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } while (NeedsAnotherIteration); 1023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// getTypeAction - Return how we should legalize values of this type, either 1053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// it is already legal or we need to expand it into multiple registers of 1063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// smaller integer type, or we need to promote it to a larger type. 1073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeAction getTypeAction(MVT::ValueType VT) const { 1083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return (LegalizeAction)((ValueTypeActions >> (2*VT)) & 3); 1093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// isTypeLegal - Return true if this type is legal on this target. 1123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 1133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isTypeLegal(MVT::ValueType VT) const { 1143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return getTypeAction(VT) == Legal; 1153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerprivate: 1183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void LegalizeDAG(); 1193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LegalizeOp(SDOperand O); 1213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void ExpandOp(SDOperand O, SDOperand &Lo, SDOperand &Hi); 12203c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand PromoteOp(SDOperand O); 1233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandLibCall(const char *Name, SDNode *Node, 12577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi); 12677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandIntToFP(bool isSigned, MVT::ValueType DestTy, 12777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Source); 128cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 1296269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand ExpandLegalINT_TO_FP(bool isSigned, 1306269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand LegalOp, 1316269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT); 1325a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman SDOperand PromoteLegalINT_TO_FP(SDOperand LegalOp, MVT::ValueType DestVT, 1335a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned); 1341618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner SDOperand PromoteLegalFP_TO_INT(SDOperand LegalOp, MVT::ValueType DestVT, 1351618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned); 13600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 137e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner bool ExpandShift(unsigned Opc, SDOperand Op, SDOperand Amt, 138e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi); 1395b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandShiftParts(unsigned NodeOp, SDOperand Op, SDOperand Amt, 1405b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi); 1415b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 1424759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi); 143e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 144b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner void SpliceCallInto(const SDOperand &CallResult, SDNode *OutChain); 145b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 1463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 1473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 1483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner}; 1503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 152b89175feffa7148c05d1d30a8e382b8d321edae5Chris Lattnerstatic unsigned getScalarizedOpcode(unsigned VecOp, MVT::ValueType VT) { 1535fbb5d2459a5410590f285250faa604576308a93Nate Begeman switch (VecOp) { 1545fbb5d2459a5410590f285250faa604576308a93Nate Begeman default: assert(0 && "Don't know how to scalarize this opcode!"); 1555fbb5d2459a5410590f285250faa604576308a93Nate Begeman case ISD::VADD: return MVT::isInteger(VT) ? ISD::ADD : ISD::FADD; 1565fbb5d2459a5410590f285250faa604576308a93Nate Begeman case ISD::VSUB: return MVT::isInteger(VT) ? ISD::SUB : ISD::FSUB; 1575fbb5d2459a5410590f285250faa604576308a93Nate Begeman case ISD::VMUL: return MVT::isInteger(VT) ? ISD::MUL : ISD::FMUL; 1585fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1595fbb5d2459a5410590f285250faa604576308a93Nate Begeman} 1603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1619c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris LattnerSelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag) 1629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner : TLI(dag.getTargetLoweringInfo()), DAG(dag), 1639c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner ValueTypeActions(TLI.getValueTypeActions()) { 1646a648614e88586e85a36ceb5c1d3b84e4f55b458Nate Begeman assert(MVT::LAST_VALUETYPE <= 32 && 1653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Too many value types for ValueTypeActions to hold!"); 1663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1686269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// ExpandLegalINT_TO_FP - This function is responsible for legalizing a 1696269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// INT_TO_FP operation of the specified operand when the target requests that 170cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we expand it. At this point, we know that the result and operand types are 171cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target. 1726269ed125fc492d81dc5e3f48482816fc9d47f49Jim LaskeySDOperand SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned, 1736269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0, 1746269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT) { 1756269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (Op0.getValueType() == MVT::i32) { 1766269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // simple 32-bit [signed|unsigned] integer to float/double expansion 1776269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey 1786269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get the stack frame index of a 8 byte buffer 1796269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MachineFunction &MF = DAG.getMachineFunction(); 1806269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey int SSFI = MF.getFrameInfo()->CreateStackObject(8, 8); 1816269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get address of 8 byte buffer 1826269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 1836269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // word offset constant for Hi/Lo address computation 1846269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy()); 1856269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // set up Hi and Lo (into buffer) address based on endian 1866269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Hi, Lo; 1876269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (TLI.isLittleEndian()) { 1886269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1896269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = StackSlot; 1906269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 1916269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = StackSlot; 1926269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1936269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 1946269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if signed map to unsigned space 1956269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0Mapped; 1966269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (isSigned) { 1976269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // constant used to invert sign bit (signed to unsigned mapping) 1986269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand SignBit = DAG.getConstant(0x80000000u, MVT::i32); 1996269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = DAG.getNode(ISD::XOR, MVT::i32, Op0, SignBit); 2006269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 2016269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = Op0; 2026269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2036269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the lo of the constructed double - based on integer input 2046269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store1 = DAG.getNode(ISD::STORE, MVT::Other, DAG.getEntryNode(), 2056269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped, Lo, DAG.getSrcValue(NULL)); 2066269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // initial hi portion of constructed double 2076269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand InitialHi = DAG.getConstant(0x43300000u, MVT::i32); 2086269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the hi of the constructed double - biased exponent 2096269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store2 = DAG.getNode(ISD::STORE, MVT::Other, Store1, 2106269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey InitialHi, Hi, DAG.getSrcValue(NULL)); 2116269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // load the constructed double 2126269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Load = DAG.getLoad(MVT::f64, Store2, StackSlot, 2136269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey DAG.getSrcValue(NULL)); 2146269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // FP constant to bias correct the final result 21502659d23637f69f90640bfa3e66919517103c57aJim Laskey SDOperand Bias = DAG.getConstantFP(isSigned ? 21602659d23637f69f90640bfa3e66919517103c57aJim Laskey BitsToDouble(0x4330000080000000ULL) 21702659d23637f69f90640bfa3e66919517103c57aJim Laskey : BitsToDouble(0x4330000000000000ULL), 2186269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::f64); 2196269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // subtract the bias 22001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Sub = DAG.getNode(ISD::FSUB, MVT::f64, Load, Bias); 2216269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // final result 2226269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Result; 2236269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // handle final rounding 2246269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (DestVT == MVT::f64) { 2256269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // do nothing 2266269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = Sub; 2276269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 2286269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if f32 then cast to f32 2296269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = DAG.getNode(ISD::FP_ROUND, MVT::f32, Sub); 2306269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2316269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey NeedsAnotherIteration = true; 2326269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey return Result; 2336269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2346269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey assert(!isSigned && "Legalize cannot Expand SINT_TO_FP for i64 yet"); 235cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Tmp1 = DAG.getNode(ISD::SINT_TO_FP, DestVT, Op0); 23600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2377cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Op0, 2387cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Op0.getValueType()), 2397cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 240cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 241cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 242cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SignSet, Four, Zero); 24300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2446269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // If the sign bit of the integer is set, the large number will be treated 2456269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // as a negative number. To counteract this, the dynamic code adds an 2466269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // offset depending on the data type. 247f4d32726e622c740b4befc803e604903eb1349dfChris Lattner uint64_t FF; 248f4d32726e622c740b4befc803e604903eb1349dfChris Lattner switch (Op0.getValueType()) { 249f4d32726e622c740b4befc803e604903eb1349dfChris Lattner default: assert(0 && "Unsupported integer type!"); 250f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i8 : FF = 0x43800000ULL; break; // 2^8 (as a float) 251f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i16: FF = 0x47800000ULL; break; // 2^16 (as a float) 252f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i32: FF = 0x4F800000ULL; break; // 2^32 (as a float) 253f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i64: FF = 0x5F800000ULL; break; // 2^64 (as a float) 254f4d32726e622c740b4befc803e604903eb1349dfChris Lattner } 255cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 256cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 25700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2585839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 259cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 260cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand FudgeInReg; 261cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (DestVT == MVT::f32) 262cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 263cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL)); 264cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner else { 265cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(DestVT == MVT::f64 && "Unexpected conversion"); 266cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = LegalizeOp(DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, 267cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getEntryNode(), CPIdx, 268cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL), MVT::f32)); 269cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 27000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 271cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NeedsAnotherIteration = true; 272473a99073cc29f59809a0d5dfee11f5e9e6ad2b7Chris Lattner return DAG.getNode(ISD::FADD, DestVT, Tmp1, FudgeInReg); 273cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 274cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 275149c58ce0b94e64faf3c4ccdbf894061cf7d66e1Chris Lattner/// PromoteLegalINT_TO_FP - This function is responsible for legalizing a 2761618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// *INT_TO_FP operation of the specified operand when the target requests that 277cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we promote it. At this point, we know that the result and operand types are 278cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target, and that there is a legal UINT_TO_FP or SINT_TO_FP 279cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// operation that takes a larger input. 2805a8441ea3fc145393d6274156bd05c4a006099eaNate BegemanSDOperand SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDOperand LegalOp, 2815a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman MVT::ValueType DestVT, 2825a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned) { 283cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // First step, figure out the appropriate *INT_TO_FP operation to use. 284cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner MVT::ValueType NewInTy = LegalOp.getValueType(); 28500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 286cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner unsigned OpToUse = 0; 28700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 288cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Scan for the appropriate larger type to use. 289cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner while (1) { 290cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NewInTy = (MVT::ValueType)(NewInTy+1); 291cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(MVT::isInteger(NewInTy) && "Ran out of possibilities!"); 29200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 293cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports SINT_TO_FP of this type, use it. 294cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, NewInTy)) { 295cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 296cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 297c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewInTy)) 298cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 299cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 300cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 301cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::SINT_TO_FP; 302cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 303cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 304cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 3055a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman if (isSigned) continue; 30600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 307cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports UINT_TO_FP of this type, use it. 308cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::UINT_TO_FP, NewInTy)) { 309cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 310cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 311c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewInTy)) 312cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 313cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 314cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 315cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::UINT_TO_FP; 316cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 317cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 318cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 31900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 320cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Otherwise, try a larger type. 321cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 322cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 323cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Make sure to legalize any nodes we create here in the next pass. 324cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NeedsAnotherIteration = true; 32500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 326cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Okay, we found the operation and type to use. Zero extend our input to the 327cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // desired type then run the operation on it. 328cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner return DAG.getNode(OpToUse, DestVT, 3295a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, 3305a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman NewInTy, LegalOp)); 331cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 332cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 3331618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// PromoteLegalFP_TO_INT - This function is responsible for legalizing a 3341618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// FP_TO_*INT operation of the specified operand when the target requests that 3351618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// we promote it. At this point, we know that the result and operand types are 3361618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// legal for the target, and that there is a legal FP_TO_UINT or FP_TO_SINT 3371618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// operation that returns a larger result. 3381618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris LattnerSDOperand SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDOperand LegalOp, 3391618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType DestVT, 3401618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned) { 3411618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // First step, figure out the appropriate FP_TO*INT operation to use. 3421618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType NewOutTy = DestVT; 343d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3441618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner unsigned OpToUse = 0; 345d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3461618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Scan for the appropriate larger type to use. 3471618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner while (1) { 3481618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NewOutTy = (MVT::ValueType)(NewOutTy+1); 3491618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner assert(MVT::isInteger(NewOutTy) && "Ran out of possibilities!"); 350d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3511618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_SINT returning this type, use it. 3521618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_SINT, NewOutTy)) { 3531618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3541618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 355c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewOutTy)) 3561618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3571618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3581618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3591618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_SINT; 3601618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3611618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3621618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 363d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3641618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_UINT of this type, use it. 3651618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_UINT, NewOutTy)) { 3661618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3671618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 368c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewOutTy)) 3691618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3701618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3711618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3721618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_UINT; 3731618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3741618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3751618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 376d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3771618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Otherwise, try a larger type. 3781618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 379d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3801618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Make sure to legalize any nodes we create here in the next pass. 3811618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NeedsAnotherIteration = true; 382d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3831618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Okay, we found the operation and type to use. Truncate the result of the 3841618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // extended FP_TO_*INT operation to the desired size. 3851618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return DAG.getNode(ISD::TRUNCATE, DestVT, 3861618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner DAG.getNode(OpToUse, NewOutTy, LegalOp)); 3871618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner} 3881618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 38932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner/// ComputeTopDownOrdering - Add the specified node to the Order list if it has 39032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner/// not been visited yet and if all of its operands have already been visited. 39132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattnerstatic void ComputeTopDownOrdering(SDNode *N, std::vector<SDNode*> &Order, 39232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::map<SDNode*, unsigned> &Visited) { 39332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner if (++Visited[N] != N->getNumOperands()) 39432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner return; // Haven't visited all operands yet 39532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 39632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner Order.push_back(N); 39732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 39832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner if (N->hasOneUse()) { // Tail recurse in common case. 39932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ComputeTopDownOrdering(*N->use_begin(), Order, Visited); 40032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner return; 40132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 40232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 40332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Now that we have N in, add anything that uses it if all of their operands 40432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // are now done. 40532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (SDNode::use_iterator UI = N->use_begin(), E = N->use_end(); UI != E;++UI) 40632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ComputeTopDownOrdering(*UI, Order, Visited); 40732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner} 40832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 4091618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 4103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 411ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // The legalize process is inherently a bottom-up recursive process (users 412ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // legalize their uses before themselves). Given infinite stack space, we 413ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // could just start legalizing on the root and traverse the whole graph. In 414ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // practice however, this causes us to run out of stack space on large basic 41532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // blocks. To avoid this problem, compute an ordering of the nodes where each 41632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // node is only legalized after all of its operands are legalized. 41732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::map<SDNode*, unsigned> Visited; 41832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::vector<SDNode*> Order; 419ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 42032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Compute ordering from all of the leaves in the graphs, those (like the 42132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // entry node) that have no operands. 42232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (SelectionDAG::allnodes_iterator I = DAG.allnodes_begin(), 42332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner E = DAG.allnodes_end(); I != E; ++I) { 424de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner if (I->getNumOperands() == 0) { 425de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner Visited[I] = 0 - 1U; 426de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner ComputeTopDownOrdering(I, Order, Visited); 427ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner } 428ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner } 429ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 430de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner assert(Order.size() == Visited.size() && 431de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner Order.size() == 432de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner (unsigned)std::distance(DAG.allnodes_begin(), DAG.allnodes_end()) && 43332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner "Error: DAG is cyclic!"); 43432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner Visited.clear(); 435ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 43632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (unsigned i = 0, e = Order.size(); i != e; ++i) { 43732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner SDNode *N = Order[i]; 43832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner switch (getTypeAction(N->getValueType(0))) { 43932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner default: assert(0 && "Bad type action!"); 44032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Legal: 44132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner LegalizeOp(SDOperand(N, 0)); 44232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 44332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Promote: 44432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner PromoteOp(SDOperand(N, 0)); 44532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 44632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Expand: { 44732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner SDOperand X, Y; 44832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ExpandOp(SDOperand(N, 0), X, Y); 44932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 45032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 45132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 45232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 45332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 45432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Finally, it's possible the root changed. Get the new root. 4553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand OldRoot = DAG.getRoot(); 45632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner assert(LegalizedNodes.count(OldRoot) && "Root didn't get legalized?"); 45732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner DAG.setRoot(LegalizedNodes[OldRoot]); 4583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandedNodes.clear(); 4603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizedNodes.clear(); 46171c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner PromotedNodes.clear(); 4623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remove dead nodes now. 46462fd269c146d9023efe32644e44cd97b88631d4fChris Lattner DAG.RemoveDeadNodes(OldRoot.Val); 4653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 4663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris LattnerSDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { 468c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Op.getValueType()) && 469e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner "Caller should expand or promote operands that are not legal!"); 47045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner SDNode *Node = Op.Val; 471e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 4723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If this operation defines any values that cannot be represented in a 473e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner // register on this target, make sure to expand or promote them. 47445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Node->getNumValues() > 1) { 47545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 47645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner switch (getTypeAction(Node->getValueType(i))) { 4773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: break; // Nothing to do. 4783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 4793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand T1, T2; 4803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Op.getValue(i), T1, T2); 4813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(LegalizedNodes.count(Op) && 4823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Expansion didn't add legal operands!"); 4833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return LegalizedNodes[Op]; 4843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 48603c8546ec57523970874917854a2fb77b1ff598eChris Lattner PromoteOp(Op.getValue(i)); 48703c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(LegalizedNodes.count(Op) && 48803c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Expansion didn't add legal operands!"); 48903c8546ec57523970874917854a2fb77b1ff598eChris Lattner return LegalizedNodes[Op]; 4903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 49345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 49445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 495e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::map<SDOperand, SDOperand>::iterator I = LegalizedNodes.find(Op); 496e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (I != LegalizedNodes.end()) return I->second; 4973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4989373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand Tmp1, Tmp2, Tmp3, Tmp4; 4993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Result = Op; 5013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 5033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 504d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getOpcode() >= ISD::BUILTIN_OP_END) { 505d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // If this is a target node, legalize it by legalizing the operands then 506d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // passing it through. 507d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<SDOperand> Ops; 508d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner bool Changed = false; 509d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 510d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 511d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Changed = Changed || Node->getOperand(i) != Ops.back(); 512d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 513d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Changed) 514d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getNumValues() == 1) 515d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Ops); 516d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner else { 517d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), 518d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Node->value_end()); 519d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 520d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 521d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner 522d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 523d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner AddLegalizedOperand(Op.getValue(i), Result.getValue(i)); 524d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner return Result.getValue(Op.ResNo); 525d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 526d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // Otherwise this is an unhandled builtin node. splat. 5273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 5283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to legalize this operator!"); 5293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 5303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EntryToken: 5313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::FrameIndex: 53232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::TargetFrameIndex: 53332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::Register: 53432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::TargetConstant: 5353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::GlobalAddress: 536b9debbf54c926036d5c22b3e7f0d12c79c1c15a3Chris Lattner case ISD::TargetGlobalAddress: 53703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::ExternalSymbol: 53869a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::ConstantPool: // Nothing to do. 53932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::BasicBlock: 54032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::CONDCODE: 54132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::VALUETYPE: 54232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::SRCVALUE: 54336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case ISD::STRING: 5440c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 5450c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner default: assert(0 && "This action is not supported yet!"); 5460c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner case TargetLowering::Custom: { 5470c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner SDOperand Tmp = TLI.LowerOperation(Op, DAG); 5480c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner if (Tmp.Val) { 5490c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner Result = LegalizeOp(Tmp); 5500c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner break; 5510c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } 5520c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } // FALLTHROUGH if the target doesn't want to lower this op after all. 5530c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner case TargetLowering::Legal: 5540c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner assert(isTypeLegal(Node->getValueType(0)) && "This must be legal!"); 5550c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner break; 5560c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } 5573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 55808951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertSext: 55908951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertZext: 56008951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 56108951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner if (Tmp1 != Node->getOperand(0)) 56208951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 56308951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Node->getOperand(1)); 56408951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner break; 565308575be66ec3870d27b19df044fda18448feb41Chris Lattner case ISD::MERGE_VALUES: 566308575be66ec3870d27b19df044fda18448feb41Chris Lattner return LegalizeOp(Node->getOperand(Op.ResNo)); 56769a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::CopyFromReg: 56869a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 56969a52155d2eff066b49dbac385113002fd9dba14Chris Lattner if (Tmp1 != Node->getOperand(0)) 570d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getCopyFromReg(Tmp1, 571d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Node->getOperand(1))->getReg(), 572d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getValueType(0)); 57313c184de29c09294ed63b01ac43e1b46c049278eChris Lattner else 57413c184de29c09294ed63b01ac43e1b46c049278eChris Lattner Result = Op.getValue(0); 57513c184de29c09294ed63b01ac43e1b46c049278eChris Lattner 57613c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // Since CopyFromReg produces two values, make sure to remember that we 57713c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // legalized both of them. 57813c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 57913c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 58013c184de29c09294ed63b01ac43e1b46c049278eChris Lattner return Result.getValue(Op.ResNo); 58118c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner case ISD::ImplicitDef: 58218c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 58318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner if (Tmp1 != Node->getOperand(0)) 584d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::ImplicitDef, MVT::Other, 585d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp1, Node->getOperand(1)); 58618c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner break; 587fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: { 588fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman MVT::ValueType VT = Op.getValueType(); 589fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman switch (TLI.getOperationAction(ISD::UNDEF, VT)) { 590ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman default: assert(0 && "This action is not supported yet!"); 591ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Expand: 592ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Promote: 593fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman if (MVT::isInteger(VT)) 594fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstant(0, VT); 595fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else if (MVT::isFloatingPoint(VT)) 596fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstantFP(0, VT); 597fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else 598fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman assert(0 && "Unknown value type!"); 599fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 600ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Legal: 601fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 602fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 603fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 604fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 60536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 60636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case ISD::LOCATION: 60736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner assert(Node->getNumOperands() == 5 && "Invalid LOCATION node!"); 60836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the input chain. 60936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 61036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner switch (TLI.getOperationAction(ISD::LOCATION, MVT::Other)) { 61136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Promote: 61236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner default: assert(0 && "This action is not supported yet!"); 61336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Expand: 61436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner // If the target doesn't support line numbers, ignore this node. 61536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Result = Tmp1; 61636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 61736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Legal: 6189ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner if (Tmp1 != Node->getOperand(0) || 6199ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner getTypeAction(Node->getOperand(1).getValueType()) == Promote) { 62036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner std::vector<SDOperand> Ops; 62136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Tmp1); 6229ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner if (getTypeAction(Node->getOperand(1).getValueType()) == Legal) { 6239ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(Node->getOperand(1)); // line # must be legal. 6249ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(Node->getOperand(2)); // col # must be legal. 6259ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner } else { 6269ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner // Otherwise promote them. 6279ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(PromoteOp(Node->getOperand(1))); 6289ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(PromoteOp(Node->getOperand(2))); 6299ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner } 63036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Node->getOperand(3)); // filename must be legal. 63136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Node->getOperand(4)); // working dir # must be legal. 63236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Result = DAG.getNode(ISD::LOCATION, MVT::Other, Ops); 63336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 63436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 63536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 63636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 63736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 6383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: 6393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // We know we don't need to expand constants here, constants only have one 6403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // value and we check that it is fine above. 6413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: Maybe we should handle things like targets that don't support full 6433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // 32-bit immediates? 6443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 6463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 6473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 6483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 6493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 6503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 6523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Check to see if this FP immediate is already legal. 6543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isLegal = false; 6553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 6563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner E = TLI.legal_fpimm_end(); I != E; ++I) 6573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (CFP->isExactlyValue(*I)) { 6583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner isLegal = true; 6593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!isLegal) { 6633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Otherwise we need to spill the constant to memory. 6643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool Extend = false; 6653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If a FP immediate is precise when represented as a float, we put it 6673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // into the constant pool as a float, even if it's is statically typed 6683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // as a double. 6693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = CFP->getValueType(0); 6703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isDouble = VT == MVT::f64; 6713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFP *LLVMC = ConstantFP::get(isDouble ? Type::DoubleTy : 6723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Type::FloatTy, CFP->getValue()); 67399939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner if (isDouble && CFP->isExactlyValue((float)CFP->getValue()) && 67499939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // Only do this if the target has a native EXTLOAD instruction from 67599939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // f32. 676c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::EXTLOAD, MVT::f32)) { 6773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LLVMC = cast<ConstantFP>(ConstantExpr::getCast(LLVMC, Type::FloatTy)); 6783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner VT = MVT::f32; 6793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Extend = true; 6803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 681edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 6825839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy()); 683f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner if (Extend) { 6845f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 6855f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 686f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } else { 68752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, 68852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 689f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } 6903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6938cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman case ISD::ConstantVec: { 6948cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // We assume that vector constants are not legal, and will be immediately 6958cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // spilled to the constant pool. 6968cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // 6978cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // FIXME: revisit this when we have some kind of mechanism by which targets 6988cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // can decided legality of vector constants, of which there may be very 6998cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // many. 7008cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // 7018cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // Create a ConstantPacked, and put it in the constant pool. 7028cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman std::vector<Constant*> CV; 7038cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman MVT::ValueType VT = Node->getValueType(0); 7048cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman for (unsigned I = 0, E = Node->getNumOperands(); I < E; ++I) { 7058cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman SDOperand OpN = Node->getOperand(I); 7068cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman const Type* OpNTy = MVT::getTypeForValueType(OpN.getValueType()); 7078cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman if (MVT::isFloatingPoint(VT)) 7088cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman CV.push_back(ConstantFP::get(OpNTy, 7098cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman cast<ConstantFPSDNode>(OpN)->getValue())); 7108cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman else 7118cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman CV.push_back(ConstantUInt::get(OpNTy, 7128cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman cast<ConstantSDNode>(OpN)->getValue())); 7138cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman } 7148cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman Constant *CP = ConstantPacked::get(CV); 7158cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman SDOperand CPIdx = DAG.getConstantPool(CP, Node->getValueType(0)); 7168cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, DAG.getSrcValue(NULL)); 7178cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman break; 7188cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman } 719040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner case ISD::TokenFactor: 720040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Node->getNumOperands() == 2) { 721040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner bool Changed = false; 722040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op0 = LegalizeOp(Node->getOperand(0)); 723040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op1 = LegalizeOp(Node->getOperand(1)); 724040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Op0 != Node->getOperand(0) || Op1 != Node->getOperand(1)) 725040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 726040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } else { 727040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner std::vector<SDOperand> Ops; 728040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner bool Changed = false; 729040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner // Legalize the operands. 730040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 731040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op = Node->getOperand(i); 732040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Ops.push_back(LegalizeOp(Op)); 733040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Changed |= Ops[i] != Op; 734040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } 735040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Changed) 736040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Ops); 737a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 738a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner break; 739a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner 74016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_START: 74116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 7423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 743128b52d3d75f4b74367de43e891cd98b5a9b5483Chris Lattner // Do not try to legalize the target-specific arguments (#1+) 74445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner Tmp2 = Node->getOperand(0); 7451aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (Tmp1 != Tmp2) 74688de6e77bfadea8962b017f372658204ab71448cChris Lattner Node->setAdjCallChain(Tmp1); 74727d404ccd1e86b7fffaf8037bf6b6dfb0b9d683bNate Begeman 74816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // Note that we do not create new CALLSEQ_DOWN/UP nodes here. These 74988de6e77bfadea8962b017f372658204ab71448cChris Lattner // nodes are treated specially and are mutated in place. This makes the dag 75088de6e77bfadea8962b017f372658204ab71448cChris Lattner // legalization process more efficient and also makes libcall insertion 75188de6e77bfadea8962b017f372658204ab71448cChris Lattner // easier. 7523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 753fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner case ISD::DYNAMIC_STACKALLOC: 754fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 755fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 756fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 757fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 758adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Tmp3 != Node->getOperand(2)) { 759adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 760adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 761adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 762adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 763adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner } else 764513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner Result = Op.getValue(0); 765fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 766fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // Since this op produces two values, make sure to remember that we 767fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // legalized both of them. 768fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 769fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 770fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner return Result.getValue(Op.ResNo); 771fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 772d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 7733d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner case ISD::CALL: { 7743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 7753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 7763d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 7773d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 7783d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 7793d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 7803d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 7813d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 7823d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 7833d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 7843d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || Changed) { 7853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 7863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(Node->getNumValues()); 7873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 788ebda942efcb86634a6581aae76a0d0c92c4a232eChris Lattner RetTyVTs.push_back(Node->getValueType(i)); 789d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Result = SDOperand(DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 790d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL), 0); 79138d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner } else { 79238d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner Result = Result.getValue(0); 7933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 79438d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // Since calls produce multiple values, make sure to remember that we 79538d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // legalized all of them. 79638d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 79738d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 79838d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner return Result.getValue(Op.ResNo); 7993d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 800c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 801c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 802c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner if (Tmp1 != Node->getOperand(0)) 803c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); 804c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 805c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner 806c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 807c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 80947e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 81047e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 81147e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 81247e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 81347e9223e06390897c3834f8c527001df392570ffChris Lattner break; 81447e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 81547e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 81647e9223e06390897c3834f8c527001df392570ffChris Lattner break; 81747e9223e06390897c3834f8c527001df392570ffChris Lattner } 8187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 8197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 8207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 8217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 8227cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 8237cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 8247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 8257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 8267cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8277cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 8287cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 829550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 830550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 831550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, MVT::i1); 832550b1e59c4eb5db020766012b1406fc56833251dChris Lattner 8337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 8347cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 8357cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 8367cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 8377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8397cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 8407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Basic block destination (Op#2) is always legal. 8417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 8427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 8437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 8447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8467cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8477cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 8487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 850c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 8517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 8527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 8537cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 8547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 8557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 8567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, Tmp3, Node->getOperand(4)); 8577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 8617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 8627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 8637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 8647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 8657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 8667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 8677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 8687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 8697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 8707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8717cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 8727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 8747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), 8757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, DAG.getConstant(0, Tmp2.getValueType()), 8767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 8777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 879c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 880411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case ISD::BRCONDTWOWAY: 881411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 882411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 883411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 884411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Legal: 885411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 886411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 887411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Promote: 888411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 889411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 890411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 891411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR 892411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // pair. 893411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { 894411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Promote: 895411e888c1b4155190c8cffe388631ee20693b309Chris Lattner default: assert(0 && "This action is not supported yet!"); 896411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Legal: 897411e888c1b4155190c8cffe388631ee20693b309Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 898411e888c1b4155190c8cffe388631ee20693b309Chris Lattner std::vector<SDOperand> Ops; 899411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp1); 900411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp2); 901411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(2)); 902411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(3)); 903411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); 904411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 905411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 906411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Expand: 9077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If BRTWOWAY_CC is legal for this target, then simply expand this node 9087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // to that. Otherwise, skip BRTWOWAY_CC and expand directly to a 9097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // BRCOND/BR pair. 910c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::BRTWOWAY_CC, MVT::Other)) { 9117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 9127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 9137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 9147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 9157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 9177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 9187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 9197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 922411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Node->getOperand(2)); 9237cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(3)); 9247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 925411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 926411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 927411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 9287cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BRTWOWAY_CC: 9297cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 930c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 9317cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 9327cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 9337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 9347cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 9357cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Node->getOperand(1), Tmp2, Tmp3, 9367cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 9377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9397cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 9417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 9427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 9437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 9447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If this target does not support BRTWOWAY_CC, lower it to a BRCOND/BR 9457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // pair. 9467cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other)) { 9477cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 9487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 9497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 9507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 9517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 9527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 9537cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 9547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 9557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 9567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 9577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 9597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 9607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 9617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 9647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 9657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 9667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(5)); 9677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: 9723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 9742d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 9753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 9763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 97752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(Node->getValueType(0), Tmp1, Tmp2, 97852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(2)); 9798afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner else 9808afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner Result = SDOperand(Node, 0); 981edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 9828afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // Since loads produce two values, make sure to remember that we legalized 9838afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // both of them. 9848afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 9858afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 9868afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner return Result.getValue(Op.ResNo); 9875fbb5d2459a5410590f285250faa604576308a93Nate Begeman 9880f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::EXTLOAD: 9890f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::SEXTLOAD: 99001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case ISD::ZEXTLOAD: { 9910f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9920f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 9930f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 9945f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner MVT::ValueType SrcVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 99501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), SrcVT)) { 99601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner default: assert(0 && "This action is not supported yet!"); 9971c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner case TargetLowering::Promote: 9981c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); 9995f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 10005f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), MVT::i8); 10011c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // Since loads produce two values, make sure to remember that we legalized 10021c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // both of them. 10031c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 10041c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 10051c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner return Result.getValue(Op.ResNo); 1006edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 100701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Legal: 100801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Tmp1 != Node->getOperand(0) || 100901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Tmp2 != Node->getOperand(1)) 10105f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 10115f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 101201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner else 101301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = SDOperand(Node, 0); 101401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner 101501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Since loads produce two values, make sure to remember that we legalized 101601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // both of them. 101701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 101801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 101901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(Op.ResNo); 102001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Expand: 10219d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth //f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 10229d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 10239d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth SDOperand Load = DAG.getLoad(SrcVT, Tmp1, Tmp2, Node->getOperand(2)); 102431559081a4285f4b7282e765aea4ec8a8e1d396cAndrew Lenharth Result = DAG.getNode(ISD::FP_EXTEND, Node->getValueType(0), Load); 10259d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (Op.ResNo) 10269d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Load.getValue(1); 10279d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Result; 10289d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 102901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(Node->getOpcode() != ISD::EXTLOAD && 103001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner "EXTLOAD should always be supported!"); 103101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 103201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // zero/sign extend inreg. 10335f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 10345f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 103523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner SDOperand ValRes; 103623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SEXTLOAD) 103723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 103815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, DAG.getValueType(SrcVT)); 103923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner else 104023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getZeroExtendInReg(Result, SrcVT); 104101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), ValRes); 104201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 104301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Op.ResNo) 104401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(1); 104501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return ValRes; 104601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 104701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(0 && "Unreachable"); 104801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 10495dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case ISD::EXTRACT_ELEMENT: { 10505dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman MVT::ValueType OpTy = Node->getOperand(0).getValueType(); 10515dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman switch (getTypeAction(OpTy)) { 10525dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman default: 10535dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman assert(0 && "EXTRACT_ELEMENT action for type unimplemented!"); 10545dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 10555dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Legal: 10565dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) { 10575dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 1 -> Hi 10585dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::SRL, OpTy, Node->getOperand(0), 10595dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman DAG.getConstant(MVT::getSizeInBits(OpTy)/2, 10605dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman TLI.getShiftAmountTy())); 10615dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Result); 10625dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } else { 10635dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 0 -> Lo 10645dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), 10655dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Node->getOperand(0)); 10665dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 10675dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = LegalizeOp(Result); 10685dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 10695dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Expand: 10705dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // Get both the low and high parts. 10715dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 10725dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) 10735dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp2; // 1 -> Hi 10745dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman else 10755dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp1; // 0 -> Lo 10765dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 10775dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 10783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10795dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 10803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 10813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 10823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1083edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1084c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getOperand(2).getValueType()) && 1085d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner "Register type must be legal!"); 1086d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // Legalize the incoming value (must be legal). 1087d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 1088d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) 1089d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::CopyToReg, MVT::Other, Tmp1, 1090d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getOperand(1), Tmp2); 10913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 10933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 10943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 10963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 2: // ret val 10973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 10983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 10993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 11008afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 11013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 11023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 11043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 11053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 11063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Lo, Hi); 1107edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 11083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 11108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 11118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 11128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 11133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 11163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 11173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); 11183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 11203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<SDOperand> NewValues; 11213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 11223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) 11233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(i).getValueType())) { 11243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 11254e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NewValues.push_back(LegalizeOp(Node->getOperand(i))); 11263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 11283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 11293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(i), Lo, Hi); 11303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Lo); 11313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Hi); 1132edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 11333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 11358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Can't promote multiple return value yet!"); 11363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); 11383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::STORE: 11433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 11443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 11453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 11465d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 114703c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ 11485d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner if (CFP->getValueType(0) == MVT::f32) { 114900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1150cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(FloatToBits(CFP->getValue()), 1151cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i32), 1152cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 115352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 11545d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } else { 11555d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); 115600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1157cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(DoubleToBits(CFP->getValue()), 1158cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i64), 1159cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 116052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 11615d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 116284734ce8ef1a21eb347d4deca0bf32d59001f751Chris Lattner Node = Result.Val; 11635d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 11645d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner 11653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 11663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: { 11673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Val = LegalizeOp(Node->getOperand(1)); 11683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Val != Node->getOperand(1) || Tmp1 != Node->getOperand(0) || 11693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(2)) 117052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, 117152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 11723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 117503c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Truncate the value and store the result. 117603c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(1)); 117703c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp3, Tmp2, 11782d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 11799fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getValueType(Node->getOperand(1).getValueType())); 118003c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 118103c8546ec57523970874917854a2fb77b1ff598eChris Lattner 11823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: 11833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 1184ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize; 11853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 11863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 11873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 11883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 11893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1190edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Lo = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Lo, Tmp2, 1191edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1192ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If this is a vector type, then we have to calculate the increment as 1193ab48be377298bd509427a29e174cf4e305138819Nate Begeman // the product of the element size in bytes, and the number of elements 1194ab48be377298bd509427a29e174cf4e305138819Nate Begeman // in the high half of the vector. 1195ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (MVT::Vector == Hi.getValueType()) { 1196ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElems = cast<ConstantSDNode>(Hi.getOperand(2))->getValue(); 1197ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Hi.getOperand(3))->getVT(); 1198ab48be377298bd509427a29e174cf4e305138819Nate Begeman IncrementSize = NumElems * MVT::getSizeInBits(EVT)/8; 1199ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 1200ab48be377298bd509427a29e174cf4e305138819Nate Begeman IncrementSize = MVT::getSizeInBits(Hi.getValueType())/8; 1201ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 12023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::ADD, Tmp2.getValueType(), Tmp2, 12033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 12043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Tmp2.getValueType()) && 12053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Pointers must be legal!"); 12062d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Again, claiming both parts of the store came form the same Instr 1207edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Hi, Tmp2, 1208edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1209ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1210ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner break; 12113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 121395762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 121495762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 12152c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 12162c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); 121795762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 121851b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth case ISD::READCYCLECOUNTER: 121951b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain 1220cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth if (Tmp1 != Node->getOperand(0)) { 1221cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth std::vector<MVT::ValueType> rtypes; 1222cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth std::vector<SDOperand> rvals; 1223cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rtypes.push_back(MVT::i64); 1224cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rtypes.push_back(MVT::Other); 1225cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rvals.push_back(Tmp1); 1226cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth Result = DAG.getNode(ISD::READCYCLECOUNTER, rtypes, rvals); 1227cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth } 122849c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth 122949c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // Since rdcc produce two values, make sure to remember that we legalized 123049c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // both of them. 123149c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth AddLegalizedOperand(SDOperand(Node, 0), Result); 123249c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 123349c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth return Result.getValue(Op.ResNo); 123451b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth break; 1235f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 12360f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::TRUNCSTORE: 12370f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 12380f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 12390f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 12400f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 12410f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Legal: 12420f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 124313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 124413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // The only promote case we handle is TRUNCSTORE:i1 X into 124513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // -> TRUNCSTORE:i8 (and X, 1) 124613d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner if (cast<VTSDNode>(Node->getOperand(4))->getVT() == MVT::i1 && 124713d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TLI.getOperationAction(ISD::TRUNCSTORE, MVT::i1) == 124813d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TargetLowering::Promote) { 124913d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // Promote the bool to a mask then store. 125013d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp2 = DAG.getNode(ISD::AND, Tmp2.getValueType(), Tmp2, 125113d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner DAG.getConstant(1, Tmp2.getValueType())); 125213d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 125313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Node->getOperand(3), DAG.getValueType(MVT::i8)); 125413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 125513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } else if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 125613d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp3 != Node->getOperand(2)) { 125745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 12589fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner Node->getOperand(3), Node->getOperand(4)); 125913d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } 12600f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 12610f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Promote: 12620f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Expand: 12630f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(0 && "Cannot handle illegal TRUNCSTORE yet!"); 12640f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner } 12650f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 12662ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 126747e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 126847e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 126947e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 127047e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 127147e9223e06390897c3834f8c527001df392570ffChris Lattner break; 127247e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 127347e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 127447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 127547e9223e06390897c3834f8c527001df392570ffChris Lattner } 12763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 12772ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 127855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 1279b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { 128055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 12819373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 12829373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 12839373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1.getOperand(0), Tmp1.getOperand(1), 12849373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 12859373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 12869373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 1287550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 1288550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 1289550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, MVT::i1); 12909373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1, 12919373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 12929373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 12939373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 12949373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 129555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 129655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 129755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 != Node->getOperand(2)) 129855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), 129955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp1, Tmp2, Tmp3); 130055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 130155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 130255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner MVT::ValueType NVT = 130355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 130455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 130555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (MVT::isInteger(Tmp2.getValueType())) { 130613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner ExtOp = ISD::ANY_EXTEND; 130755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::TRUNCATE; 130855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 130955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::FP_EXTEND; 131055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::FP_ROUND; 131155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 131255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 131355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp2 = DAG.getNode(ExtOp, NVT, Tmp2); 131455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 = DAG.getNode(ExtOp, NVT, Tmp3); 131555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 131655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2,Tmp3); 131755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(TruncOp, Node->getValueType(0), Result); 131855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 131955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 132055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 13213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13229373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 13239373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 13249373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 13259373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 1326c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(0).getValueType())) { 132723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner // Everything is legal, see if we should expand this op or something. 132823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner switch (TLI.getOperationAction(ISD::SELECT_CC, 132923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0).getValueType())) { 133023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner default: assert(0 && "This action is not supported yet!"); 133123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Custom: { 133223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner SDOperand Tmp = 133323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner TLI.LowerOperation(DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), 133423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0), 133523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(1), Tmp3, Tmp4, 1336d7050a9c50211dd215cb3c2bc28b4fb6bfa4a116Chris Lattner Node->getOperand(4)), DAG); 133723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp.Val) { 133823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = LegalizeOp(Tmp); 133923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 134023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 134123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } // FALLTHROUGH if the target can't lower this operation after all. 134223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Legal: 134323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 134423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 134523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 134623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3)) { 134723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), Tmp1, Tmp2, 134823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3, Tmp4, Node->getOperand(4)); 134923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 135023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 13519373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 13529373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 13539373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 13549373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp1 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 13559373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(0), // LHS 13569373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), // RHS 13579373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4))); 13587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 13597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 13607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 13617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 13627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 13637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, Tmp3.getValueType(), 13647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1.getOperand(0), Tmp1.getOperand(1), 13657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, Tmp1.getOperand(2)); 13667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 13677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getSelectCC(Tmp1, 13687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 13697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, ISD::SETNE); 13707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 13719373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 13729373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 13733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 13743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 13753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 13763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 13773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 13783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 13808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // LHS 13818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // RHS 13828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 13838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // If this is an FP compare, the operands have already been extended. 13848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(Node->getOperand(0).getValueType())) { 13858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner MVT::ValueType VT = Node->getOperand(0).getValueType(); 138671c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 13878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 13888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Otherwise, we have to insert explicit sign or zero extends. Note 13898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // that we could insert sign extends for ALL conditions, but zero extend 13908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // is cheaper on many machines (an AND instead of two shifts), so prefer 13918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // it. 13927cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 13938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner default: assert(0 && "Unknown integer comparison!"); 13948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETEQ: 13958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETNE: 13968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGE: 13978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGT: 13988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULE: 13998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULT: 14008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // ALL of these operations will work if we either sign or zero extend 14018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // the operands (including the unsigned comparisons!). Zero extend is 14028b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // usually a simpler/cheaper operation, so prefer it. 140323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 140423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 14058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 14068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGE: 14078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGT: 14088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLT: 14098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLE: 141015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 141115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 141215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 141315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 14148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 14158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 14168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 14173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1418edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case Expand: 14193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 14203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LHSLo, LHSHi); 14213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RHSLo, RHSHi); 14227cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 14233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETEQ: 14243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETNE: 142508b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSLo == RHSHi) 142608b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 142708b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSCST->isAllOnesValue()) { 142808b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner // Comparison to -1. 142908b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Tmp1 = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 1430b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSLo; 1431edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 143208b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner } 143308b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner 14343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 14353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 14363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp2); 1437b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 14383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 14393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 14405b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 14415b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // X > -1, x < 0 14425b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Node->getOperand(1))) 14437cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner if ((cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETLT && 14445b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner CST->getValue() == 0) || // X < 0 14457cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner (cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETGT && 1446b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman (CST->isAllOnesValue()))) { // X > -1 1447b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp1 = LHSHi; 1448b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSHi; 1449b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1450b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 14515b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner 14523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: This generated code sucks. 14533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ISD::CondCode LowCC; 14547cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 14553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: assert(0 && "Unknown integer setcc!"); 14563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLT: 14573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 14583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGT: 14593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 14603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLE: 14613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 14623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGE: 14633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 14643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1465edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 14663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 14673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 14683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 14693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 14703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 14713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 14727cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp1 = DAG.getSetCC(Node->getValueType(0), LHSLo, RHSLo, LowCC); 14737cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getNode(ISD::SETCC, Node->getValueType(0), LHSHi, RHSHi, 14747cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 14757cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getSetCC(Node->getValueType(0), LHSHi, RHSHi, ISD::SETEQ); 1476b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1477b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result, Tmp1, Tmp2)); 1478b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman return Result; 14793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 14803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1481b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman 1482b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch(TLI.getOperationAction(ISD::SETCC, Node->getOperand(0).getValueType())) { 1483b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman default: 1484b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman assert(0 && "Cannot handle this action for SETCC yet!"); 1485b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1486ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth case TargetLowering::Promote: { 1487ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // First step, figure out the appropriate operation to use. 1488ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Allow SETCC to not be supported for all legal data types 1489ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Mostly this targets FP 1490ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth MVT::ValueType NewInTy = Node->getOperand(0).getValueType(); 1491ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth MVT::ValueType OldVT = NewInTy; 1492ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1493ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Scan for the appropriate larger type to use. 1494ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth while (1) { 1495ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth NewInTy = (MVT::ValueType)(NewInTy+1); 1496ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1497ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(MVT::isInteger(NewInTy) == MVT::isInteger(OldVT) && 1498ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the integer world"); 1499ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(MVT::isFloatingPoint(NewInTy) == MVT::isFloatingPoint(OldVT) && 1500ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the floating point world"); 1501ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1502ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // If the target supports SETCC of this type, use it. 1503ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth if (TLI.getOperationAction(ISD::SETCC, NewInTy) == TargetLowering::Legal) 1504ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth break; 1505ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1506ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth if (MVT::isInteger(NewInTy)) 1507ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(0 && "Cannot promote Legal Integer SETCC yet"); 1508ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth else { 1509ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth Tmp1 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp1); 1510ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth Tmp2 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp2); 1511ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1512ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 15135e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 15145e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Node->getOperand(2)); 15155e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth break; 1516ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1517b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Legal: 1518b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1519b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 1520b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1521b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1522b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Expand: 1523b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // Expand a setcc node into a select_cc of the same condition, lhs, and 1524b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // rhs that selects between const 1 (true) and const 0 (false). 1525b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman MVT::ValueType VT = Node->getValueType(0); 1526b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SELECT_CC, VT, Tmp1, Tmp2, 1527b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman DAG.getConstant(1, VT), DAG.getConstant(0, VT), 1528b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1529b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(Result); 1530b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1531b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 15323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 15333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1534e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMSET: 1535e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMCPY: 1536e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMMOVE: { 1537deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Chain 1538e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Pointer 1539e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner 1540e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { // memset = ubyte 1541e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner switch (getTypeAction(Node->getOperand(2).getValueType())) { 1542e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand a byte!"); 1543e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1544deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 1545e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1546e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1547deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); 1548e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1549e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1550e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } else { 1551edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Tmp3 = LegalizeOp(Node->getOperand(2)); // memcpy/move = pointer, 1552e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1553272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1554272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp4; 1555272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(3).getValueType())) { 15566814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner case Expand: { 15576814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner // Length is too big, just take the lo-part of the length. 15586814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner SDOperand HiPart; 15596814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner ExpandOp(Node->getOperand(3), HiPart, Tmp4); 15606814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner break; 15616814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner } 1562e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1563e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = LegalizeOp(Node->getOperand(3)); 1564e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1565e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1566e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = PromoteOp(Node->getOperand(3)); 1567272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1568272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner } 1569272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1570272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp5; 1571272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(4).getValueType())) { // uint 1572272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 1573272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Legal: 1574272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner Tmp5 = LegalizeOp(Node->getOperand(4)); 1575272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1576272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Promote: 1577e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp5 = PromoteOp(Node->getOperand(4)); 1578e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1579e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 158055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 158155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 158255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 158307dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 158407dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 158507dffd6af673c73352150583150b242a93694f00Chris Lattner TLI.LowerOperation(DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, 158607dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp2, Tmp3, Tmp4, Tmp5), DAG); 158707dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 158807dffd6af673c73352150583150b242a93694f00Chris Lattner Result = LegalizeOp(Tmp); 158907dffd6af673c73352150583150b242a93694f00Chris Lattner break; 159007dffd6af673c73352150583150b242a93694f00Chris Lattner } 159107dffd6af673c73352150583150b242a93694f00Chris Lattner // FALLTHROUGH if the target thinks it is legal. 159207dffd6af673c73352150583150b242a93694f00Chris Lattner } 159355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 1594e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 1595e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || 1596e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp5 != Node->getOperand(4)) { 1597e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<SDOperand> Ops; 1598e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 1599e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 1600e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 1601e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 160255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 160355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: { 1604e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Otherwise, the target does not support this operation. Lower the 1605e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // operation to an explicit libcall as appropriate. 1606e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 1607e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner const Type *IntPtrTy = TLI.getTargetData().getIntPtrType(); 1608e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1609e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 16103bfbf4ea990930d153e58e153f319408341a94feReid Spencer const char *FnName = 0; 1611e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { 1612e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1613e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Extend the ubyte argument to be an int value for the call. 1614e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Tmp3); 1615e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, Type::IntTy)); 1616e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1617e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 1618e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = "memset"; 1619e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else if (Node->getOpcode() == ISD::MEMCPY || 1620e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Node->getOpcode() == ISD::MEMMOVE) { 1621e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1622e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, IntPtrTy)); 1623e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1624e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = Node->getOpcode() == ISD::MEMMOVE ? "memmove" : "memcpy"; 1625e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else { 1626e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner assert(0 && "Unknown op!"); 1627e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 162845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 1629e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 1630adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(Tmp1, Type::VoidTy, false, CallingConv::C, false, 1631e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner DAG.getExternalSymbol(FnName, IntPtr), Args, DAG); 1632c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner Result = CallResult.second; 1633c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner NeedsAnotherIteration = true; 163455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 163555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 1636e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 1637e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner break; 1638e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 163952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 164052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::READPORT: 164152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 164252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 16436d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 16443e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 16453e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 16463e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 16473e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 16483e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 16493e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 16503e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 165152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = SDOperand(Node, 0); 165252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // Since these produce two values, make sure to remember that we legalized 165352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // both of them. 165452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 165552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 165652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner return Result.getValue(Op.ResNo); 165752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::WRITEPORT: 165852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 165952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 166052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 166152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 166252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 != Node->getOperand(2)) 166352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 166452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner break; 166552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 16666d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::READIO: 16676d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 16686d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 16696d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 16706d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 16716d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 16726d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 16736d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 16743e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 16753e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 16763e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 16773e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 16783e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 16793e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 16803e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 16816d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = SDOperand(Node, 0); 16826d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 16836d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 16846d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a load from memory. 16856d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0), 16866d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), DAG.getSrcValue(NULL)); 16876d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 16886d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 16896d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 16906d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 16916d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Since these produce two values, make sure to remember that we legalized 16926d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // both of them. 16936d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 16946d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 16956d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner return Result.getValue(Op.ResNo); 16966d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 16976d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::WRITEIO: 16986d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 16996d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 17006d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 17016d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 17026d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 17036d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1).getValueType())) { 17046d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 17056d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 17066d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 17076d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 17086d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 != Node->getOperand(2)) 17096d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 17106d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 17116d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 17126d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a store to memory. 17136d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0), 17146d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), Node->getOperand(2), 17156d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getSrcValue(NULL)); 17166d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 17176d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 17186d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 17196d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 17206d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 172184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::ADD_PARTS: 17225b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SUB_PARTS: 17235b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 17245b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 17255b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 172684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 172784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 172884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 172984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 173084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 173184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 1732e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (Changed) { 1733e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 1734e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 1735e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 17362c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 17372c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 17382c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 17392c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 17402c8086f4b9916b2d02842be5e375276023225fbaChris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 17412c8086f4b9916b2d02842be5e375276023225fbaChris Lattner return Result.getValue(Op.ResNo); 174284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 17432c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 17442c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 17453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 17463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 17473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 1748c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 1749c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 17503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 17513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 17523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 17533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 17543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 175503c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 175603c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 175703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 175801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 175901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 176001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 176101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 17623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1763f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth switch (getTypeAction(Node->getOperand(1).getValueType())) { 1764f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Expand: assert(0 && "Not possible"); 1765f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Legal: 1766f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 1767f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1768f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Promote: 1769f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the RHS. 1770f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1771f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth } 17723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 17733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 17743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 17753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1776edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1777419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case ISD::BUILD_PAIR: { 1778419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman MVT::ValueType PairTy = Node->getValueType(0); 1779419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman // TODO: handle the case where the Lo and Hi operands are not of legal type 1780419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Lo 1781419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Hi 1782419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman switch (TLI.getOperationAction(ISD::BUILD_PAIR, PairTy)) { 1783419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Legal: 1784419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1785419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = DAG.getNode(ISD::BUILD_PAIR, PairTy, Tmp1, Tmp2); 1786419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1787419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Promote: 1788419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Custom: 1789419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman assert(0 && "Cannot promote/custom this yet!"); 1790419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Expand: 1791419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, PairTy, Tmp1); 1792419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::ANY_EXTEND, PairTy, Tmp2); 1793419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::SHL, PairTy, Tmp2, 1794419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman DAG.getConstant(MVT::getSizeInBits(PairTy)/2, 1795419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman TLI.getShiftAmountTy())); 1796419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::OR, PairTy, Tmp1, Tmp2)); 1797419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1798419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 1799419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1800419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 1801419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman 1802c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 1803c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 180401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 1805c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1806c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 1807c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1808c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Legal: 1809c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman if (Tmp1 != Node->getOperand(0) || 1810c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 != Node->getOperand(1)) 1811edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 1812c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2); 1813c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1814c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Promote: 1815c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Custom: 1816c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman assert(0 && "Cannot promote/custom handle this yet!"); 18174c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner case TargetLowering::Expand: 18184c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner if (MVT::isInteger(Node->getValueType(0))) { 18194c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner MVT::ValueType VT = Node->getValueType(0); 18204c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner unsigned Opc = (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 18214c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(Opc, VT, Tmp1, Tmp2); 18224c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::MUL, VT, Result, Tmp2); 18234c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::SUB, VT, Tmp1, Result); 18244c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner } else { 18254c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner // Floating point mod -> fmod libcall. 18264c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner const char *FnName = Node->getValueType(0) == MVT::f32 ? "fmodf":"fmod"; 18274c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner SDOperand Dummy; 18284c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = ExpandLibCall(FnName, Node, Dummy); 1829c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1830c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1831c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1832c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 18332c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 1834691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1835691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1836691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1837691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 1838691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1839691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 1840691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth if (Tmp1 != Node->getOperand(0)) 1841691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1842691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1843691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 1844691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType OVT = Tmp1.getValueType(); 1845691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 1846edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 1847edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 1848691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 1849691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 1850691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1851691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch(Node->getOpcode()) 1852691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth { 1853691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1854691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 1855691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1856691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1857691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 18587cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 18597cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), 18607cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ); 186100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 1862691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(OVT),NVT), Tmp1); 1863691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1864691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1865691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 186600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 186700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 1868691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getSizeInBits(OVT), NVT)); 1869691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1870691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1871691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1872691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1873691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Custom: 1874691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth assert(0 && "Cannot custom handle this yet!"); 1875691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 1876ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth switch(Node->getOpcode()) 1877ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth { 1878ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth case ISD::CTPOP: { 1879e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner static const uint64_t mask[6] = { 1880e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 1881e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 1882e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 1883e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner }; 1884ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth MVT::ValueType VT = Tmp1.getValueType(); 1885e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner MVT::ValueType ShVT = TLI.getShiftAmountTy(); 1886e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner unsigned len = getSizeInBits(VT); 1887e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 1888ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 1889e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp2 = DAG.getConstant(mask[i], VT); 1890e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp3 = DAG.getConstant(1ULL << i, ShVT); 189100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::ADD, VT, 1892ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, Tmp1, Tmp2), 1893ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, 1894ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3), 1895ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp2)); 1896ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1897ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Result = Tmp1; 1898ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1899ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 190057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTLZ: { 190157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina /* for now, we do this: 19025c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 1); 19035c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 2); 19045c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner ... 19055c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>16); 190600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen x = x | (x >>32); // for 64-bit input 19075c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner return popcount(~x); 190800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 19095c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner but see also: http://www.hackersdelight.org/HDcode/nlz.cc */ 19105c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 191157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina MVT::ValueType ShVT = TLI.getShiftAmountTy(); 191257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina unsigned len = getSizeInBits(VT); 191357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 191457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getConstant(1ULL << i, ShVT); 191500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::OR, VT, Tmp1, 191657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3)); 191757ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 191857ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getNode(ISD::XOR, VT, Tmp1, DAG.getConstant(~0ULL, VT)); 19195c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 192018aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 192157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 192257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTTZ: { 192300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen // for now, we use: { return popcount(~x & (x - 1)); } 1924d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // unless the target has ctlz but not ctpop, in which case we use: 1925d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // { return 32 - nlz(~x & (x-1)); } 1926d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // see also http://www.hackersdelight.org/HDcode/ntz.cc 19275c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 19285c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp2 = DAG.getConstant(~0ULL, VT); 192900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp3 = DAG.getNode(ISD::AND, VT, 19305c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::XOR, VT, Tmp1, Tmp2), 19315c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::SUB, VT, Tmp1, 19325c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getConstant(1, VT))); 1933d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // If ISD::CTLZ is legal and CTPOP isn't, then do that instead 1934c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::CTPOP, VT) && 1935c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::CTLZ, VT)) { 193600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = LegalizeOp(DAG.getNode(ISD::SUB, VT, 1937d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getConstant(getSizeInBits(VT), VT), 1938d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getNode(ISD::CTLZ, VT, Tmp3))); 1939d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } else { 1940d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 1941d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } 194218aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 194357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 1944ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth default: 1945ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth assert(0 && "Cannot expand this yet!"); 1946ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1947ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1948691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1949691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1950691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 195100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 19522c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 19532c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 19542c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 1955da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 1956da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 1957da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 19582c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 19592c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 19602c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 19612c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 19622c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 19632c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 19642c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Promote: 19652c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Custom: 19662c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Cannot promote/custom handle this yet!"); 19672c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 1968f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1969f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FNEG: { 19702c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 19712c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 197201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = LegalizeOp(DAG.getNode(ISD::FSUB, Node->getValueType(0), 19732c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2, Tmp1)); 1974f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1975f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1976f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 19774af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 19784af6e0d7836126630f579b0a34f054321187f00bChris Lattner MVT::ValueType VT = Node->getValueType(0); 19794af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 19807cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, Tmp2, ISD::SETUGT); 19814af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp3 = DAG.getNode(ISD::FNEG, VT, Tmp1); 19824af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = DAG.getNode(ISD::SELECT, VT, Tmp2, Tmp1, Tmp3); 19834af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = LegalizeOp(Result); 1984f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1985f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1986f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: 1987f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: 1988f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: { 1989f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner MVT::ValueType VT = Node->getValueType(0); 1990f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner const char *FnName = 0; 1991f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1992f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: FnName = VT == MVT::f32 ? "sqrtf" : "sqrt"; break; 1993f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: FnName = VT == MVT::f32 ? "sinf" : "sin"; break; 1994f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: FnName = VT == MVT::f32 ? "cosf" : "cos"; break; 1995f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 1996f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 19972ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman SDOperand Dummy; 19982ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman Result = ExpandLibCall(FnName, Node, Dummy); 1999f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 2000f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2001f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: 20024af6e0d7836126630f579b0a34f054321187f00bChris Lattner assert(0 && "Unreachable!"); 20032c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 20042c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 20052c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 20062c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 20072c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 20082c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 2009fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::SINT_TO_FP: 2010fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::UINT_TO_FP: { 2011fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP; 2012fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2013fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2014d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen switch (TLI.getOperationAction(Node->getOpcode(), 2015fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType())) { 2016fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner default: assert(0 && "Unknown operation action!"); 2017fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Expand: 20186269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = ExpandLegalINT_TO_FP(isSigned, 20196269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey LegalizeOp(Node->getOperand(0)), 20206269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Node->getValueType(0)); 2021fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 2022fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 2023fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Promote: 2024fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteLegalINT_TO_FP(LegalizeOp(Node->getOperand(0)), 2025fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), 2026fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner isSigned); 2027fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 2028fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 2029fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Legal: 2030fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 20315b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth case TargetLowering::Custom: { 20325b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); 20335b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth SDOperand Tmp = 20345b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 20355b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth Tmp = TLI.LowerOperation(Tmp, DAG); 20365b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth if (Tmp.Val) { 20375b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth AddLegalizedOperand(Op, Tmp); 20385b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth NeedsAnotherIteration = true; 20395b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth return Tmp; 20405b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } else { 20415b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth assert(0 && "Target Must Lower this"); 20425b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } 20435b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } 2044fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2045fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 2046fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2047fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2048fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2049fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2050fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2051fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, 2052fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), Node->getOperand(0)); 2053fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2054fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2055fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (isSigned) { 2056fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2057fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 2058fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result, DAG.getValueType(Node->getOperand(0).getValueType())); 2059fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SINT_TO_FP, Op.getValueType(), Result); 2060fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } else { 2061fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2062fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getZeroExtendInReg(Result, 2063fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType()); 2064fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::UINT_TO_FP, Op.getValueType(), Result); 2065fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2066fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2067fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2068fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2069fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2070fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::TRUNCATE: 2071fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2072fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2073fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2074fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2075fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2076fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2077fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2078fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 2079fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 2080fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // Since the result is legal, we should just be able to truncate the low 2081fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // part of the source. 2082fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Tmp1); 2083fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2084fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2085fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2086fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Op.getValueType(), Result); 2087fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2088fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2089fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2090d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 2091fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_SINT: 2092fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_UINT: 2093fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2094fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2095f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2096f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner 20971618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))){ 20981618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: assert(0 && "Unknown operation action!"); 20991618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Expand: 2100d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT) { 2101d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman SDOperand True, False; 2102d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType VT = Node->getOperand(0).getValueType(); 2103d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType NVT = Node->getValueType(0); 2104d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman unsigned ShiftAmt = MVT::getSizeInBits(Node->getValueType(0))-1; 2105d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getConstantFP((double)(1ULL << ShiftAmt), VT); 2106d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp3 = DAG.getSetCC(TLI.getSetCCResultTy(), 2107d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Node->getOperand(0), Tmp2, ISD::SETLT); 2108d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman True = DAG.getNode(ISD::FP_TO_SINT, NVT, Node->getOperand(0)); 2109d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::FP_TO_SINT, NVT, 211001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getNode(ISD::FSUB, VT, Node->getOperand(0), 2111d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2)); 2112d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::XOR, NVT, False, 2113d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getConstant(1ULL << ShiftAmt, NVT)); 2114d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, NVT, Tmp3, True, False)); 21152d56e72f09337a1cab3ba199a9467c159296f3faNate Begeman return Result; 2116d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2117d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman assert(0 && "Do not know how to expand FP_TO_SINT yet!"); 2118d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 2119d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman break; 21201618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Promote: 2121f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = PromoteLegalFP_TO_INT(Tmp1, Node->getValueType(0), 21221618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner Node->getOpcode() == ISD::FP_TO_SINT); 21231618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner AddLegalizedOperand(Op, Result); 21241618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return Result; 212507dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 212607dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 212707dffd6af673c73352150583150b242a93694f00Chris Lattner DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 212807dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp = TLI.LowerOperation(Tmp, DAG); 212907dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 213007dffd6af673c73352150583150b242a93694f00Chris Lattner AddLegalizedOperand(Op, Tmp); 213107dffd6af673c73352150583150b242a93694f00Chris Lattner NeedsAnotherIteration = true; 2132507f752f6ed28aa9f0ae680e95bfc93df4e9e2dcChris Lattner return Tmp; 213307dffd6af673c73352150583150b242a93694f00Chris Lattner } else { 213407dffd6af673c73352150583150b242a93694f00Chris Lattner // The target thinks this is legal afterall. 213507dffd6af673c73352150583150b242a93694f00Chris Lattner break; 213607dffd6af673c73352150583150b242a93694f00Chris Lattner } 213707dffd6af673c73352150583150b242a93694f00Chris Lattner } 21381618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 21391618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 21401618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 2141d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 2142fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2143fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2144fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2145fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2146fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2147fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2148fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2149fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2150fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2151fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2152fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2153d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 215413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 21553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 21563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 215703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_EXTEND: 215803c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_ROUND: 21593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 21603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 21613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 21623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 21633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 21643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2165b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner case Expand: 21662c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2167b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner 216803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Promote: 216903c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 217013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 217113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = PromoteOp(Node->getOperand(0)); 217213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 217313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 21741713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner case ISD::ZERO_EXTEND: 21751713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 217613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 217723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 217823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 217903c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 218003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SIGN_EXTEND: 21811713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 218213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 21831713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 218415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 218515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 21861713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 218703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_EXTEND: 21881713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 21891713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner if (Result.getValueType() != Op.getValueType()) 21901713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner // Dynamically dead while we have only 2 FP types. 21911713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::FP_EXTEND, Op.getValueType(), Result); 21921713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 219303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_ROUND: 2194f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 2195f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2196f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 219703c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 21983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 21993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 22000f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 220123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 22020f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 220315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 220445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 220545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 220645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 220755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 220855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 220955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 221055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0)) 221155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 22125f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner DAG.getValueType(ExtraVT)); 221355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 221455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 221545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 221623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 221745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 221845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 221945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned BitsDiff = MVT::getSizeInBits(Node->getValueType(0)) - 222045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::getSizeInBits(ExtraVT); 222127ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner SDOperand ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 222245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SHL, Node->getValueType(0), 222345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 222445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SRA, Node->getValueType(0), 222545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 222645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 222745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // The only way we can lower this is to turn it into a STORETRUNC, 222845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 222945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 223045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 223145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 223245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 223345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner const Type *Ty = MVT::getTypeForValueType(ExtraVT); 223445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned TySize = (unsigned)TLI.getTargetData().getTypeSize(Ty); 223545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 223645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 2237edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman int SSFI = 223845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 223945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 224045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, DAG.getEntryNode(), 224152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(0), StackSlot, 22429fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getSrcValue(NULL), DAG.getValueType(ExtraVT)); 22435f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 22445f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result, StackSlot, DAG.getSrcValue(NULL), 22455f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner ExtraVT); 224645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 224745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 224845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 224945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = LegalizeOp(Result); 225055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 225145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 22520f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 22533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 225445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 22553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 225645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 225745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 225845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 22593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 22603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 22613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 22628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// PromoteOp - Given an operation that produces a value in an invalid type, 22638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// promote it to compute the value into a larger type. The produced value will 22648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// have the correct bits for the low portion of the register, but no guarantee 22658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// is made about the top bits: it may be zero, sign-extended, or garbage. 226603c8546ec57523970874917854a2fb77b1ff598eChris LattnerSDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) { 226703c8546ec57523970874917854a2fb77b1ff598eChris Lattner MVT::ValueType VT = Op.getValueType(); 226871c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 226903c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(getTypeAction(VT) == Promote && 227003c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Caller should expand or legalize operands that are not promotable!"); 227103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(NVT > VT && MVT::isInteger(NVT) == MVT::isInteger(VT) && 227203c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Cannot promote to smaller type!"); 227303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 227403c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Tmp1, Tmp2, Tmp3; 227503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 227603c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Result; 227703c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDNode *Node = Op.Val; 227803c8546ec57523970874917854a2fb77b1ff598eChris Lattner 22796fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op); 22806fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != PromotedNodes.end()) return I->second; 228145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 22820f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // Promotion needs an optimization step to clean up after it, and is not 22830f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // careful to avoid operations the target does not support. Make sure that 22840f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // all generated operations are legalized in the next iteration. 22850f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner NeedsAnotherIteration = true; 22860f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 228703c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 2288d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2289d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 229003c8546ec57523970874917854a2fb77b1ff598eChris Lattner default: 229103c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 229203c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(0 && "Do not know how to promote this operator!"); 229303c8546ec57523970874917854a2fb77b1ff598eChris Lattner abort(); 2294fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2295fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getNode(ISD::UNDEF, NVT); 2296fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 229703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::Constant: 2298ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner if (VT != MVT::i1) 2299ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND, NVT, Op); 2300ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner else 2301ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, NVT, Op); 230203c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantSDNode>(Result) && "Didn't constant fold zext?"); 230303c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 230403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::ConstantFP: 230503c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::FP_EXTEND, NVT, Op); 230603c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantFPSDNode>(Result) && "Didn't constant fold fp_extend?"); 230703c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2308ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner 230982fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner case ISD::SETCC: 2310c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(TLI.getSetCCResultTy()) && "SetCC type is not legal??"); 23117cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(),Node->getOperand(0), 23127cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(1), Node->getOperand(2)); 231382fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = LegalizeOp(Result); 231482fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner break; 231503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 231603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 231703c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 231803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Legal: 231903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 232003c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.getValueType() >= NVT && 232103c8546ec57523970874917854a2fb77b1ff598eChris Lattner "This truncation doesn't make sense!"); 232203c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (Result.getValueType() > NVT) // Truncate to NVT instead of VT 232303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Result); 232403c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2325e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner case Promote: 2326e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // The truncation is not required, because we don't guarantee anything 2327e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // about high bits anyway. 2328e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner Result = PromoteOp(Node->getOperand(0)); 2329e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner break; 233003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Expand: 233179e46acd35df36477029e9f534ab1a366a98df56Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 233279e46acd35df36477029e9f534ab1a366a98df56Nate Begeman // Truncate the low part of the expanded value to the result type 2333e21c305ed85b2be4a27784ba52471f6b68fdd255Chris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Tmp1); 233403c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 233503c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 23368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SIGN_EXTEND: 23378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::ZERO_EXTEND: 233813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 23398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 23408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Smaller reg should have been promoted!"); 23418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 23428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Just do extend all the way to the larger type. 23438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 23448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 23458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23468b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 23478b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Promote the reg if it's smaller. 23488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 23498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The high bits are not guaranteed to be anything. Insert an extend. 23508b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND) 2351595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 235215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 235313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner else if (Node->getOpcode() == ISD::ZERO_EXTEND) 235423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 235523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 23568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 23588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 23608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_EXTEND: 23618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Case not implemented. Dynamically dead with 2 FP types!"); 23628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_ROUND: 23638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 23648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Cannot expand FP regs!"); 23658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: assert(0 && "Unreachable with 2 FP types!"); 23668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 23678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Do an FP_ROUND_INREG. 23688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 236915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 237015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 23718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 23738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 23758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SINT_TO_FP: 23768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UINT_TO_FP: 23778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 23788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 23798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 238077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 238177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 23828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 23848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 23858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 23868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP) 23878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 238815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 238915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 23908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 239123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 239223993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 239377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 239477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 23958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 239777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, NVT, 239877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOperand(0)); 239977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // Round if we cannot tolerate excess precision. 240077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (NoExcessFPPrecision) 240115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 240215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 240377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 24048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 24058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 24075e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner case ISD::SIGN_EXTEND_INREG: 24085e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Result = PromoteOp(Node->getOperand(0)); 24095e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 24105e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Node->getOperand(1)); 24115e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner break; 24128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_SINT: 24138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_UINT: 24148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 24158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 24168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 24178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 24198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input result is prerounded, so we don't have to do anything 24208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // special. 24218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 24228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 24248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "not implemented"); 24258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 2426d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // If we're promoting a UINT to a larger size, check to see if the new node 2427d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 2428d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // we can use that instead. This allows us to generate better code for 2429d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 2430d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // legal, such as PowerPC. 2431d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT && 2432c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) && 2433b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman (TLI.isOperationLegal(ISD::FP_TO_SINT, NVT) || 2434b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman TLI.getOperationAction(ISD::FP_TO_SINT, NVT)==TargetLowering::Custom)){ 2435d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(ISD::FP_TO_SINT, NVT, Tmp1); 2436d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2437d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2438d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 24398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 24412c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 24422c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 24432c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 24442c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(Tmp1.getValueType() == NVT); 24452c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 24462c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NOTE: we do not have to do any extra rounding here for 24472c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NoExcessFPPrecision, because we know the input will have the appropriate 24482c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // precision, and these operations don't modify precision at all. 24492c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 24502c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 2451da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2452da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2453da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 2454da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 2455da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner assert(Tmp1.getValueType() == NVT); 2456da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2457da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner if(NoExcessFPPrecision) 245815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 245915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 2460da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner break; 2461da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner 246203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::AND: 246303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::OR: 246403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::XOR: 24650f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::ADD: 24668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SUB: 24670f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::MUL: 24680f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // The input may have strange things in the top bits of the registers, but 246901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. They may have weird bits going out, but 24700f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // that too is okay if they are integer operations. 24710f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 24720f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 24730f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 24740f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 247501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 247601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 247701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 247801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 247901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // The input may have strange things in the top bits of the registers, but 248001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. 248101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 248201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 248301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 248401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 248501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 248601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Floating point operations will give excess precision that we may not be 248701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // able to tolerate. If we DO allow excess precision, just leave it, 248801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // otherwise excise it. 24898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // FIXME: Why would we need to round FP ops more than integer ones? 24908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Is Round(Add(Add(A,B),C)) != Round(Add(Round(Add(A,B)), C)) 249101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 249215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 249315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 24940f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 24950f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 24968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SDIV: 24978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SREM: 24988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be sign extended. 24998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 25008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 25018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(NVT)) { 250215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 250315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 250415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 250515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 25068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 25078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 25088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 25098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 25108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 251115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 251215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 25138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 251401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 251501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 251601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // These operators require that their input be fp extended. 251701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 251801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 251901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 252001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 252101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 252201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 252301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 252401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getValueType(VT)); 252501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 25268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 25278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UDIV: 25288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UREM: 25298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be zero extended. 25308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 25318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 25328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(MVT::isInteger(NVT) && "Operators don't apply to FP!"); 253323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 253423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 25358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 25368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 25378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 25388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SHL: 25398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 25408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 25418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SHL, NVT, Tmp1, Tmp2); 25428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 25438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRA: 25448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly sign extended. 25458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 254615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 254715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 25488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 25498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRA, NVT, Tmp1, Tmp2); 25508b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 25518b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRL: 25528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly zero extended. 25538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 255423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 25558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 25568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRL, NVT, Tmp1, Tmp2); 25578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 255803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::LOAD: 255903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 256003c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2561ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Result = DAG.getExtLoad(ISD::EXTLOAD, NVT, Tmp1, Tmp2, 2562ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Node->getOperand(2), VT); 256303c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Remember that we legalized the chain. 256403c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 256503c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 25664c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::SEXTLOAD: 25674c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::ZEXTLOAD: 25684c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::EXTLOAD: 25694c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 25704c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 25718136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), NVT, Tmp1, Tmp2, 25728136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Node->getOperand(2), 25738136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner cast<VTSDNode>(Node->getOperand(3))->getVT()); 25744c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner // Remember that we legalized the chain. 25754c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 25764c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner break; 257703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SELECT: 257847e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 257947e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 258047e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 258147e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0));// Legalize the condition. 258247e9223e06390897c3834f8c527001df392570ffChris Lattner break; 258347e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 258447e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 258547e9223e06390897c3834f8c527001df392570ffChris Lattner break; 258647e9223e06390897c3834f8c527001df392570ffChris Lattner } 258703c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Legalize the op0 258803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); // Legalize the op1 258903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2, Tmp3); 259003c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 25919373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 25929373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2 = PromoteOp(Node->getOperand(2)); // True 25939373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = PromoteOp(Node->getOperand(3)); // False 25949373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 25959373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), Tmp2, Tmp3, 25969373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4)); 25979373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 2598d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 25998ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner case ISD::CALL: { 26008ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 26018ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 26028ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 26033d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 26043d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) 26053d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 26063d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 26078ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 26088ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner "Can only promote single result calls"); 26098ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner std::vector<MVT::ValueType> RetTyVTs; 26108ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.reserve(2); 26118ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(NVT); 26128ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(MVT::Other); 2613d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 2614d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 26158ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Result = SDOperand(NC, 0); 26168ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 26178ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner // Insert the new chain mapping. 26188ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 26198ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner break; 2620edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 2621fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2622fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2623fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2624fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = Node->getOperand(0); 2625fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Zero extend the argument 2626fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2627fecf095292991bdf9396fec474011446107f9813Andrew Lenharth // Perform the larger operation, then subtract if needed. 2628fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2629fecf095292991bdf9396fec474011446107f9813Andrew Lenharth switch(Node->getOpcode()) 2630fecf095292991bdf9396fec474011446107f9813Andrew Lenharth { 2631fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2632fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = Tmp1; 2633fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2634fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2635fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 2636d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 26377cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), ISD::SETEQ); 263800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 2639fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(VT),NVT), Tmp1); 2640fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2641fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2642fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 264300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 264400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 2645fecf095292991bdf9396fec474011446107f9813Andrew Lenharth getSizeInBits(VT), NVT)); 2646fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2647fecf095292991bdf9396fec474011446107f9813Andrew Lenharth } 2648fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 264903c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 265003c8546ec57523970874917854a2fb77b1ff598eChris Lattner 265103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.Val && "Didn't set a result!"); 265203c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddPromotedOperand(Op, Result); 265303c8546ec57523970874917854a2fb77b1ff598eChris Lattner return Result; 265403c8546ec57523970874917854a2fb77b1ff598eChris Lattner} 26553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 265684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// ExpandAddSub - Find a clever way to expand this add operation into 265784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// subcomponents. 26584759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattnervoid SelectionDAGLegalize:: 26594759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris LattnerExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 26604759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi) { 266184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner // Expand the subcomponents. 266284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 266384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(LHS, LHSL, LHSH); 266484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(RHS, RHSL, RHSH); 266584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 266684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 266784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSL); 266884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSH); 266984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSL); 267084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSH); 2671e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2672e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 267384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Hi = Lo.getValue(1); 267484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner} 267584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 26765b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattnervoid SelectionDAGLegalize::ExpandShiftParts(unsigned NodeOp, 26775b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand Op, SDOperand Amt, 26785b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi) { 26795b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner // Expand the subcomponents. 26805b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand LHSL, LHSH; 26815b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandOp(Op, LHSL, LHSH); 26825b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 26835b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner std::vector<SDOperand> Ops; 26845b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSL); 26855b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSH); 26865b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(Amt); 2687cc0675a4be9a5133abd48ee272ff999ae48feabfChris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2688e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 26895b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Hi = Lo.getValue(1); 26905b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner} 26915b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 26925b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 2693e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// ExpandShift - Try to find a clever way to expand this shift operation out to 2694e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// smaller elements. If we can't find a way that is more efficient than a 2695e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// libcall on this target, return false. Otherwise, return true with the 2696e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// low-parts expanded into Lo and Hi. 2697e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattnerbool SelectionDAGLegalize::ExpandShift(unsigned Opc, SDOperand Op,SDOperand Amt, 2698e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi) { 2699e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner assert((Opc == ISD::SHL || Opc == ISD::SRA || Opc == ISD::SRL) && 2700e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner "This is not a shift!"); 2701f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2702e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(Op.getValueType()); 2703f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand ShAmt = LegalizeOp(Amt); 2704f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman MVT::ValueType ShTy = ShAmt.getValueType(); 2705f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned VTBits = MVT::getSizeInBits(Op.getValueType()); 2706f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned NVTBits = MVT::getSizeInBits(NVT); 2707f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2708f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Handle the case when Amt is an immediate. Other cases are currently broken 2709f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and are disabled. 2710f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Amt.Val)) { 2711f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned Cst = CN->getValue(); 2712f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Expand the incoming operand to be shifted, so that we have its parts 2713f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand InL, InH; 2714f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman ExpandOp(Op, InL, InH); 2715f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman switch(Opc) { 2716f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SHL: 2717f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2718f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2719f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2720f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2721f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2722f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst-NVTBits,ShTy)); 2723ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2724ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = DAG.getConstant(0, NVT); 2725ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = InL; 2726f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2727f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst, ShTy)); 2728f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::OR, NVT, 2729f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(Cst, ShTy)), 2730f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(NVTBits-Cst, ShTy))); 2731f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2732f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2733f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRL: 2734f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2735f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2736f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2737f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2738f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst-NVTBits,ShTy)); 2739f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2740ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2741ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2742ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = DAG.getConstant(0, NVT); 2743f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2744f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2745f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2746f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2747f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst, ShTy)); 2748f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2749f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2750f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRA: 2751f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2752edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 2753f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2754f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2755edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Lo = DAG.getNode(ISD::SRA, NVT, InH, 2756f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(Cst-NVTBits, ShTy)); 2757edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2758f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2759ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2760ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2761edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2762ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2763f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2764f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2765f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2766f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2767f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Cst, ShTy)); 2768f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2769f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2770f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2771f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2772f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // FIXME: The following code for expanding shifts using ISD::SELECT is buggy, 2773f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // so disable it for now. Currently targets are handling this via SHL_PARTS 2774f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and friends. 2775f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return false; 2776e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2777e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we have an efficient select operation (or if the selects will all fold 2778e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // away), lower to some complex code, otherwise just emit the libcall. 2779c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::SELECT, NVT) && !isa<ConstantSDNode>(Amt)) 2780e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return false; 2781e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2782e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand InL, InH; 2783e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ExpandOp(Op, InL, InH); 2784e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand NAmt = DAG.getNode(ISD::SUB, ShTy, // NAmt = 32-ShAmt 2785e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits, ShTy), ShAmt); 2786e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2787e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner // Compare the unmasked shift amount against 32. 27887cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand Cond = DAG.getSetCC(TLI.getSetCCResultTy(), ShAmt, 27897cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(NVTBits, ShTy), ISD::SETGE); 2790e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner 2791e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getShiftAmountFlavor() != TargetLowering::Mask) { 2792e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ShAmt = DAG.getNode(ISD::AND, ShTy, ShAmt, // ShAmt &= 31 2793e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2794e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner NAmt = DAG.getNode(ISD::AND, ShTy, NAmt, // NAmt &= 31 2795e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2796e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2797e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2798e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (Opc == ISD::SHL) { 2799e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << Amt) | (Lo >> NAmt) 2800e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, ShAmt), 2801e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, NAmt)); 2802e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(ISD::SHL, NVT, InL, ShAmt); // T2 = Lo << Amt&31 2803edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2804e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2805e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, DAG.getConstant(0, NVT), T2); 2806e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } else { 280777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand HiLoPart = DAG.getNode(ISD::SELECT, NVT, 28087cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getSetCC(TLI.getSetCCResultTy(), NAmt, 28097cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(32, ShTy), 28107cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ), 281177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(0, NVT), 281277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, NAmt)); 2813e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << NAmt) | (Lo >> Amt) 281477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiLoPart, 2815e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, ShAmt)); 2816e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(Opc, NVT, InH, ShAmt); // T2 = InH >> ShAmt&31 2817e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2818e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand HiPart; 281977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Opc == ISD::SRA) 282077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiPart = DAG.getNode(ISD::SRA, NVT, InH, 282177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2822e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner else 2823e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner HiPart = DAG.getConstant(0, NVT); 2824e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2825e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, HiPart, T2); 2826e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2827e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return true; 2828e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner} 282977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 28309530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindLatestCallSeqStart - Scan up the dag to find the latest (highest 28319530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqStart operation and occurs later than 28329c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// Found. 28339530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic void FindLatestCallSeqStart(SDNode *Node, SDNode *&Found) { 28349c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->getNodeDepth() <= Found->getNodeDepth()) return; 28352f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner 283616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_START, we already know this node occurs later 28379c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 283816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) { 28399c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 28409c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 28419c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 28429c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28439c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 28449c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(Node->getNumOperands() != 0 && 28459c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner "All leaves should have depth equal to the entry node!"); 2846829cb818065673a50101435f3c25e50ca82a02bfNate Begeman for (unsigned i = 0, e = Node->getNumOperands()-1; i != e; ++i) 28479530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(i).Val, Found); 28489c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28499c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 28509530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(Node->getNumOperands()-1).Val, 28519c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found); 28529c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 28539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28549c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28559530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindEarliestCallSeqEnd - Scan down the dag to find the earliest (lowest 28569530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqEnd operation and occurs more recent 28579c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// than Found. 285882299e70977500209c951404e354510feffb8efaChris Lattnerstatic void FindEarliestCallSeqEnd(SDNode *Node, SDNode *&Found, 285982299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> &Visited) { 286082299e70977500209c951404e354510feffb8efaChris Lattner if ((Found && Node->getNodeDepth() >= Found->getNodeDepth()) || 286182299e70977500209c951404e354510feffb8efaChris Lattner !Visited.insert(Node).second) return; 28629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 286316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_END, we already know this node occurs earlier 28649c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 286516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) { 28669c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 28679c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 28689c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 28699c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28709c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 28719c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end(); 28729c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (UI == E) return; 28739c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (--E; UI != E; ++UI) 287482299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 28759c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28769c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 287782299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 28789c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 28799c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28809530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqEnd - Given a chained node that is part of a call sequence, 288116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_END node that terminates the call sequence. 28829530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqEnd(SDNode *Node) { 288316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 28849c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return Node; 2885f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (Node->use_empty()) 28869530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return 0; // No CallSeqEnd 28879c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28889c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand TheChain(Node, Node->getNumValues()-1); 28892789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner if (TheChain.getValueType() != MVT::Other) 28902789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner TheChain = SDOperand(Node, 0); 28911aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (TheChain.getValueType() != MVT::Other) 28921aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman return 0; 2893edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2894edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman for (SDNode::use_iterator UI = Node->use_begin(), 28952f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner E = Node->use_end(); UI != E; ++UI) { 2896edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 28979c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Make sure to only follow users of our token chain. 28989c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *User = *UI; 28999c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 29009c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (User->getOperand(i) == TheChain) 2901eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner if (SDNode *Result = FindCallSeqEnd(User)) 2902eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner return Result; 29039c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 29042f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner return 0; 29059c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 29069c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29079530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqStart - Given a chained node that is part of a call sequence, 290816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_START node that initiates the call sequence. 29099530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqStart(SDNode *Node) { 29109530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(Node && "Didn't find callseq_start for a call??"); 291116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 29120d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29130d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 29140d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner "Node doesn't have a token chain argument!"); 29159530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqStart(Node->getOperand(0).Val); 29160d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 29170d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29180d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29199c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// FindInputOutputChains - If we are replacing an operation with a call we need 29209c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// to find the call that occurs before and the call that occurs after it to 29210d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// properly serialize the calls in the block. The returned operand is the 29220d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// input chain value for the new call (e.g. the entry node or the previous 29230d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// call), and OutChain is set to be the chain node to update to point to the 29240d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// end of the call chain. 29259c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnerstatic SDOperand FindInputOutputChains(SDNode *OpNode, SDNode *&OutChain, 29269c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand Entry) { 29279530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqStart = Entry.Val; 29289530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqEnd = 0; 29299530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(OpNode, LatestCallSeqStart); 29309530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner //std::cerr<<"Found node: "; LatestCallSeqStart->dump(); std::cerr <<"\n"; 2931edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 293216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // It is possible that no ISD::CALLSEQ_START was found because there is no 2933c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman // previous call in the function. LatestCallStackDown may in that case be 293416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // the entry node itself. Do not attempt to find a matching CALLSEQ_END 293516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // unless LatestCallStackDown is an CALLSEQ_START. 29361aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (LatestCallSeqStart->getOpcode() == ISD::CALLSEQ_START) { 29379530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = FindCallSeqEnd(LatestCallSeqStart); 29381aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman //std::cerr<<"Found end node: "; LatestCallSeqEnd->dump(); std::cerr <<"\n"; 29391aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } else { 29409530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = Entry.Val; 29411aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } 29429530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(LatestCallSeqEnd && "NULL return from FindCallSeqEnd"); 2943edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 29440d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Finally, find the first call that this must come before, first we find the 29459530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // CallSeqEnd that ends the call. 29460d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain = 0; 294782299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> Visited; 294882299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(OpNode, OutChain, Visited); 29499c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29509530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // If we found one, translate from the adj up to the callseq_start. 29510d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain) 29529530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner OutChain = FindCallSeqStart(OutChain); 29539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29549530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return SDOperand(LatestCallSeqEnd, 0); 29559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 29569c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 295700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen/// SpliceCallInto - Given the result chain of a libcall (CallResult), and a 2958b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattnervoid SelectionDAGLegalize::SpliceCallInto(const SDOperand &CallResult, 2959b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SDNode *OutChain) { 29600d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Nothing to splice it into? 29610d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain == 0) return; 29620d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29630d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(OutChain->getOperand(0).getValueType() == MVT::Other); 29640d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner //OutChain->dump(); 29650d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29660d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Form a token factor node merging the old inval and the new inval. 29670d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InToken = DAG.getNode(ISD::TokenFactor, MVT::Other, CallResult, 29680d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->getOperand(0)); 29690d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Change the node to refer to the new token. 29700d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->setAdjCallChain(InToken); 29710d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 29729c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29739c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 297477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 297577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 297677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 297777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 297877e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize::ExpandLibCall(const char *Name, SDNode *Node, 297977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi) { 29809c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *OutChain; 29819c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand InChain = FindInputOutputChains(Node, OutChain, 29829c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner DAG.getEntryNode()); 2983f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (InChain.Val == 0) 2984f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner InChain = DAG.getEntryNode(); 29859c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 298677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 298777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 298877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner MVT::ValueType ArgVT = Node->getOperand(i).getValueType(); 298977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(ArgVT); 299077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Node->getOperand(i), ArgTy)); 299177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 299277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(Name, TLI.getPointerTy()); 2993edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 29940d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 299577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(Node->getValueType(0)); 29960d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallInfo = 2997adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, false, 2998adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 29990d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 300099c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SDOperand Result; 30010d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner switch (getTypeAction(CallInfo.first.getValueType())) { 300277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner default: assert(0 && "Unknown thing"); 300377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Legal: 300499c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner Result = CallInfo.first; 300599c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 300677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Promote: 300777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(0 && "Cannot promote this yet!"); 300877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Expand: 300999c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner ExpandOp(CallInfo.first, Result, Hi); 301099c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner CallInfo.second = LegalizeOp(CallInfo.second); 301199c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 301277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 301399c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner 301499c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SpliceCallInto(CallInfo.second, OutChain); 301599c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner NeedsAnotherIteration = true; 301699c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner return Result; 301777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 301877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 30199c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 302077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// ExpandIntToFP - Expand a [US]INT_TO_FP operation, assuming that the 302177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// destination type is legal. 302277e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize:: 302377e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) { 3024c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(DestTy) && "Destination type is not legal!"); 302577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(Source.getValueType()) == Expand && 302677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner "This is not an expansion!"); 302777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(Source.getValueType() == MVT::i64 && "Only handle expand from i64!"); 302877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 30290d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (!isSigned) { 3030e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(Source.getValueType() == MVT::i64 && 3031e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner "This only works for 64-bit -> FP"); 3032e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 3033e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // incoming integer is set. To handle this, we dynamically test to see if 3034e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // it is set, and, if so, add a fudge factor. 3035e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Lo, Hi; 3036e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner ExpandOp(Source, Lo, Hi); 3037e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 303866de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 303966de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // signed, then adjust the result if the sign bit is set. 304066de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner SDOperand SignedConv = ExpandIntToFP(true, DestTy, 304166de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), Lo, Hi)); 304266de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 30437cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Hi, 30447cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Hi.getValueType()), 30457cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 3046e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 3047e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 3048e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SignSet, Four, Zero); 3049383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner uint64_t FF = 0x5f800000ULL; 3050383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 3051383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 3052e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 30535839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 3054e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 3055e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand FudgeInReg; 3056e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner if (DestTy == MVT::f32) 305752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 305852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 3059e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner else { 3060e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(DestTy == MVT::f64 && "Unexpected conversion"); 30615f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 30625f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 3063e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 3064473a99073cc29f59809a0d5dfee11f5e9e6ad2b7Chris Lattner return DAG.getNode(ISD::FADD, DestTy, SignedConv, FudgeInReg); 306577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 30660d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 3067a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 3068a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, Source.getValueType())) { 3069a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 3070a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Legal: 3071a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Expand: 3072a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner break; // This case is handled below. 307307dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 307407dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand NV = TLI.LowerOperation(DAG.getNode(ISD::SINT_TO_FP, DestTy, 307507dffd6af673c73352150583150b242a93694f00Chris Lattner Source), DAG); 307607dffd6af673c73352150583150b242a93694f00Chris Lattner if (NV.Val) 307707dffd6af673c73352150583150b242a93694f00Chris Lattner return LegalizeOp(NV); 307807dffd6af673c73352150583150b242a93694f00Chris Lattner break; // The target decided this was legal after all 307907dffd6af673c73352150583150b242a93694f00Chris Lattner } 3080a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 3081a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 308213689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // Expand the source, then glue it back together for the call. We must expand 308313689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // the source in case it is shared (this pass of legalize must traverse it). 308413689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner SDOperand SrcLo, SrcHi; 308513689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner ExpandOp(Source, SrcLo, SrcHi); 308613689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner Source = DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), SrcLo, SrcHi); 308713689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 30880d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDNode *OutChain = 0; 30890d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InChain = FindInputOutputChains(Source.Val, OutChain, 30900d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner DAG.getEntryNode()); 30910d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner const char *FnName = 0; 30920d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (DestTy == MVT::f32) 30930d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdisf"; 30940d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner else { 30950d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(DestTy == MVT::f64 && "Unknown fp value type!"); 30960d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdidf"; 30970d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 30980d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 309977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(FnName, TLI.getPointerTy()); 310077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 310177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 310277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(Source.getValueType()); 310344d105b7faf5672a2af61a3f0fdfed0d437d5777Chris Lattner 310477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Source, ArgTy)); 310577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 310677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // We don't care about token chains for libcalls. We just use the entry 310777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // node as our input and ignore the output chain. This allows us to place 310877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // calls wherever we need them to satisfy data dependences. 310977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(DestTy); 31100d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 31110d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 3112adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, true, 3113adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 31140d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 3115b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallResult.second, OutChain); 31160d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallResult.first; 311777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 3118edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3119e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3120e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 31213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandOp - Expand the specified SDOperand into its two component pieces 31223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo&Hi. Note that the Op MUST be an expanded type. As a result of this, the 31233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// LegalizeNodes map is filled in for any results that are not expanded, the 31243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandedNodes map is filled in for any results that are expanded, and the 31253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo/Hi values are returned. 31263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){ 31273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = Op.getValueType(); 312871c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 31293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDNode *Node = Op.Val; 31303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(VT) == Expand && "Not an expanded type!"); 3131ab48be377298bd509427a29e174cf4e305138819Nate Begeman assert((MVT::isInteger(VT) || VT == MVT::Vector) && 3132ab48be377298bd509427a29e174cf4e305138819Nate Begeman "Cannot expand FP values!"); 3133ab48be377298bd509427a29e174cf4e305138819Nate Begeman assert(((MVT::isInteger(NVT) && NVT < VT) || VT == MVT::Vector) && 31343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand to FP value or to larger int value!"); 31353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 31366fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner // See if we already expanded it. 31376fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I 31386fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner = ExpandedNodes.find(Op); 31396fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != ExpandedNodes.end()) { 31406fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Lo = I->second.first; 31416fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Hi = I->second.second; 31426fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner return; 31433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 31443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 31454e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // Expanding to multiple registers needs to perform an optimization step, and 31464e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // is not careful to avoid operations the target does not support. Make sure 31474e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // that all generated operations are legalized in the next iteration. 31484e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NeedsAnotherIteration = true; 31493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 31503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 3151d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 3152d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 3153d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner default: 31543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 31553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to expand this operator!"); 31563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 3157fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 3158fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Lo = DAG.getNode(ISD::UNDEF, NVT); 3159fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Hi = DAG.getNode(ISD::UNDEF, NVT); 3160fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 31613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: { 31623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner uint64_t Cst = cast<ConstantSDNode>(Node)->getValue(); 31633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getConstant(Cst, NVT); 31643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT); 31653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 31663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3167cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman case ISD::ConstantVec: { 3168cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman unsigned NumElements = Node->getNumOperands(); 3169cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // If we only have two elements left in the constant vector, just break it 3170cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // apart into the two scalar constants it contains. Otherwise, bisect the 3171cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // ConstantVec, and return each half as a new ConstantVec. 3172cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // FIXME: this is hard coded as big endian, it may have to change to support 3173cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // SSE and Alpha MVI 3174cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman if (NumElements == 2) { 3175cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Hi = Node->getOperand(0); 3176cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Lo = Node->getOperand(1); 3177cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } else { 3178cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman NumElements /= 2; 3179cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman std::vector<SDOperand> LoOps, HiOps; 3180cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman for (unsigned I = 0, E = NumElements; I < E; ++I) { 3181cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman HiOps.push_back(Node->getOperand(I)); 3182cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman LoOps.push_back(Node->getOperand(I+NumElements)); 3183cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 3184cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Lo = DAG.getNode(ISD::ConstantVec, MVT::Vector, LoOps); 3185cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Hi = DAG.getNode(ISD::ConstantVec, MVT::Vector, HiOps); 3186cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 3187cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman break; 3188cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 31893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3190d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner case ISD::BUILD_PAIR: 3191d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // Legalize both operands. FIXME: in the future we should handle the case 3192d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // where the two elements are not legal. 3193d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 3194d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Lo = LegalizeOp(Node->getOperand(0)); 3195d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Hi = LegalizeOp(Node->getOperand(1)); 3196d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner break; 3197d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner 3198edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner case ISD::CTPOP: 3199edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 32009b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner Lo = DAG.getNode(ISD::ADD, NVT, // ctpop(HL) -> ctpop(H)+ctpop(L) 32019b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Lo), 32029b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Hi)); 3203edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getConstant(0, NVT); 3204edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner break; 3205edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 320639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTLZ: { 320739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // ctlz (HL) -> ctlz(H) != 32 ? ctlz(H) : (ctlz(L)+32) 32083becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 320939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 321039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 32117cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand TopNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), HLZ, BitsC, 32127cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 321339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LowPart = DAG.getNode(ISD::CTLZ, NVT, Lo); 321439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LowPart = DAG.getNode(ISD::ADD, NVT, LowPart, BitsC); 321539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 321639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, TopNotZero, HLZ, LowPart); 321739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 321839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 321939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 322039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 322139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTTZ: { 322239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // cttz (HL) -> cttz(L) != 32 ? cttz(L) : (cttz(H)+32) 32233becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 322439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 322539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LTZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 32267cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand BotNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), LTZ, BitsC, 32277cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 322839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HiPart = DAG.getNode(ISD::CTTZ, NVT, Hi); 322939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HiPart = DAG.getNode(ISD::ADD, NVT, HiPart, BitsC); 323039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 323139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, BotNotZero, LTZ, HiPart); 323239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 323339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 323439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 3235edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 32363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: { 32373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 32383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 32392d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Lo = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 32403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Increment the pointer to the other half. 324238d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner unsigned IncrementSize = MVT::getSizeInBits(Lo.getValueType())/8; 32433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 32443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 324500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen //Is this safe? declaring that the two parts of the split load 32462d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //are from the same instruction? 32472d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Hi = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 3248ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner 3249ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Build a factor node to remember that this load is independent of the 3250ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // other one. 3251ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 3252ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi.getValue(1)); 3253edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 32543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember that we legalized the chain. 3255ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner AddLegalizedOperand(Op.getValue(1), TF); 32563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 32573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 32583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 32593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3260ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VLOAD: { 3261ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3262ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 3263ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElements =cast<ConstantSDNode>(Node->getOperand(2))->getValue(); 3264ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3265ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3266ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If we only have two elements, turn into a pair of scalar loads. 3267ab48be377298bd509427a29e174cf4e305138819Nate Begeman // FIXME: handle case where a vector of two elements is fine, such as 3268ab48be377298bd509427a29e174cf4e305138819Nate Begeman // 2 x double on SSE2. 3269ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (NumElements == 2) { 3270ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getLoad(EVT, Ch, Ptr, Node->getOperand(4)); 3271ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Increment the pointer to the other half. 3272ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize = MVT::getSizeInBits(EVT)/8; 3273ab48be377298bd509427a29e174cf4e305138819Nate Begeman Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 3274ab48be377298bd509427a29e174cf4e305138819Nate Begeman getIntPtrConstant(IncrementSize)); 3275ab48be377298bd509427a29e174cf4e305138819Nate Begeman //Is this safe? declaring that the two parts of the split load 3276ab48be377298bd509427a29e174cf4e305138819Nate Begeman //are from the same instruction? 3277ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getLoad(EVT, Ch, Ptr, Node->getOperand(4)); 3278ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 3279ab48be377298bd509427a29e174cf4e305138819Nate Begeman NumElements /= 2; // Split the vector in half 3280ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getVecLoad(NumElements, EVT, Ch, Ptr, Node->getOperand(4)); 3281ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize = NumElements * MVT::getSizeInBits(EVT)/8; 3282ab48be377298bd509427a29e174cf4e305138819Nate Begeman Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 3283ab48be377298bd509427a29e174cf4e305138819Nate Begeman getIntPtrConstant(IncrementSize)); 3284ab48be377298bd509427a29e174cf4e305138819Nate Begeman //Is this safe? declaring that the two parts of the split load 3285ab48be377298bd509427a29e174cf4e305138819Nate Begeman //are from the same instruction? 3286ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getVecLoad(NumElements, EVT, Ch, Ptr, Node->getOperand(4)); 3287ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3288ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3289ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Build a factor node to remember that this load is independent of the 3290ab48be377298bd509427a29e174cf4e305138819Nate Begeman // other one. 3291ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 3292ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi.getValue(1)); 3293ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3294ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Remember that we legalized the chain. 3295ab48be377298bd509427a29e174cf4e305138819Nate Begeman AddLegalizedOperand(Op.getValue(1), TF); 3296ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (!TLI.isLittleEndian()) 3297ab48be377298bd509427a29e174cf4e305138819Nate Begeman std::swap(Lo, Hi); 3298ab48be377298bd509427a29e174cf4e305138819Nate Begeman break; 3299ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3300ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VADD: 3301ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VSUB: 3302ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VMUL: { 3303ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElements =cast<ConstantSDNode>(Node->getOperand(2))->getValue(); 3304ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3305ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand LL, LH, RL, RH; 3306ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3307ab48be377298bd509427a29e174cf4e305138819Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3308ab48be377298bd509427a29e174cf4e305138819Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 3309ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3310ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If we only have two elements, turn into a pair of scalar loads. 3311ab48be377298bd509427a29e174cf4e305138819Nate Begeman // FIXME: handle case where a vector of two elements is fine, such as 3312ab48be377298bd509427a29e174cf4e305138819Nate Begeman // 2 x double on SSE2. 3313ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (NumElements == 2) { 3314ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned Opc = getScalarizedOpcode(Node->getOpcode(), EVT); 3315ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getNode(Opc, EVT, LL, RL); 3316ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getNode(Opc, EVT, LH, RH); 3317ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 3318ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getNode(Node->getOpcode(), MVT::Vector, LL, RL, LL.getOperand(2), 3319ab48be377298bd509427a29e174cf4e305138819Nate Begeman LL.getOperand(3)); 3320ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getNode(Node->getOpcode(), MVT::Vector, LH, RH, LH.getOperand(2), 3321ab48be377298bd509427a29e174cf4e305138819Nate Begeman LH.getOperand(3)); 3322ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3323ab48be377298bd509427a29e174cf4e305138819Nate Begeman break; 3324ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3325d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 33263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CALL: { 33273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 33283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Callee = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 33293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 33303d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 33313d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 33323d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 33333d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 33343d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 33353d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 33363d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 33373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 33383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Can only expand a call once so far, not i64 -> i16!"); 33393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 33403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 33413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(3); 33423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 33433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 33443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(MVT::Other); 3345d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Chain, Callee, Ops, 3346d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 33473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = SDOperand(NC, 0); 33483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = SDOperand(NC, 1); 33493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 33503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Insert the new chain mapping. 3351e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner AddLegalizedOperand(Op.getValue(1), Hi.getValue(2)); 33523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 33533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 33543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 33553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 33563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: { // Simple logical operators -> two trivial pieces. 33573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LL, LH, RL, RH; 33583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LL, LH); 33593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RL, RH); 33603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(Node->getOpcode(), NVT, LL, RL); 33613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(Node->getOpcode(), NVT, LH, RH); 33623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 33633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 33643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SELECT: { 33653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand C, LL, LH, RL, RH; 336647e9223e06390897c3834f8c527001df392570ffChris Lattner 336747e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 336847e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 336947e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 337047e9223e06390897c3834f8c527001df392570ffChris Lattner C = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 337147e9223e06390897c3834f8c527001df392570ffChris Lattner break; 337247e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 337347e9223e06390897c3834f8c527001df392570ffChris Lattner C = PromoteOp(Node->getOperand(0)); // Promote the condition. 337447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 337547e9223e06390897c3834f8c527001df392570ffChris Lattner } 33763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), LL, LH); 33773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(2), RL, RH); 33783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, C, LL, RL); 33793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, C, LH, RH); 33803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 33813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 33829373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: { 33839373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand TL, TH, FL, FH; 33849373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(2), TL, TH); 33859373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(3), FL, FH); 33869373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Lo = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 33879373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TL, FL, Node->getOperand(4)); 33889373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Hi = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 33899373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TH, FH, Node->getOperand(4)); 3390e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Lo = LegalizeOp(Lo); 3391e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Hi = LegalizeOp(Hi); 33929373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 33939373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 3394144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::SEXTLOAD: { 3395144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 3396144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 3397144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3398144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 3399144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 3400144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 3401144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 3402144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::SEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 3403144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 34049ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 34059ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 34069ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 34079ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 3408144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is obtained by SRA'ing all but one of the bits of the lo 3409144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // part. 3410144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 3411144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 3412144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman TLI.getShiftAmountTy())); 3413144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 3414144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = LegalizeOp(Hi); 3415144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 3416144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 3417144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::ZEXTLOAD: { 3418144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 3419144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 3420144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3421144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 3422144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 3423144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 3424144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 3425144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 3426144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 34279ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 34289ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 34299ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 34309ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 3431144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is just a zero. 34329ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getConstant(0, NVT)); 34339ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = LegalizeOp(Lo); 34349ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner break; 34359ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner } 34369ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner case ISD::EXTLOAD: { 34379ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); 34389ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 34399ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 34409ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 34419ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner if (EVT == NVT) 34429ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 34439ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner else 34449ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getExtLoad(ISD::EXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 34459ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner EVT); 34469ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 34479ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 34489ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 34499ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 34509ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // The high part is undefined. 34519ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getNode(ISD::UNDEF, NVT)); 3452144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 3453144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 3454144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 345513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: { 345613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner SDOperand In; 345713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 345813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 345913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 346013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Promote: 346113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner In = PromoteOp(Node->getOperand(0)); 346213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 346313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 346413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner 346513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The low part is any extension of the input (which degenerates to a copy). 346613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Lo = DAG.getNode(ISD::ANY_EXTEND, NVT, In); 346713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The high part is undefined. 346813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); 346913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 347013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 34713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: { 347206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 347306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 347406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 347506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 347606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 347706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 347806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate sign_extend_inreg to get the value we want. 347906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), In, 348015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 348106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 348206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 348306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 34843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a sign extension of the input (which degenerates to 34853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 348606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, In); 3487edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 34883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is obtained by SRA'ing all but one of the bits of the lo 34893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // part. 34902dad454af674cb41a14a85ad6ce5c85c43959acdChris Lattner unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 349127ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 349227ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner TLI.getShiftAmountTy())); 34933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 34943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 349506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case ISD::ZERO_EXTEND: { 349606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 349706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 349806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 349906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 350006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 350106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 350206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate zero_extend_inreg to get the value we want. 350323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner In = DAG.getZeroExtendInReg(In, Node->getOperand(0).getValueType()); 350406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 350506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 350606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 35073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a zero extension of the input (which degenerates to 35083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 3509dea29e25c32d2651e2efaff67bc30803ea24d991Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, In); 3510edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 35113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is just a zero. 35123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(0, NVT); 35133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 351406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 3515f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 3516308575be66ec3870d27b19df044fda18448feb41Chris Lattner case ISD::READCYCLECOUNTER: { 3517308575be66ec3870d27b19df044fda18448feb41Chris Lattner assert(TLI.getOperationAction(ISD::READCYCLECOUNTER, VT) == 3518308575be66ec3870d27b19df044fda18448feb41Chris Lattner TargetLowering::Custom && 3519308575be66ec3870d27b19df044fda18448feb41Chris Lattner "Must custom expand ReadCycleCounter"); 3520308575be66ec3870d27b19df044fda18448feb41Chris Lattner SDOperand T = TLI.LowerOperation(Op, DAG); 3521308575be66ec3870d27b19df044fda18448feb41Chris Lattner assert(T.Val && "Node must be custom expanded!"); 3522308575be66ec3870d27b19df044fda18448feb41Chris Lattner Lo = LegalizeOp(T.getValue(0)); 3523308575be66ec3870d27b19df044fda18448feb41Chris Lattner Hi = LegalizeOp(T.getValue(1)); 3524308575be66ec3870d27b19df044fda18448feb41Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), // Remember we legalized the chain. 3525308575be66ec3870d27b19df044fda18448feb41Chris Lattner LegalizeOp(T.getValue(2))); 3526f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth break; 3527308575be66ec3870d27b19df044fda18448feb41Chris Lattner } 3528f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 35294e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // These operators cannot be expanded directly, emit them as calls to 35304e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // library functions. 35314e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_SINT: 353280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_SINT, VT) == TargetLowering::Custom) { 3533f20d183c2268553c738fefb014959ea924dd0555Chris Lattner SDOperand Op; 3534f20d183c2268553c738fefb014959ea924dd0555Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 3535f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Expand: assert(0 && "cannot expand FP!"); 3536f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Legal: Op = LegalizeOp(Node->getOperand(0)); break; 3537f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Promote: Op = PromoteOp(Node->getOperand(0)); break; 3538f20d183c2268553c738fefb014959ea924dd0555Chris Lattner } 3539d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3540f20d183c2268553c738fefb014959ea924dd0555Chris Lattner Op = TLI.LowerOperation(DAG.getNode(ISD::FP_TO_SINT, VT, Op), DAG); 3541f20d183c2268553c738fefb014959ea924dd0555Chris Lattner 354280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 354380a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 354407dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 354507dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 354607dffd6af673c73352150583150b242a93694f00Chris Lattner break; 354707dffd6af673c73352150583150b242a93694f00Chris Lattner } 354880a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3549d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 35504e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 355177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixsfdi", Node, Hi); 35524e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 355377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixdfdi", Node, Hi); 35544e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 3555d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 35564e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_UINT: 355780a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_UINT, VT) == TargetLowering::Custom) { 355880a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner SDOperand Op = DAG.getNode(ISD::FP_TO_UINT, VT, 355980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner LegalizeOp(Node->getOperand(0))); 356080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 356180a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 356207dffd6af673c73352150583150b242a93694f00Chris Lattner Op = TLI.LowerOperation(Op, DAG); 356307dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 356407dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 356507dffd6af673c73352150583150b242a93694f00Chris Lattner break; 356607dffd6af673c73352150583150b242a93694f00Chris Lattner } 356780a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3568d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 35694e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 357077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunssfdi", Node, Hi); 35714e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 357277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunsdfdi", Node, Hi); 35734e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 35744e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner 3575e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SHL: 357650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 357750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SHL, VT) == TargetLowering::Custom) { 357850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SHL, VT, Node->getOperand(0), 357950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 358050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 358150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 358250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 358350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 358450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 358550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 358650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 358750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 358850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3589e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 359077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SHL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3591e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 35924759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 35934759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SHL_PARTS, use it. 3594c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SHL_PARTS, NVT)) { 35955b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SHL_PARTS, Node->getOperand(0), Node->getOperand(1), 35965b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 35974759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 35984759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 35994759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3600e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 360177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashldi3", Node, Hi); 3602e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3603e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3604e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRA: 360550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 360650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRA, VT) == TargetLowering::Custom) { 360750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRA, VT, Node->getOperand(0), 360850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 360950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 361050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 361150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 361250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 361350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 361450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 361550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 361650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 361750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3618e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 361977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRA, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3620e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 36214759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 36224759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRA_PARTS, use it. 3623c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRA_PARTS, NVT)) { 36245b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRA_PARTS, Node->getOperand(0), Node->getOperand(1), 36255b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 36264759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 36274759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 36284759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3629e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 363077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashrdi3", Node, Hi); 3631e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3632e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRL: 363350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 363450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRL, VT) == TargetLowering::Custom) { 363550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRL, VT, Node->getOperand(0), 363650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 363750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 363850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 363950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 364050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 364150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 364250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 364350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 364450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 364550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3646e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 364777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3648e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 36494759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 36504759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRL_PARTS, use it. 3651c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRL_PARTS, NVT)) { 36525b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRL_PARTS, Node->getOperand(0), Node->getOperand(1), 36535b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 36544759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 36554759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 36564759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3657e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 365877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__lshrdi3", Node, Hi); 3659e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3660e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3661edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case ISD::ADD: 36624759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::ADD_PARTS, Node->getOperand(0), Node->getOperand(1), 36634759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 366484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 366584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::SUB: 36664759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::SUB_PARTS, Node->getOperand(0), Node->getOperand(1), 36674759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 366884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 3669c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MUL: { 3670c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::MULHU, NVT)) { 3671c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman SDOperand LL, LH, RL, RH; 3672c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3673c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 367456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman unsigned SH = MVT::getSizeInBits(RH.getValueType())-1; 367556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // MULHS implicitly sign extends its inputs. Check to see if ExpandOp 367656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // extended the sign bit of the low half through the upper half, and if so 367756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // emit a MULHS instead of the alternate sequence that is valid for any 367856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // i64 x i64 multiply. 367956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman if (TLI.isOperationLegal(ISD::MULHS, NVT) && 368056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is RH an extension of the sign bit of RL? 368156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOpcode() == ISD::SRA && RH.getOperand(0) == RL && 368256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOperand(1).getOpcode() == ISD::Constant && 368356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(RH.getOperand(1))->getValue() == SH && 368456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is LH an extension of the sign bit of LL? 368556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOpcode() == ISD::SRA && LH.getOperand(0) == LL && 368656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOperand(1).getOpcode() == ISD::Constant && 368756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(LH.getOperand(1))->getValue() == SH) { 368856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHS, NVT, LL, RL); 368956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } else { 369056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 369156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 369256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 369356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 369456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 369556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } 3696c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 3697c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } else { 3698c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = ExpandLibCall("__muldi3" , Node, Hi); break; 3699c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 3700c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman break; 3701c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 370277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SDIV: Lo = ExpandLibCall("__divdi3" , Node, Hi); break; 370377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UDIV: Lo = ExpandLibCall("__udivdi3", Node, Hi); break; 370477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SREM: Lo = ExpandLibCall("__moddi3" , Node, Hi); break; 370577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UREM: Lo = ExpandLibCall("__umoddi3", Node, Hi); break; 37063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 37073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 37083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember in a map if the values will be reused later. 37096fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner bool isNew = ExpandedNodes.insert(std::make_pair(Op, 37106fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::make_pair(Lo, Hi))).second; 37116fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner assert(isNew && "Value already expanded?!?"); 37123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 37133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 37143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 37153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 37163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 37179c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnervoid SelectionDAG::Legalize() { 37183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 37193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 37209c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(*this).Run(); 37213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 37223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3723