LegalizeDAG.cpp revision 7310fb11f2a074069bf9ec3fc169c742ac48d32b
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: 53528a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman case ISD::TargetConstantPool: 5363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::GlobalAddress: 537b9debbf54c926036d5c22b3e7f0d12c79c1c15a3Chris Lattner case ISD::TargetGlobalAddress: 53803c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::ExternalSymbol: 53969a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::ConstantPool: // Nothing to do. 54032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::BasicBlock: 54132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::CONDCODE: 54232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::VALUETYPE: 54332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::SRCVALUE: 54436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case ISD::STRING: 5450c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 5460c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner default: assert(0 && "This action is not supported yet!"); 5470c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner case TargetLowering::Custom: { 5480c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner SDOperand Tmp = TLI.LowerOperation(Op, DAG); 5490c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner if (Tmp.Val) { 5500c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner Result = LegalizeOp(Tmp); 5510c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner break; 5520c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } 5530c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } // FALLTHROUGH if the target doesn't want to lower this op after all. 5540c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner case TargetLowering::Legal: 5550c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner assert(isTypeLegal(Node->getValueType(0)) && "This must be legal!"); 5560c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner break; 5570c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } 5583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 55908951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertSext: 56008951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertZext: 56108951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 56208951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner if (Tmp1 != Node->getOperand(0)) 56308951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 56408951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Node->getOperand(1)); 56508951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner break; 566308575be66ec3870d27b19df044fda18448feb41Chris Lattner case ISD::MERGE_VALUES: 567308575be66ec3870d27b19df044fda18448feb41Chris Lattner return LegalizeOp(Node->getOperand(Op.ResNo)); 56869a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::CopyFromReg: 56969a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 5707310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = Op.getValue(0); 5717310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Node->getNumOperands() == 2) { 5727310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Tmp1 != Node->getOperand(0)) 5737310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = DAG.getCopyFromReg(Tmp1, 574d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Node->getOperand(1))->getReg(), 5757310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Node->getValueType(0)); 5767310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } else { 5777310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner assert(Node->getNumOperands() == 3 && "Invalid copyfromreg!"); 5787310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 5797310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) 5807310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = DAG.getCopyFromReg(Tmp1, 5817310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner cast<RegisterSDNode>(Node->getOperand(1))->getReg(), 5827310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Node->getValueType(0), Tmp2); 5837310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner AddLegalizedOperand(Op.getValue(2), Result.getValue(2)); 5847310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 58513c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // Since CopyFromReg produces two values, make sure to remember that we 58613c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // legalized both of them. 58713c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 58813c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 58913c184de29c09294ed63b01ac43e1b46c049278eChris Lattner return Result.getValue(Op.ResNo); 59018c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner case ISD::ImplicitDef: 59118c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 59218c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner if (Tmp1 != Node->getOperand(0)) 593d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::ImplicitDef, MVT::Other, 594d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp1, Node->getOperand(1)); 59518c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner break; 596fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: { 597fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman MVT::ValueType VT = Op.getValueType(); 598fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman switch (TLI.getOperationAction(ISD::UNDEF, VT)) { 599ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman default: assert(0 && "This action is not supported yet!"); 600ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Expand: 601ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Promote: 602fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman if (MVT::isInteger(VT)) 603fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstant(0, VT); 604fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else if (MVT::isFloatingPoint(VT)) 605fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstantFP(0, VT); 606fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else 607fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman assert(0 && "Unknown value type!"); 608fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 609ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Legal: 610fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 611fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 612fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 613fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 61436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 61536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case ISD::LOCATION: 61636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner assert(Node->getNumOperands() == 5 && "Invalid LOCATION node!"); 61736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the input chain. 61836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 61936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner switch (TLI.getOperationAction(ISD::LOCATION, MVT::Other)) { 62036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Promote: 62136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner default: assert(0 && "This action is not supported yet!"); 622f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey case TargetLowering::Expand: { 623f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey MachineDebugInfo &DebugInfo = DAG.getMachineFunction().getDebugInfo(); 624f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey std::vector<SDOperand> Ops; 625f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Ops.push_back(Tmp1); // chain 626f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Ops.push_back(Node->getOperand(1)); // line # 627f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Ops.push_back(Node->getOperand(2)); // col # 628f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey const std::string &fname = cast<StringSDNode>(Node->getOperand(3))->getValue(); 629f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey const std::string &dirname=cast<StringSDNode>(Node->getOperand(4))->getValue(); 630f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey unsigned id = DebugInfo.RecordSource(fname, dirname); 631f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Ops.push_back(DAG.getConstant(id, MVT::i32)); // source file id 632f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Result = DAG.getNode(ISD::DEBUG_LOC, MVT::Other, Ops); 633f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey } 63436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 63536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Legal: 6369ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner if (Tmp1 != Node->getOperand(0) || 6379ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner getTypeAction(Node->getOperand(1).getValueType()) == Promote) { 63836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner std::vector<SDOperand> Ops; 63936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Tmp1); 6409ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner if (getTypeAction(Node->getOperand(1).getValueType()) == Legal) { 6419ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(Node->getOperand(1)); // line # must be legal. 6429ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(Node->getOperand(2)); // col # must be legal. 6439ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner } else { 6449ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner // Otherwise promote them. 6459ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(PromoteOp(Node->getOperand(1))); 6469ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(PromoteOp(Node->getOperand(2))); 6479ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner } 64836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Node->getOperand(3)); // filename must be legal. 64936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Node->getOperand(4)); // working dir # must be legal. 65036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Result = DAG.getNode(ISD::LOCATION, MVT::Other, Ops); 65136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 65236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 65336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 65436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 655f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey 656f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey case ISD::DEBUG_LOC: 657f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey assert(Node->getNumOperands() == 4 && "Invalid DEBUG_LOC node!"); 658f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey switch (TLI.getOperationAction(ISD::DEBUG_LOC, MVT::Other)) { 659f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey case TargetLowering::Promote: 660f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey case TargetLowering::Expand: 661f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey default: assert(0 && "This action is not supported yet!"); 662f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey case TargetLowering::Legal: 663f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 664f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the line #. 665f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the col #. 666f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Tmp4 = LegalizeOp(Node->getOperand(3)); // Legalize the source file id. 667f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey 668f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey if (Tmp1 != Node->getOperand(0) || 669f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Tmp2 != Node->getOperand(1) || 670f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Tmp3 != Node->getOperand(2) || 671f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Tmp4 != Node->getOperand(3)) { 672f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Result = DAG.getNode(ISD::DEBUG_LOC,MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4); 673f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey } 674f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey break; 675f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey } 676f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey break; 67736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 6783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: 6793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // We know we don't need to expand constants here, constants only have one 6803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // value and we check that it is fine above. 6813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: Maybe we should handle things like targets that don't support full 6833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // 32-bit immediates? 6843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 6863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 6873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 6883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 6893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 6903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 6923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Check to see if this FP immediate is already legal. 6943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isLegal = false; 6953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 6963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner E = TLI.legal_fpimm_end(); I != E; ++I) 6973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (CFP->isExactlyValue(*I)) { 6983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner isLegal = true; 6993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 7003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 7013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 7023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!isLegal) { 7033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Otherwise we need to spill the constant to memory. 7043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool Extend = false; 7053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 7063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If a FP immediate is precise when represented as a float, we put it 7073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // into the constant pool as a float, even if it's is statically typed 7083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // as a double. 7093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = CFP->getValueType(0); 7103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isDouble = VT == MVT::f64; 7113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFP *LLVMC = ConstantFP::get(isDouble ? Type::DoubleTy : 7123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Type::FloatTy, CFP->getValue()); 71399939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner if (isDouble && CFP->isExactlyValue((float)CFP->getValue()) && 71499939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // Only do this if the target has a native EXTLOAD instruction from 71599939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // f32. 716c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::EXTLOAD, MVT::f32)) { 7173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LLVMC = cast<ConstantFP>(ConstantExpr::getCast(LLVMC, Type::FloatTy)); 7183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner VT = MVT::f32; 7193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Extend = true; 7203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 721edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 72228a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman SDOperand CPIdx = 72328a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman LegalizeOp(DAG.getConstantPool(LLVMC, TLI.getPointerTy())); 724f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner if (Extend) { 7255f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 7265f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 727f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } else { 72852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, 72952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 730f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } 7313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 7323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 7333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 7348cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman case ISD::ConstantVec: { 7358cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // We assume that vector constants are not legal, and will be immediately 7368cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // spilled to the constant pool. 7378cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // 7388cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // FIXME: revisit this when we have some kind of mechanism by which targets 7398cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // can decided legality of vector constants, of which there may be very 7408cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // many. 7418cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // 7428cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // Create a ConstantPacked, and put it in the constant pool. 7438cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman std::vector<Constant*> CV; 7448cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman MVT::ValueType VT = Node->getValueType(0); 7458cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman for (unsigned I = 0, E = Node->getNumOperands(); I < E; ++I) { 7468cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman SDOperand OpN = Node->getOperand(I); 7478cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman const Type* OpNTy = MVT::getTypeForValueType(OpN.getValueType()); 7488cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman if (MVT::isFloatingPoint(VT)) 7498cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman CV.push_back(ConstantFP::get(OpNTy, 7508cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman cast<ConstantFPSDNode>(OpN)->getValue())); 7518cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman else 7528cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman CV.push_back(ConstantUInt::get(OpNTy, 7538cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman cast<ConstantSDNode>(OpN)->getValue())); 7548cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman } 7558cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman Constant *CP = ConstantPacked::get(CV); 756d7d746f60337684310fcd985d4466edd6a5980acNate Begeman SDOperand CPIdx = LegalizeOp(DAG.getConstantPool(CP, TLI.getPointerTy())); 7578cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, DAG.getSrcValue(NULL)); 7588cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman break; 7598cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman } 760040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner case ISD::TokenFactor: 761040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Node->getNumOperands() == 2) { 762040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner bool Changed = false; 763040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op0 = LegalizeOp(Node->getOperand(0)); 764040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op1 = LegalizeOp(Node->getOperand(1)); 765040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Op0 != Node->getOperand(0) || Op1 != Node->getOperand(1)) 766040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 767040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } else { 768040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner std::vector<SDOperand> Ops; 769040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner bool Changed = false; 770040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner // Legalize the operands. 771040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 772040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op = Node->getOperand(i); 773040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Ops.push_back(LegalizeOp(Op)); 774040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Changed |= Ops[i] != Op; 775040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } 776040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Changed) 777040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Ops); 778a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 779a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner break; 780a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner 78116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_START: 78216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 7833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 784128b52d3d75f4b74367de43e891cd98b5a9b5483Chris Lattner // Do not try to legalize the target-specific arguments (#1+) 78545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner Tmp2 = Node->getOperand(0); 7861aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (Tmp1 != Tmp2) 78788de6e77bfadea8962b017f372658204ab71448cChris Lattner Node->setAdjCallChain(Tmp1); 78827d404ccd1e86b7fffaf8037bf6b6dfb0b9d683bNate Begeman 78916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // Note that we do not create new CALLSEQ_DOWN/UP nodes here. These 79088de6e77bfadea8962b017f372658204ab71448cChris Lattner // nodes are treated specially and are mutated in place. This makes the dag 79188de6e77bfadea8962b017f372658204ab71448cChris Lattner // legalization process more efficient and also makes libcall insertion 79288de6e77bfadea8962b017f372658204ab71448cChris Lattner // easier. 7933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 794fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner case ISD::DYNAMIC_STACKALLOC: 795fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 796fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 797fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 798fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 799adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Tmp3 != Node->getOperand(2)) { 800adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 801adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 802adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 803adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 804adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner } else 805513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner Result = Op.getValue(0); 806fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 807fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // Since this op produces two values, make sure to remember that we 808fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // legalized both of them. 809fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 810fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 811fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner return Result.getValue(Op.ResNo); 812fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 813d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 8143d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner case ISD::CALL: { 8153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 8173d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 8183d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 8193d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 8203d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 8213d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 8223d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 8233d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 8243d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 8253d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || Changed) { 8263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 8273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(Node->getNumValues()); 8283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 829ebda942efcb86634a6581aae76a0d0c92c4a232eChris Lattner RetTyVTs.push_back(Node->getValueType(i)); 830d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Result = SDOperand(DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 831d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL), 0); 83238d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner } else { 83338d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner Result = Result.getValue(0); 8343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 83538d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // Since calls produce multiple values, make sure to remember that we 83638d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // legalized all of them. 83738d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 83838d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 83938d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner return Result.getValue(Op.ResNo); 8403d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 841c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 842c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 843c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner if (Tmp1 != Node->getOperand(0)) 844c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); 845c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 846c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner 847c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 848c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 85047e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 85147e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 85247e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 85347e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 85447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 85547e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 85647e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 85747e9223e06390897c3834f8c527001df392570ffChris Lattner break; 85847e9223e06390897c3834f8c527001df392570ffChris Lattner } 8597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 8607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 8617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 8627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 8637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 8647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 8657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 8667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 8677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 8697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 870550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 871550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 872550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, MVT::i1); 873550b1e59c4eb5db020766012b1406fc56833251dChris Lattner 8747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 8757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 8767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 8777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 8787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8797cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8807cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 8817cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Basic block destination (Op#2) is always legal. 8827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 8837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 8847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 8857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 8897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 890181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner if (!isTypeLegal(Node->getOperand(2).getValueType())) { 8917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 8927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 8937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 8947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 8957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 8967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 8977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 8987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 8997cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 9007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 9017cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 9027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 9037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9047cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 9057cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), 9067cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, DAG.getConstant(0, Tmp2.getValueType()), 9077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 9087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 909181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 910181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } 911181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner 912181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 913181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 914181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner 915181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner switch (TLI.getOperationAction(ISD::BR_CC, Tmp3.getValueType())) { 916181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner default: assert(0 && "Unexpected action for BR_CC!"); 917181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner case TargetLowering::Custom: { 918181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp4 = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 919181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp2, Tmp3, Node->getOperand(4)); 920181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp4 = TLI.LowerOperation(Tmp4, DAG); 921181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner if (Tmp4.Val) { 922181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Result = LegalizeOp(Tmp4); 923181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 924181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } 925181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } // FALLTHROUGH if the target doesn't want to lower this op after all. 926181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner case TargetLowering::Legal: 927181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 928181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp3 != Node->getOperand(3)) { 929181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 930181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp2, Tmp3, Node->getOperand(4)); 931181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } 932181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 9337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 934c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 935411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case ISD::BRCONDTWOWAY: 936411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 937411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 938411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 939411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Legal: 940411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 941411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 942411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Promote: 943411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 944411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 945411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 946411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR 947411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // pair. 948411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { 949411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Promote: 950411e888c1b4155190c8cffe388631ee20693b309Chris Lattner default: assert(0 && "This action is not supported yet!"); 951411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Legal: 952411e888c1b4155190c8cffe388631ee20693b309Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 953411e888c1b4155190c8cffe388631ee20693b309Chris Lattner std::vector<SDOperand> Ops; 954411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp1); 955411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp2); 956411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(2)); 957411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(3)); 958411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); 959411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 960411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 961411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Expand: 9627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If BRTWOWAY_CC is legal for this target, then simply expand this node 9637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // to that. Otherwise, skip BRTWOWAY_CC and expand directly to a 9647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // BRCOND/BR pair. 965c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::BRTWOWAY_CC, MVT::Other)) { 9667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 9677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 9687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 9697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 9707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9717cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 9727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 9737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 9747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 977411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Node->getOperand(2)); 9787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(3)); 9797cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 980411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 981411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 982411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 9837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BRTWOWAY_CC: 9847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 985c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 9867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 9877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 9887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 9897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 9907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Node->getOperand(1), Tmp2, Tmp3, 9917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 9927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 9967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 9977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 9987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 9997cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If this target does not support BRTWOWAY_CC, lower it to a BRCOND/BR 10007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // pair. 10017cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other)) { 10027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 10037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 10047cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 10057cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 10067cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 10077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 10087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 10097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 10107cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 10117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 10127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 10137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 10147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 10157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 10167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 10177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 10187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 10197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 10207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 10217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(5)); 10227cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 10237cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 10247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 10257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 10263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: 10273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 10292d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 10303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 10313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 103252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(Node->getValueType(0), Tmp1, Tmp2, 103352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(2)); 10348afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner else 10358afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner Result = SDOperand(Node, 0); 1036edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 10378afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // Since loads produce two values, make sure to remember that we legalized 10388afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // both of them. 10398afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 10408afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 10418afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner return Result.getValue(Op.ResNo); 10425fbb5d2459a5410590f285250faa604576308a93Nate Begeman 10430f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::EXTLOAD: 10440f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::SEXTLOAD: 104501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case ISD::ZEXTLOAD: { 10460f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10470f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 10480f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 10495f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner MVT::ValueType SrcVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 105001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), SrcVT)) { 105101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner default: assert(0 && "This action is not supported yet!"); 10521c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner case TargetLowering::Promote: 10531c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); 10545f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 10555f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), MVT::i8); 10561c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // Since loads produce two values, make sure to remember that we legalized 10571c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // both of them. 10581c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 10591c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 10601c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner return Result.getValue(Op.ResNo); 1061edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 106201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Legal: 106301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Tmp1 != Node->getOperand(0) || 106401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Tmp2 != Node->getOperand(1)) 10655f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 10665f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 106701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner else 106801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = SDOperand(Node, 0); 106901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner 107001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Since loads produce two values, make sure to remember that we legalized 107101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // both of them. 107201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 107301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 107401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(Op.ResNo); 107501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Expand: 10769d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth //f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 10779d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 10789d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth SDOperand Load = DAG.getLoad(SrcVT, Tmp1, Tmp2, Node->getOperand(2)); 107931559081a4285f4b7282e765aea4ec8a8e1d396cAndrew Lenharth Result = DAG.getNode(ISD::FP_EXTEND, Node->getValueType(0), Load); 10809d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (Op.ResNo) 10819d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Load.getValue(1); 10829d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Result; 10839d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 108401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(Node->getOpcode() != ISD::EXTLOAD && 108501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner "EXTLOAD should always be supported!"); 108601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 108701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // zero/sign extend inreg. 10885f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 10895f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 109023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner SDOperand ValRes; 109123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SEXTLOAD) 109223993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 109315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, DAG.getValueType(SrcVT)); 109423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner else 109523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getZeroExtendInReg(Result, SrcVT); 109601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), ValRes); 109701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 109801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Op.ResNo) 109901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(1); 110001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return ValRes; 110101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 110201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(0 && "Unreachable"); 110301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 11045dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case ISD::EXTRACT_ELEMENT: { 11055dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman MVT::ValueType OpTy = Node->getOperand(0).getValueType(); 11065dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman switch (getTypeAction(OpTy)) { 11075dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman default: 11085dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman assert(0 && "EXTRACT_ELEMENT action for type unimplemented!"); 11095dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 11105dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Legal: 11115dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) { 11125dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 1 -> Hi 11135dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::SRL, OpTy, Node->getOperand(0), 11145dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman DAG.getConstant(MVT::getSizeInBits(OpTy)/2, 11155dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman TLI.getShiftAmountTy())); 11165dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Result); 11175dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } else { 11185dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 0 -> Lo 11195dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), 11205dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Node->getOperand(0)); 11215dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 11225dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = LegalizeOp(Result); 11235dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 11245dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Expand: 11255dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // Get both the low and high parts. 11265dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 11275dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) 11285dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp2; // 1 -> Hi 11295dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman else 11305dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp1; // 0 -> Lo 11315dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 11325dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 11333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11345dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 11353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 11363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 11373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1138edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1139c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getOperand(2).getValueType()) && 1140d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner "Register type must be legal!"); 11417310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // Legalize the incoming value (must be a legal type). 1142d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 11437310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Node->getNumOperands() == 3) { 11447310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) 11457310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = DAG.getNode(ISD::CopyToReg, MVT::Other, Tmp1, 11467310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Node->getOperand(1), Tmp2); 11477310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } else { 11487310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner assert(Node->getNumOperands() == 4 && "Unknown CopyToReg"); 11497310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Tmp3 = LegalizeOp(Node->getOperand(3)); 11507310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 11517310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Tmp3 != Node->getOperand(3)) { 11527310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner unsigned Reg = cast<RegisterSDNode>(Node->getOperand(1))->getReg(); 11537310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = DAG.getCopyToReg(Tmp1, Reg, Tmp2, Tmp3); 11547310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 11557310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner 11567310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // Since this produces two values, make sure to remember that we legalized 11577310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // both of them. 11587310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 11597310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 11607310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner return Result.getValue(Op.ResNo); 11617310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 11623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 11643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 11653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 11663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 11673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 2: // ret val 11683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 11693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 11703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 11718afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 11723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 11733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 11753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 11763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 11773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Lo, Hi); 1178edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 11793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 11818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 11828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 11838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 11843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 11873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 11883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); 11893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 11913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<SDOperand> NewValues; 11923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 11933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) 11943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(i).getValueType())) { 11953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 11964e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NewValues.push_back(LegalizeOp(Node->getOperand(i))); 11973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 11993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 12003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(i), Lo, Hi); 12013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Lo); 12023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Hi); 1203edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 12043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 12068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Can't promote multiple return value yet!"); 12073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); 12093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::STORE: 12143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 12153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 12163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12175d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 121803c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ 12195d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner if (CFP->getValueType(0) == MVT::f32) { 122000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1221cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(FloatToBits(CFP->getValue()), 1222cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i32), 1223cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 122452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 12255d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } else { 12265d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); 122700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1228cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(DoubleToBits(CFP->getValue()), 1229cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i64), 1230cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 123152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 12325d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 123384734ce8ef1a21eb347d4deca0bf32d59001f751Chris Lattner Node = Result.Val; 12345d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 12355d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner 12363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 12373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: { 12383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Val = LegalizeOp(Node->getOperand(1)); 12393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Val != Node->getOperand(1) || Tmp1 != Node->getOperand(0) || 12403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(2)) 124152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, 124252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 12433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 124603c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Truncate the value and store the result. 124703c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(1)); 124803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp3, Tmp2, 12492d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 12509fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getValueType(Node->getOperand(1).getValueType())); 125103c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 125203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 12533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: 12543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 1255ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize; 12563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 12573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 12593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 12603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1261edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Lo = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Lo, Tmp2, 1262edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1263ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If this is a vector type, then we have to calculate the increment as 1264ab48be377298bd509427a29e174cf4e305138819Nate Begeman // the product of the element size in bytes, and the number of elements 1265ab48be377298bd509427a29e174cf4e305138819Nate Begeman // in the high half of the vector. 1266ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (MVT::Vector == Hi.getValueType()) { 1267ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElems = cast<ConstantSDNode>(Hi.getOperand(2))->getValue(); 1268ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Hi.getOperand(3))->getVT(); 1269ab48be377298bd509427a29e174cf4e305138819Nate Begeman IncrementSize = NumElems * MVT::getSizeInBits(EVT)/8; 1270ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 1271ab48be377298bd509427a29e174cf4e305138819Nate Begeman IncrementSize = MVT::getSizeInBits(Hi.getValueType())/8; 1272ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 12733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::ADD, Tmp2.getValueType(), Tmp2, 12743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 12753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Tmp2.getValueType()) && 12763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Pointers must be legal!"); 12772d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Again, claiming both parts of the store came form the same Instr 1278edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Hi, Tmp2, 1279edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1280ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1281ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner break; 12823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 128495762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 128595762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 12862c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 12872c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); 128895762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 128951b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth case ISD::READCYCLECOUNTER: 129051b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain 1291cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth if (Tmp1 != Node->getOperand(0)) { 1292cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth std::vector<MVT::ValueType> rtypes; 1293cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth std::vector<SDOperand> rvals; 1294cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rtypes.push_back(MVT::i64); 1295cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rtypes.push_back(MVT::Other); 1296cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rvals.push_back(Tmp1); 1297cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth Result = DAG.getNode(ISD::READCYCLECOUNTER, rtypes, rvals); 1298cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth } 129949c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth 130049c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // Since rdcc produce two values, make sure to remember that we legalized 130149c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // both of them. 130249c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth AddLegalizedOperand(SDOperand(Node, 0), Result); 130349c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 130449c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth return Result.getValue(Op.ResNo); 1305f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 13060f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::TRUNCSTORE: 13070f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 13080f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 13090f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 13100f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 13110f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Legal: 13120f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 131313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 131413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // The only promote case we handle is TRUNCSTORE:i1 X into 131513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // -> TRUNCSTORE:i8 (and X, 1) 131613d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner if (cast<VTSDNode>(Node->getOperand(4))->getVT() == MVT::i1 && 131713d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TLI.getOperationAction(ISD::TRUNCSTORE, MVT::i1) == 131813d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TargetLowering::Promote) { 131913d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // Promote the bool to a mask then store. 132013d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp2 = DAG.getNode(ISD::AND, Tmp2.getValueType(), Tmp2, 132113d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner DAG.getConstant(1, Tmp2.getValueType())); 132213d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 132313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Node->getOperand(3), DAG.getValueType(MVT::i8)); 132413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 132513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } else if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 132613d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp3 != Node->getOperand(2)) { 132745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 13289fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner Node->getOperand(3), Node->getOperand(4)); 132913d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } 13300f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 13310f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Promote: 13320f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Expand: 13330f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(0 && "Cannot handle illegal TRUNCSTORE yet!"); 13340f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner } 13350f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 13362ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 133747e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 133847e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 133947e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 134047e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 134147e9223e06390897c3834f8c527001df392570ffChris Lattner break; 134247e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 134347e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 134447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 134547e9223e06390897c3834f8c527001df392570ffChris Lattner } 13463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 13472ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 134855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 1349b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { 135055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 13519373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 13529373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 13539373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1.getOperand(0), Tmp1.getOperand(1), 13549373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 13559373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 13569373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 1357550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 1358550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 1359550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, MVT::i1); 13609373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1, 13619373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 13629373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 13639373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 13649373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 13657df96d66729d1f33934de7b52553e5f071686041Evan Cheng case TargetLowering::Custom: { 13667df96d66729d1f33934de7b52553e5f071686041Evan Cheng SDOperand Tmp = 13677df96d66729d1f33934de7b52553e5f071686041Evan Cheng TLI.LowerOperation(DAG.getNode(ISD::SELECT, Node->getValueType(0), 13687df96d66729d1f33934de7b52553e5f071686041Evan Cheng Tmp1, Tmp2, Tmp3), DAG); 13697df96d66729d1f33934de7b52553e5f071686041Evan Cheng if (Tmp.Val) { 13707df96d66729d1f33934de7b52553e5f071686041Evan Cheng Result = LegalizeOp(Tmp); 13717df96d66729d1f33934de7b52553e5f071686041Evan Cheng break; 13727df96d66729d1f33934de7b52553e5f071686041Evan Cheng } 13737df96d66729d1f33934de7b52553e5f071686041Evan Cheng // FALLTHROUGH if the target thinks it is legal. 13747df96d66729d1f33934de7b52553e5f071686041Evan Cheng } 137555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 137655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 137755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 != Node->getOperand(2)) 137855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), 137955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp1, Tmp2, Tmp3); 138055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 138155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 138255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner MVT::ValueType NVT = 138355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 138455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 138555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (MVT::isInteger(Tmp2.getValueType())) { 138613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner ExtOp = ISD::ANY_EXTEND; 138755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::TRUNCATE; 138855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 138955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::FP_EXTEND; 139055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::FP_ROUND; 139155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 139255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 139355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp2 = DAG.getNode(ExtOp, NVT, Tmp2); 139455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 = DAG.getNode(ExtOp, NVT, Tmp3); 139555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 139655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2,Tmp3); 139755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(TruncOp, Node->getValueType(0), Result); 139855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 139955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 140055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 14013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 14029373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 14039373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 14049373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 14059373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 1406c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(0).getValueType())) { 140723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner // Everything is legal, see if we should expand this op or something. 140823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner switch (TLI.getOperationAction(ISD::SELECT_CC, 140923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0).getValueType())) { 141023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner default: assert(0 && "This action is not supported yet!"); 141123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Custom: { 141223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner SDOperand Tmp = 141323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner TLI.LowerOperation(DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), 141423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0), 141523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(1), Tmp3, Tmp4, 1416d7050a9c50211dd215cb3c2bc28b4fb6bfa4a116Chris Lattner Node->getOperand(4)), DAG); 141723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp.Val) { 141823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = LegalizeOp(Tmp); 141923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 142023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 142123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } // FALLTHROUGH if the target can't lower this operation after all. 142223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Legal: 142323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 142423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 142523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 142623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3)) { 142723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), Tmp1, Tmp2, 142823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3, Tmp4, Node->getOperand(4)); 142923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 143023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 14319373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 14329373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 14339373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 14349373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp1 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 14359373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(0), // LHS 14369373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), // RHS 14379373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4))); 14387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 14397cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 14407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 14417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 14427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 14437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, Tmp3.getValueType(), 14447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1.getOperand(0), Tmp1.getOperand(1), 14457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, Tmp1.getOperand(2)); 14467cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 14477cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getSelectCC(Tmp1, 14487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 14497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, ISD::SETNE); 14507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 14519373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 14529373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 14533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 14543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 14553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 14563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 14573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 14583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 14593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 14608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // LHS 14618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // RHS 14628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 14638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // If this is an FP compare, the operands have already been extended. 14648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(Node->getOperand(0).getValueType())) { 14658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner MVT::ValueType VT = Node->getOperand(0).getValueType(); 146671c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 14678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 14688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Otherwise, we have to insert explicit sign or zero extends. Note 14698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // that we could insert sign extends for ALL conditions, but zero extend 14708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // is cheaper on many machines (an AND instead of two shifts), so prefer 14718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // it. 14727cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 14738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner default: assert(0 && "Unknown integer comparison!"); 14748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETEQ: 14758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETNE: 14768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGE: 14778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGT: 14788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULE: 14798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULT: 14808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // ALL of these operations will work if we either sign or zero extend 14818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // the operands (including the unsigned comparisons!). Zero extend is 14828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // usually a simpler/cheaper operation, so prefer it. 148323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 148423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 14858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 14868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGE: 14878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGT: 14888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLT: 14898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLE: 149015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 149115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 149215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 149315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 14948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 14958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 14968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 14973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1498edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case Expand: 14993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 15003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LHSLo, LHSHi); 15013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RHSLo, RHSHi); 15027cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 15033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETEQ: 15043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETNE: 150508b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSLo == RHSHi) 150608b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 150708b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSCST->isAllOnesValue()) { 150808b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner // Comparison to -1. 150908b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Tmp1 = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 1510b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSLo; 1511edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 151208b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner } 151308b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner 15143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 15153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 15163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp2); 1517b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 15183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 15193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 15205b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 15215b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // X > -1, x < 0 15225b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Node->getOperand(1))) 15237cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner if ((cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETLT && 15245b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner CST->getValue() == 0) || // X < 0 15257cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner (cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETGT && 1526b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman (CST->isAllOnesValue()))) { // X > -1 1527b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp1 = LHSHi; 1528b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSHi; 1529b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1530b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 15315b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner 15323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: This generated code sucks. 15333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ISD::CondCode LowCC; 15347cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 15353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: assert(0 && "Unknown integer setcc!"); 15363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLT: 15373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 15383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGT: 15393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 15403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLE: 15413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 15423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGE: 15433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 15443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1545edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 15463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 15473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 15483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 15493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 15503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 15513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 15527cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp1 = DAG.getSetCC(Node->getValueType(0), LHSLo, RHSLo, LowCC); 15537cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getNode(ISD::SETCC, Node->getValueType(0), LHSHi, RHSHi, 15547cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 15557cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getSetCC(Node->getValueType(0), LHSHi, RHSHi, ISD::SETEQ); 1556b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1557b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result, Tmp1, Tmp2)); 1558b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman return Result; 15593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 15603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1561b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman 1562b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch(TLI.getOperationAction(ISD::SETCC, Node->getOperand(0).getValueType())) { 1563b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman default: 1564b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman assert(0 && "Cannot handle this action for SETCC yet!"); 1565b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1566ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth case TargetLowering::Promote: { 1567ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // First step, figure out the appropriate operation to use. 1568ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Allow SETCC to not be supported for all legal data types 1569ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Mostly this targets FP 1570ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth MVT::ValueType NewInTy = Node->getOperand(0).getValueType(); 1571ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth MVT::ValueType OldVT = NewInTy; 1572ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1573ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Scan for the appropriate larger type to use. 1574ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth while (1) { 1575ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth NewInTy = (MVT::ValueType)(NewInTy+1); 1576ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1577ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(MVT::isInteger(NewInTy) == MVT::isInteger(OldVT) && 1578ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the integer world"); 1579ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(MVT::isFloatingPoint(NewInTy) == MVT::isFloatingPoint(OldVT) && 1580ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the floating point world"); 1581ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1582ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // If the target supports SETCC of this type, use it. 1583ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth if (TLI.getOperationAction(ISD::SETCC, NewInTy) == TargetLowering::Legal) 1584ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth break; 1585ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1586ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth if (MVT::isInteger(NewInTy)) 1587ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(0 && "Cannot promote Legal Integer SETCC yet"); 1588ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth else { 1589ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth Tmp1 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp1); 1590ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth Tmp2 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp2); 1591ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1592ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 15935e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 15945e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Node->getOperand(2)); 15955e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth break; 1596ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1597b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Legal: 1598b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1599b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 1600b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1601b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1602b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Expand: 1603b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // Expand a setcc node into a select_cc of the same condition, lhs, and 1604b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // rhs that selects between const 1 (true) and const 0 (false). 1605b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman MVT::ValueType VT = Node->getValueType(0); 1606b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SELECT_CC, VT, Tmp1, Tmp2, 1607b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman DAG.getConstant(1, VT), DAG.getConstant(0, VT), 1608b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1609b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(Result); 1610b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1611b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 16123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 16133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1614e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMSET: 1615e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMCPY: 1616e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMMOVE: { 1617deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Chain 1618e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Pointer 1619e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner 1620e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { // memset = ubyte 1621e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner switch (getTypeAction(Node->getOperand(2).getValueType())) { 1622e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand a byte!"); 1623e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1624deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 1625e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1626e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1627deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); 1628e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1629e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1630e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } else { 1631edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Tmp3 = LegalizeOp(Node->getOperand(2)); // memcpy/move = pointer, 1632e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1633272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1634272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp4; 1635272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(3).getValueType())) { 16366814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner case Expand: { 16376814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner // Length is too big, just take the lo-part of the length. 16386814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner SDOperand HiPart; 16396814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner ExpandOp(Node->getOperand(3), HiPart, Tmp4); 16406814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner break; 16416814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner } 1642e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1643e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = LegalizeOp(Node->getOperand(3)); 1644e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1645e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1646e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = PromoteOp(Node->getOperand(3)); 1647272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1648272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner } 1649272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1650272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp5; 1651272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(4).getValueType())) { // uint 1652272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 1653272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Legal: 1654272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner Tmp5 = LegalizeOp(Node->getOperand(4)); 1655272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1656272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Promote: 1657e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp5 = PromoteOp(Node->getOperand(4)); 1658e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1659e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 166055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 166155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 166255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 166307dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 166407dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 166507dffd6af673c73352150583150b242a93694f00Chris Lattner TLI.LowerOperation(DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, 166607dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp2, Tmp3, Tmp4, Tmp5), DAG); 166707dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 166807dffd6af673c73352150583150b242a93694f00Chris Lattner Result = LegalizeOp(Tmp); 166907dffd6af673c73352150583150b242a93694f00Chris Lattner break; 167007dffd6af673c73352150583150b242a93694f00Chris Lattner } 167107dffd6af673c73352150583150b242a93694f00Chris Lattner // FALLTHROUGH if the target thinks it is legal. 167207dffd6af673c73352150583150b242a93694f00Chris Lattner } 167355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 1674e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 1675e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || 1676e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp5 != Node->getOperand(4)) { 1677e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<SDOperand> Ops; 1678e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 1679e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 1680e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 1681e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 168255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 168355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: { 1684e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Otherwise, the target does not support this operation. Lower the 1685e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // operation to an explicit libcall as appropriate. 1686e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 1687e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner const Type *IntPtrTy = TLI.getTargetData().getIntPtrType(); 1688e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1689e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 16903bfbf4ea990930d153e58e153f319408341a94feReid Spencer const char *FnName = 0; 1691e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { 1692e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1693e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Extend the ubyte argument to be an int value for the call. 1694e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Tmp3); 1695e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, Type::IntTy)); 1696e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1697e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 1698e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = "memset"; 1699e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else if (Node->getOpcode() == ISD::MEMCPY || 1700e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Node->getOpcode() == ISD::MEMMOVE) { 1701e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1702e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, IntPtrTy)); 1703e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1704e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = Node->getOpcode() == ISD::MEMMOVE ? "memmove" : "memcpy"; 1705e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else { 1706e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner assert(0 && "Unknown op!"); 1707e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 170845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 1709e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 1710adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(Tmp1, Type::VoidTy, false, CallingConv::C, false, 1711e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner DAG.getExternalSymbol(FnName, IntPtr), Args, DAG); 1712c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner Result = CallResult.second; 1713c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner NeedsAnotherIteration = true; 171455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 171555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 1716e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 1717e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner break; 1718e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 171952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 172052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::READPORT: 172152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 172252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 17236d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 17243e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 17253e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 17263e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 17273e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 17283e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 17293e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 17303e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 173152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = SDOperand(Node, 0); 173252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // Since these produce two values, make sure to remember that we legalized 173352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // both of them. 173452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 173552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 173652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner return Result.getValue(Op.ResNo); 173752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::WRITEPORT: 173852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 173952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 174052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 174152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 174252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 != Node->getOperand(2)) 174352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 174452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner break; 174552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 17466d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::READIO: 17476d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 17486d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 17496d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 17506d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 17516d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 17526d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 17536d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 17543e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 17553e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 17563e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 17573e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 17583e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 17593e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 17603e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 17616d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = SDOperand(Node, 0); 17626d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 17636d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 17646d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a load from memory. 17656d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0), 17666d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), DAG.getSrcValue(NULL)); 17676d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 17686d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 17696d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 17706d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 17716d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Since these produce two values, make sure to remember that we legalized 17726d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // both of them. 17736d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 17746d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 17756d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner return Result.getValue(Op.ResNo); 17766d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 17776d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::WRITEIO: 17786d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 17796d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 17806d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 17816d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 17826d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 17836d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1).getValueType())) { 17846d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 17856d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 17866d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 17876d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 17886d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 != Node->getOperand(2)) 17896d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 17906d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 17916d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 17926d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a store to memory. 17936d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0), 17946d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), Node->getOperand(2), 17956d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getSrcValue(NULL)); 17966d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 17976d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 17986d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 17996d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 18006d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 180184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::ADD_PARTS: 18025b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SUB_PARTS: 18035b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 18045b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 18055b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 180684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 180784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 180884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 180984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 181084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 181184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 1812e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (Changed) { 1813e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 1814e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 1815e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 18162c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 18172c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 18182c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 18192c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 18202c8086f4b9916b2d02842be5e375276023225fbaChris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 18212c8086f4b9916b2d02842be5e375276023225fbaChris Lattner return Result.getValue(Op.ResNo); 182284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 18232c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 18242c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 18253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 18263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 18273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 1828c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 1829c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 18303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 18313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 18323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 18333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 18343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 183503c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 183603c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 183703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 183801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 183901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 184001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 184101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 18423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1843f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth switch (getTypeAction(Node->getOperand(1).getValueType())) { 1844f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Expand: assert(0 && "Not possible"); 1845f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Legal: 1846f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 1847f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1848f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Promote: 1849f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the RHS. 1850f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1851f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth } 18523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 18533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 18543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 18553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1856edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1857419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case ISD::BUILD_PAIR: { 1858419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman MVT::ValueType PairTy = Node->getValueType(0); 1859419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman // TODO: handle the case where the Lo and Hi operands are not of legal type 1860419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Lo 1861419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Hi 1862419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman switch (TLI.getOperationAction(ISD::BUILD_PAIR, PairTy)) { 1863419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Legal: 1864419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1865419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = DAG.getNode(ISD::BUILD_PAIR, PairTy, Tmp1, Tmp2); 1866419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1867419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Promote: 1868419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Custom: 1869419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman assert(0 && "Cannot promote/custom this yet!"); 1870419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Expand: 1871419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, PairTy, Tmp1); 1872419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::ANY_EXTEND, PairTy, Tmp2); 1873419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::SHL, PairTy, Tmp2, 1874419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman DAG.getConstant(MVT::getSizeInBits(PairTy)/2, 1875419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman TLI.getShiftAmountTy())); 1876419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::OR, PairTy, Tmp1, Tmp2)); 1877419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1878419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 1879419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1880419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 1881419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman 1882c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 1883c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 188401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 1885c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1886c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 1887c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1888c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Legal: 1889c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman if (Tmp1 != Node->getOperand(0) || 1890c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 != Node->getOperand(1)) 1891edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 1892c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2); 1893c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1894c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Promote: 1895c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Custom: 1896c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman assert(0 && "Cannot promote/custom handle this yet!"); 18974c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner case TargetLowering::Expand: 18984c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner if (MVT::isInteger(Node->getValueType(0))) { 18994c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner MVT::ValueType VT = Node->getValueType(0); 19004c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner unsigned Opc = (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 19014c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(Opc, VT, Tmp1, Tmp2); 19024c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::MUL, VT, Result, Tmp2); 19034c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::SUB, VT, Tmp1, Result); 19044c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner } else { 19054c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner // Floating point mod -> fmod libcall. 19064c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner const char *FnName = Node->getValueType(0) == MVT::f32 ? "fmodf":"fmod"; 19074c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner SDOperand Dummy; 19084c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = ExpandLibCall(FnName, Node, Dummy); 1909c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1910c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1911c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1912c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 19132c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 1914691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1915691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1916691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1917691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 1918691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1919691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 1920691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth if (Tmp1 != Node->getOperand(0)) 1921691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1922691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1923691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 1924691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType OVT = Tmp1.getValueType(); 1925691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 1926edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 1927edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 1928691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 1929691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 1930691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1931691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch(Node->getOpcode()) 1932691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth { 1933691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1934691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 1935691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1936691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1937691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 19387cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 19397cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), 19407cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ); 194100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 1942691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(OVT),NVT), Tmp1); 1943691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1944691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1945691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 194600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 194700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 1948691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getSizeInBits(OVT), NVT)); 1949691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1950691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1951691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1952691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1953691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Custom: 1954691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth assert(0 && "Cannot custom handle this yet!"); 1955691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 1956ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth switch(Node->getOpcode()) 1957ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth { 1958ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth case ISD::CTPOP: { 1959e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner static const uint64_t mask[6] = { 1960e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 1961e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 1962e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 1963e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner }; 1964ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth MVT::ValueType VT = Tmp1.getValueType(); 1965e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner MVT::ValueType ShVT = TLI.getShiftAmountTy(); 1966e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner unsigned len = getSizeInBits(VT); 1967e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 1968ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 1969e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp2 = DAG.getConstant(mask[i], VT); 1970e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp3 = DAG.getConstant(1ULL << i, ShVT); 197100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::ADD, VT, 1972ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, Tmp1, Tmp2), 1973ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, 1974ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3), 1975ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp2)); 1976ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1977ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Result = Tmp1; 1978ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1979ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 198057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTLZ: { 198157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina /* for now, we do this: 19825c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 1); 19835c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 2); 19845c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner ... 19855c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>16); 198600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen x = x | (x >>32); // for 64-bit input 19875c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner return popcount(~x); 198800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 19895c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner but see also: http://www.hackersdelight.org/HDcode/nlz.cc */ 19905c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 199157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina MVT::ValueType ShVT = TLI.getShiftAmountTy(); 199257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina unsigned len = getSizeInBits(VT); 199357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 199457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getConstant(1ULL << i, ShVT); 199500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::OR, VT, Tmp1, 199657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3)); 199757ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 199857ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getNode(ISD::XOR, VT, Tmp1, DAG.getConstant(~0ULL, VT)); 19995c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 200018aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 200157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 200257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTTZ: { 200300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen // for now, we use: { return popcount(~x & (x - 1)); } 2004d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // unless the target has ctlz but not ctpop, in which case we use: 2005d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // { return 32 - nlz(~x & (x-1)); } 2006d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // see also http://www.hackersdelight.org/HDcode/ntz.cc 20075c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 20085c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp2 = DAG.getConstant(~0ULL, VT); 200900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp3 = DAG.getNode(ISD::AND, VT, 20105c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::XOR, VT, Tmp1, Tmp2), 20115c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::SUB, VT, Tmp1, 20125c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getConstant(1, VT))); 2013d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // If ISD::CTLZ is legal and CTPOP isn't, then do that instead 2014c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::CTPOP, VT) && 2015c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::CTLZ, VT)) { 201600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = LegalizeOp(DAG.getNode(ISD::SUB, VT, 2017d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getConstant(getSizeInBits(VT), VT), 2018d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getNode(ISD::CTLZ, VT, Tmp3))); 2019d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } else { 2020d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 2021d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } 202218aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 202357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 2024ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth default: 2025ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth assert(0 && "Cannot expand this yet!"); 2026ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 2027ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 2028691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2029691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 2030691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 203100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 20322c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 20332c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 20342c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 2035da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2036da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2037da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 20382c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 20392c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 20402c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 20412c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 20422c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 20432c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 20442c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Promote: 20452c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Custom: 20462c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Cannot promote/custom handle this yet!"); 20472c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 2048f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 2049f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FNEG: { 20502c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 20512c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 205201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = LegalizeOp(DAG.getNode(ISD::FSUB, Node->getValueType(0), 20532c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2, Tmp1)); 2054f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 2055f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2056f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 20574af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 20584af6e0d7836126630f579b0a34f054321187f00bChris Lattner MVT::ValueType VT = Node->getValueType(0); 20594af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 20607cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, Tmp2, ISD::SETUGT); 20614af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp3 = DAG.getNode(ISD::FNEG, VT, Tmp1); 20624af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = DAG.getNode(ISD::SELECT, VT, Tmp2, Tmp1, Tmp3); 20634af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = LegalizeOp(Result); 2064f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 2065f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2066f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: 2067f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: 2068f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: { 2069f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner MVT::ValueType VT = Node->getValueType(0); 2070f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner const char *FnName = 0; 2071f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 2072f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: FnName = VT == MVT::f32 ? "sqrtf" : "sqrt"; break; 2073f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: FnName = VT == MVT::f32 ? "sinf" : "sin"; break; 2074f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: FnName = VT == MVT::f32 ? "cosf" : "cos"; break; 2075f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 2076f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 20772ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman SDOperand Dummy; 20782ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman Result = ExpandLibCall(FnName, Node, Dummy); 2079f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 2080f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2081f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: 20824af6e0d7836126630f579b0a34f054321187f00bChris Lattner assert(0 && "Unreachable!"); 20832c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 20842c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 20852c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 20862c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 20872c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 20882c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 2089fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::SINT_TO_FP: 2090fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::UINT_TO_FP: { 2091fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP; 2092fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2093fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2094d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen switch (TLI.getOperationAction(Node->getOpcode(), 2095fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType())) { 2096fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner default: assert(0 && "Unknown operation action!"); 2097fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Expand: 20986269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = ExpandLegalINT_TO_FP(isSigned, 20996269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey LegalizeOp(Node->getOperand(0)), 21006269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Node->getValueType(0)); 2101fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 2102fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 2103fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Promote: 2104fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteLegalINT_TO_FP(LegalizeOp(Node->getOperand(0)), 2105fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), 2106fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner isSigned); 2107fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 2108fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 2109fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Legal: 2110fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 21115b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth case TargetLowering::Custom: { 21125b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); 21135b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth SDOperand Tmp = 21145b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 21155b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth Tmp = TLI.LowerOperation(Tmp, DAG); 21165b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth if (Tmp.Val) { 21175b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth AddLegalizedOperand(Op, Tmp); 21185b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth NeedsAnotherIteration = true; 21195b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth return Tmp; 21205b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } else { 21215b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth assert(0 && "Target Must Lower this"); 21225b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } 21235b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } 2124fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2125fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 2126fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2127fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2128fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2129fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2130fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2131fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, 2132fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), Node->getOperand(0)); 2133fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2134fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2135fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (isSigned) { 2136fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2137fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 2138fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result, DAG.getValueType(Node->getOperand(0).getValueType())); 2139fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SINT_TO_FP, Op.getValueType(), Result); 2140fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } else { 2141fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2142fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getZeroExtendInReg(Result, 2143fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType()); 2144fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::UINT_TO_FP, Op.getValueType(), Result); 2145fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2146fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2147fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2148fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2149fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2150fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::TRUNCATE: 2151fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2152fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2153fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2154fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2155fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2156fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2157fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2158fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 2159fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 2160fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // Since the result is legal, we should just be able to truncate the low 2161fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // part of the source. 2162fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Tmp1); 2163fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2164fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2165fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2166fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Op.getValueType(), Result); 2167fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2168fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2169fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2170d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 2171fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_SINT: 2172fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_UINT: 2173fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2174fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2175f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2176f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner 21771618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))){ 21781618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: assert(0 && "Unknown operation action!"); 21791618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Expand: 2180d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT) { 2181d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman SDOperand True, False; 2182d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType VT = Node->getOperand(0).getValueType(); 2183d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType NVT = Node->getValueType(0); 2184d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman unsigned ShiftAmt = MVT::getSizeInBits(Node->getValueType(0))-1; 2185d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getConstantFP((double)(1ULL << ShiftAmt), VT); 2186d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp3 = DAG.getSetCC(TLI.getSetCCResultTy(), 2187d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Node->getOperand(0), Tmp2, ISD::SETLT); 2188d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman True = DAG.getNode(ISD::FP_TO_SINT, NVT, Node->getOperand(0)); 2189d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::FP_TO_SINT, NVT, 219001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getNode(ISD::FSUB, VT, Node->getOperand(0), 2191d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2)); 2192d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::XOR, NVT, False, 2193d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getConstant(1ULL << ShiftAmt, NVT)); 2194d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, NVT, Tmp3, True, False)); 21952d56e72f09337a1cab3ba199a9467c159296f3faNate Begeman return Result; 2196d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2197d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman assert(0 && "Do not know how to expand FP_TO_SINT yet!"); 2198d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 2199d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman break; 22001618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Promote: 2201f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = PromoteLegalFP_TO_INT(Tmp1, Node->getValueType(0), 22021618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner Node->getOpcode() == ISD::FP_TO_SINT); 22031618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner AddLegalizedOperand(Op, Result); 22041618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return Result; 220507dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 220607dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 220707dffd6af673c73352150583150b242a93694f00Chris Lattner DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 220807dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp = TLI.LowerOperation(Tmp, DAG); 220907dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 221007dffd6af673c73352150583150b242a93694f00Chris Lattner AddLegalizedOperand(Op, Tmp); 221107dffd6af673c73352150583150b242a93694f00Chris Lattner NeedsAnotherIteration = true; 2212507f752f6ed28aa9f0ae680e95bfc93df4e9e2dcChris Lattner return Tmp; 221307dffd6af673c73352150583150b242a93694f00Chris Lattner } else { 221407dffd6af673c73352150583150b242a93694f00Chris Lattner // The target thinks this is legal afterall. 221507dffd6af673c73352150583150b242a93694f00Chris Lattner break; 221607dffd6af673c73352150583150b242a93694f00Chris Lattner } 221707dffd6af673c73352150583150b242a93694f00Chris Lattner } 22181618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 22191618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 22201618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 2221d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 2222fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2223fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2224fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2225fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2226fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2227fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2228fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2229fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2230fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2231fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2232fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2233d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 223413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 22353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 22363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 223703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_EXTEND: 223803c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_ROUND: 22393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 22403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 22413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 22423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 22433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 22443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2245b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner case Expand: 22462c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2247b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner 224803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Promote: 224903c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 225013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 225113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = PromoteOp(Node->getOperand(0)); 225213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 225313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 22541713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner case ISD::ZERO_EXTEND: 22551713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 225613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 225723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 225823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 225903c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 226003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SIGN_EXTEND: 22611713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 226213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 22631713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 226415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 226515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 22661713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 226703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_EXTEND: 22681713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 22691713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner if (Result.getValueType() != Op.getValueType()) 22701713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner // Dynamically dead while we have only 2 FP types. 22711713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::FP_EXTEND, Op.getValueType(), Result); 22721713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 227303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_ROUND: 2274f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 2275f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2276f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 227703c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 22783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 22793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 22800f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 228123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 22820f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 228315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 228445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 228545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 228645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 228755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 228855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 228955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 229055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0)) 229155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 22925f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner DAG.getValueType(ExtraVT)); 229355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 229455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 229545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 229623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 229745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 229845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 229945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned BitsDiff = MVT::getSizeInBits(Node->getValueType(0)) - 230045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::getSizeInBits(ExtraVT); 230127ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner SDOperand ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 230245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SHL, Node->getValueType(0), 230345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 230445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SRA, Node->getValueType(0), 230545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 230645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 230745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // The only way we can lower this is to turn it into a STORETRUNC, 230845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 230945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 231045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 231145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 231245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 231345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner const Type *Ty = MVT::getTypeForValueType(ExtraVT); 231445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned TySize = (unsigned)TLI.getTargetData().getTypeSize(Ty); 231545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 231645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 2317edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman int SSFI = 231845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 231945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 232045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, DAG.getEntryNode(), 232152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(0), StackSlot, 23229fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getSrcValue(NULL), DAG.getValueType(ExtraVT)); 23235f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 23245f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result, StackSlot, DAG.getSrcValue(NULL), 23255f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner ExtraVT); 232645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 232745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 232845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 232945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = LegalizeOp(Result); 233055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 233145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 23320f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 23333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 233445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 23353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 233645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 233745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 233845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 23393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 23403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 23413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 23428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// PromoteOp - Given an operation that produces a value in an invalid type, 23438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// promote it to compute the value into a larger type. The produced value will 23448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// have the correct bits for the low portion of the register, but no guarantee 23458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// is made about the top bits: it may be zero, sign-extended, or garbage. 234603c8546ec57523970874917854a2fb77b1ff598eChris LattnerSDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) { 234703c8546ec57523970874917854a2fb77b1ff598eChris Lattner MVT::ValueType VT = Op.getValueType(); 234871c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 234903c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(getTypeAction(VT) == Promote && 235003c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Caller should expand or legalize operands that are not promotable!"); 235103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(NVT > VT && MVT::isInteger(NVT) == MVT::isInteger(VT) && 235203c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Cannot promote to smaller type!"); 235303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 235403c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Tmp1, Tmp2, Tmp3; 235503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 235603c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Result; 235703c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDNode *Node = Op.Val; 235803c8546ec57523970874917854a2fb77b1ff598eChris Lattner 23596fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op); 23606fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != PromotedNodes.end()) return I->second; 236145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 23620f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // Promotion needs an optimization step to clean up after it, and is not 23630f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // careful to avoid operations the target does not support. Make sure that 23640f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // all generated operations are legalized in the next iteration. 23650f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner NeedsAnotherIteration = true; 23660f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 236703c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 2368d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2369d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 237003c8546ec57523970874917854a2fb77b1ff598eChris Lattner default: 237103c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 237203c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(0 && "Do not know how to promote this operator!"); 237303c8546ec57523970874917854a2fb77b1ff598eChris Lattner abort(); 2374fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2375fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getNode(ISD::UNDEF, NVT); 2376fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 237703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::Constant: 2378ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner if (VT != MVT::i1) 2379ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND, NVT, Op); 2380ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner else 2381ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, NVT, Op); 238203c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantSDNode>(Result) && "Didn't constant fold zext?"); 238303c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 238403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::ConstantFP: 238503c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::FP_EXTEND, NVT, Op); 238603c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantFPSDNode>(Result) && "Didn't constant fold fp_extend?"); 238703c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2388ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner 238982fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner case ISD::SETCC: 2390c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(TLI.getSetCCResultTy()) && "SetCC type is not legal??"); 23917cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(),Node->getOperand(0), 23927cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(1), Node->getOperand(2)); 239382fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = LegalizeOp(Result); 239482fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner break; 239503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 239603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 239703c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 239803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Legal: 239903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 240003c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.getValueType() >= NVT && 240103c8546ec57523970874917854a2fb77b1ff598eChris Lattner "This truncation doesn't make sense!"); 240203c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (Result.getValueType() > NVT) // Truncate to NVT instead of VT 240303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Result); 240403c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2405e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner case Promote: 2406e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // The truncation is not required, because we don't guarantee anything 2407e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // about high bits anyway. 2408e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner Result = PromoteOp(Node->getOperand(0)); 2409e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner break; 241003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Expand: 241179e46acd35df36477029e9f534ab1a366a98df56Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 241279e46acd35df36477029e9f534ab1a366a98df56Nate Begeman // Truncate the low part of the expanded value to the result type 2413e21c305ed85b2be4a27784ba52471f6b68fdd255Chris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Tmp1); 241403c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 241503c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 24168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SIGN_EXTEND: 24178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::ZERO_EXTEND: 241813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 24198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 24208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Smaller reg should have been promoted!"); 24218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 24228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Just do extend all the way to the larger type. 24238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 24248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 24258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 24278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Promote the reg if it's smaller. 24288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 24298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The high bits are not guaranteed to be anything. Insert an extend. 24308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND) 2431595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 243215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 243313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner else if (Node->getOpcode() == ISD::ZERO_EXTEND) 243423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 243523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 24368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 24388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 24408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_EXTEND: 24418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Case not implemented. Dynamically dead with 2 FP types!"); 24428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_ROUND: 24438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 24448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Cannot expand FP regs!"); 24458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: assert(0 && "Unreachable with 2 FP types!"); 24468b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 24478b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Do an FP_ROUND_INREG. 24488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 244915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 245015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 24518b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 24538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24548b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 24558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SINT_TO_FP: 24568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UINT_TO_FP: 24578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 24588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 24598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 246077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 246177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 24628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 24648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 24658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 24668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP) 24678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 246815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 246915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 24708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 247123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 247223993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 247377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 247477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 24758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 247777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, NVT, 247877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOperand(0)); 247977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // Round if we cannot tolerate excess precision. 248077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (NoExcessFPPrecision) 248115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 248215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 248377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 24848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 24858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 24875e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner case ISD::SIGN_EXTEND_INREG: 24885e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Result = PromoteOp(Node->getOperand(0)); 24895e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 24905e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Node->getOperand(1)); 24915e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner break; 24928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_SINT: 24938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_UINT: 24948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 24958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 24968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 24978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 24998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input result is prerounded, so we don't have to do anything 25008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // special. 25018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 25028b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 25038b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 25048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "not implemented"); 25058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 2506d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // If we're promoting a UINT to a larger size, check to see if the new node 2507d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 2508d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // we can use that instead. This allows us to generate better code for 2509d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 2510d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // legal, such as PowerPC. 2511d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT && 2512c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) && 2513b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman (TLI.isOperationLegal(ISD::FP_TO_SINT, NVT) || 2514b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman TLI.getOperationAction(ISD::FP_TO_SINT, NVT)==TargetLowering::Custom)){ 2515d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(ISD::FP_TO_SINT, NVT, Tmp1); 2516d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2517d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2518d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 25198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 25208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 25212c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 25222c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 25232c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 25242c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(Tmp1.getValueType() == NVT); 25252c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 25262c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NOTE: we do not have to do any extra rounding here for 25272c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NoExcessFPPrecision, because we know the input will have the appropriate 25282c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // precision, and these operations don't modify precision at all. 25292c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 25302c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 2531da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2532da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2533da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 2534da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 2535da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner assert(Tmp1.getValueType() == NVT); 2536da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2537da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner if(NoExcessFPPrecision) 253815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 253915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 2540da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner break; 2541da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner 254203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::AND: 254303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::OR: 254403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::XOR: 25450f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::ADD: 25468b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SUB: 25470f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::MUL: 25480f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // The input may have strange things in the top bits of the registers, but 254901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. They may have weird bits going out, but 25500f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // that too is okay if they are integer operations. 25510f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 25520f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 25530f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 25540f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 255501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 255601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 255701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 255801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 255901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // The input may have strange things in the top bits of the registers, but 256001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. 256101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 256201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 256301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 256401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 256501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 256601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Floating point operations will give excess precision that we may not be 256701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // able to tolerate. If we DO allow excess precision, just leave it, 256801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // otherwise excise it. 25698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // FIXME: Why would we need to round FP ops more than integer ones? 25708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Is Round(Add(Add(A,B),C)) != Round(Add(Round(Add(A,B)), C)) 257101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 257215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 257315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 25740f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 25750f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 25768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SDIV: 25778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SREM: 25788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be sign extended. 25798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 25808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 25818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(NVT)) { 258215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 258315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 258415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 258515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 25868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 25878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 25888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 25898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 25908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 259115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 259215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 25938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 259401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 259501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 259601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // These operators require that their input be fp extended. 259701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 259801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 259901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 260001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 260101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 260201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 260301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 260401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getValueType(VT)); 260501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 26068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 26078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UDIV: 26088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UREM: 26098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be zero extended. 26108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 26118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 26128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(MVT::isInteger(NVT) && "Operators don't apply to FP!"); 261323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 261423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 26158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 26168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 26178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 26188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SHL: 26198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 26208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 26218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SHL, NVT, Tmp1, Tmp2); 26228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 26238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRA: 26248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly sign extended. 26258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 262615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 262715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 26288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 26298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRA, NVT, Tmp1, Tmp2); 26308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 26318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRL: 26328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly zero extended. 26338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 263423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 26358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 26368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRL, NVT, Tmp1, Tmp2); 26378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 263803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::LOAD: 263903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 264003c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2641ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Result = DAG.getExtLoad(ISD::EXTLOAD, NVT, Tmp1, Tmp2, 2642ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Node->getOperand(2), VT); 264303c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Remember that we legalized the chain. 264403c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 264503c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 26464c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::SEXTLOAD: 26474c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::ZEXTLOAD: 26484c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::EXTLOAD: 26494c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 26504c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 26518136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), NVT, Tmp1, Tmp2, 26528136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Node->getOperand(2), 26538136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner cast<VTSDNode>(Node->getOperand(3))->getVT()); 26544c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner // Remember that we legalized the chain. 26554c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 26564c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner break; 265703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SELECT: 265847e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 265947e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 266047e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 266147e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0));// Legalize the condition. 266247e9223e06390897c3834f8c527001df392570ffChris Lattner break; 266347e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 266447e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 266547e9223e06390897c3834f8c527001df392570ffChris Lattner break; 266647e9223e06390897c3834f8c527001df392570ffChris Lattner } 266703c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Legalize the op0 266803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); // Legalize the op1 266903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2, Tmp3); 267003c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 26719373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 26729373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2 = PromoteOp(Node->getOperand(2)); // True 26739373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = PromoteOp(Node->getOperand(3)); // False 26749373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 26759373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), Tmp2, Tmp3, 26769373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4)); 26779373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 2678d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 26798ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner case ISD::CALL: { 26808ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 26818ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 26828ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 26833d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 26843d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) 26853d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 26863d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 26878ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 26888ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner "Can only promote single result calls"); 26898ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner std::vector<MVT::ValueType> RetTyVTs; 26908ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.reserve(2); 26918ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(NVT); 26928ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(MVT::Other); 2693d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 2694d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 26958ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Result = SDOperand(NC, 0); 26968ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 26978ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner // Insert the new chain mapping. 26988ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 26998ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner break; 2700edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 2701fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2702fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2703fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2704fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = Node->getOperand(0); 2705fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Zero extend the argument 2706fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2707fecf095292991bdf9396fec474011446107f9813Andrew Lenharth // Perform the larger operation, then subtract if needed. 2708fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2709fecf095292991bdf9396fec474011446107f9813Andrew Lenharth switch(Node->getOpcode()) 2710fecf095292991bdf9396fec474011446107f9813Andrew Lenharth { 2711fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2712fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = Tmp1; 2713fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2714fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2715fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 2716d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 27177cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), ISD::SETEQ); 271800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 2719fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(VT),NVT), Tmp1); 2720fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2721fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2722fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 272300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 272400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 2725fecf095292991bdf9396fec474011446107f9813Andrew Lenharth getSizeInBits(VT), NVT)); 2726fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2727fecf095292991bdf9396fec474011446107f9813Andrew Lenharth } 2728fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 272903c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 273003c8546ec57523970874917854a2fb77b1ff598eChris Lattner 273103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.Val && "Didn't set a result!"); 273203c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddPromotedOperand(Op, Result); 273303c8546ec57523970874917854a2fb77b1ff598eChris Lattner return Result; 273403c8546ec57523970874917854a2fb77b1ff598eChris Lattner} 27353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 273684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// ExpandAddSub - Find a clever way to expand this add operation into 273784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// subcomponents. 27384759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattnervoid SelectionDAGLegalize:: 27394759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris LattnerExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 27404759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi) { 274184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner // Expand the subcomponents. 274284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 274384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(LHS, LHSL, LHSH); 274484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(RHS, RHSL, RHSH); 274584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 274684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 274784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSL); 274884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSH); 274984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSL); 275084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSH); 2751e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2752e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 275384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Hi = Lo.getValue(1); 275484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner} 275584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 27565b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattnervoid SelectionDAGLegalize::ExpandShiftParts(unsigned NodeOp, 27575b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand Op, SDOperand Amt, 27585b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi) { 27595b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner // Expand the subcomponents. 27605b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand LHSL, LHSH; 27615b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandOp(Op, LHSL, LHSH); 27625b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 27635b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner std::vector<SDOperand> Ops; 27645b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSL); 27655b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSH); 27665b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(Amt); 2767cc0675a4be9a5133abd48ee272ff999ae48feabfChris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2768e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 27695b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Hi = Lo.getValue(1); 27705b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner} 27715b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 27725b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 2773e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// ExpandShift - Try to find a clever way to expand this shift operation out to 2774e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// smaller elements. If we can't find a way that is more efficient than a 2775e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// libcall on this target, return false. Otherwise, return true with the 2776e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// low-parts expanded into Lo and Hi. 2777e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattnerbool SelectionDAGLegalize::ExpandShift(unsigned Opc, SDOperand Op,SDOperand Amt, 2778e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi) { 2779e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner assert((Opc == ISD::SHL || Opc == ISD::SRA || Opc == ISD::SRL) && 2780e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner "This is not a shift!"); 2781f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2782e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(Op.getValueType()); 2783f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand ShAmt = LegalizeOp(Amt); 2784f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman MVT::ValueType ShTy = ShAmt.getValueType(); 2785f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned VTBits = MVT::getSizeInBits(Op.getValueType()); 2786f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned NVTBits = MVT::getSizeInBits(NVT); 2787f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2788f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Handle the case when Amt is an immediate. Other cases are currently broken 2789f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and are disabled. 2790f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Amt.Val)) { 2791f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned Cst = CN->getValue(); 2792f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Expand the incoming operand to be shifted, so that we have its parts 2793f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand InL, InH; 2794f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman ExpandOp(Op, InL, InH); 2795f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman switch(Opc) { 2796f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SHL: 2797f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2798f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2799f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2800f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2801f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2802f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst-NVTBits,ShTy)); 2803ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2804ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = DAG.getConstant(0, NVT); 2805ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = InL; 2806f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2807f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst, ShTy)); 2808f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::OR, NVT, 2809f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(Cst, ShTy)), 2810f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(NVTBits-Cst, ShTy))); 2811f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2812f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2813f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRL: 2814f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2815f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2816f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2817f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2818f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst-NVTBits,ShTy)); 2819f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2820ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2821ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2822ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = DAG.getConstant(0, NVT); 2823f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2824f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2825f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2826f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2827f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst, ShTy)); 2828f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2829f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2830f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRA: 2831f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2832edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 2833f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2834f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2835edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Lo = DAG.getNode(ISD::SRA, NVT, InH, 2836f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(Cst-NVTBits, ShTy)); 2837edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2838f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2839ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2840ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2841edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2842ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2843f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2844f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2845f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2846f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2847f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Cst, ShTy)); 2848f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2849f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2850f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2851f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2852f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // FIXME: The following code for expanding shifts using ISD::SELECT is buggy, 2853f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // so disable it for now. Currently targets are handling this via SHL_PARTS 2854f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and friends. 2855f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return false; 2856e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2857e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we have an efficient select operation (or if the selects will all fold 2858e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // away), lower to some complex code, otherwise just emit the libcall. 2859c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::SELECT, NVT) && !isa<ConstantSDNode>(Amt)) 2860e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return false; 2861e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2862e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand InL, InH; 2863e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ExpandOp(Op, InL, InH); 2864e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand NAmt = DAG.getNode(ISD::SUB, ShTy, // NAmt = 32-ShAmt 2865e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits, ShTy), ShAmt); 2866e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2867e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner // Compare the unmasked shift amount against 32. 28687cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand Cond = DAG.getSetCC(TLI.getSetCCResultTy(), ShAmt, 28697cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(NVTBits, ShTy), ISD::SETGE); 2870e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner 2871e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getShiftAmountFlavor() != TargetLowering::Mask) { 2872e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ShAmt = DAG.getNode(ISD::AND, ShTy, ShAmt, // ShAmt &= 31 2873e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2874e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner NAmt = DAG.getNode(ISD::AND, ShTy, NAmt, // NAmt &= 31 2875e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2876e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2877e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2878e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (Opc == ISD::SHL) { 2879e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << Amt) | (Lo >> NAmt) 2880e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, ShAmt), 2881e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, NAmt)); 2882e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(ISD::SHL, NVT, InL, ShAmt); // T2 = Lo << Amt&31 2883edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2884e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2885e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, DAG.getConstant(0, NVT), T2); 2886e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } else { 288777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand HiLoPart = DAG.getNode(ISD::SELECT, NVT, 28887cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getSetCC(TLI.getSetCCResultTy(), NAmt, 28897cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(32, ShTy), 28907cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ), 289177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(0, NVT), 289277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, NAmt)); 2893e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << NAmt) | (Lo >> Amt) 289477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiLoPart, 2895e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, ShAmt)); 2896e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(Opc, NVT, InH, ShAmt); // T2 = InH >> ShAmt&31 2897e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2898e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand HiPart; 289977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Opc == ISD::SRA) 290077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiPart = DAG.getNode(ISD::SRA, NVT, InH, 290177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2902e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner else 2903e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner HiPart = DAG.getConstant(0, NVT); 2904e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2905e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, HiPart, T2); 2906e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2907e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return true; 2908e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner} 290977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 29109530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindLatestCallSeqStart - Scan up the dag to find the latest (highest 29119530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqStart operation and occurs later than 29129c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// Found. 29139530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic void FindLatestCallSeqStart(SDNode *Node, SDNode *&Found) { 29149c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->getNodeDepth() <= Found->getNodeDepth()) return; 29152f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner 291616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_START, we already know this node occurs later 29179c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 291816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) { 29199c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 29209c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 29219c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 29229c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29239c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 29249c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(Node->getNumOperands() != 0 && 29259c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner "All leaves should have depth equal to the entry node!"); 2926829cb818065673a50101435f3c25e50ca82a02bfNate Begeman for (unsigned i = 0, e = Node->getNumOperands()-1; i != e; ++i) 29279530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(i).Val, Found); 29289c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29299c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 29309530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(Node->getNumOperands()-1).Val, 29319c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found); 29329c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 29339c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29349c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29359530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindEarliestCallSeqEnd - Scan down the dag to find the earliest (lowest 29369530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqEnd operation and occurs more recent 29379c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// than Found. 293882299e70977500209c951404e354510feffb8efaChris Lattnerstatic void FindEarliestCallSeqEnd(SDNode *Node, SDNode *&Found, 293982299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> &Visited) { 294082299e70977500209c951404e354510feffb8efaChris Lattner if ((Found && Node->getNodeDepth() >= Found->getNodeDepth()) || 294182299e70977500209c951404e354510feffb8efaChris Lattner !Visited.insert(Node).second) return; 29429c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 294316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_END, we already know this node occurs earlier 29449c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 294516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) { 29469c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 29479c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 29489c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 29499c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29509c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 29519c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end(); 29529c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (UI == E) return; 29539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (--E; UI != E; ++UI) 295482299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 29559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29569c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 295782299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 29589c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 29599c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29609530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqEnd - Given a chained node that is part of a call sequence, 296116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_END node that terminates the call sequence. 29629530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqEnd(SDNode *Node) { 296316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 29649c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return Node; 2965f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (Node->use_empty()) 29669530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return 0; // No CallSeqEnd 29679c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29689c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand TheChain(Node, Node->getNumValues()-1); 29692789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner if (TheChain.getValueType() != MVT::Other) 29702789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner TheChain = SDOperand(Node, 0); 29711aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (TheChain.getValueType() != MVT::Other) 29721aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman return 0; 2973edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2974edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman for (SDNode::use_iterator UI = Node->use_begin(), 29752f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner E = Node->use_end(); UI != E; ++UI) { 2976edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 29779c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Make sure to only follow users of our token chain. 29789c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *User = *UI; 29799c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 29809c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (User->getOperand(i) == TheChain) 2981eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner if (SDNode *Result = FindCallSeqEnd(User)) 2982eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner return Result; 29839c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 29842f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner return 0; 29859c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 29869c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29879530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqStart - Given a chained node that is part of a call sequence, 298816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_START node that initiates the call sequence. 29899530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqStart(SDNode *Node) { 29909530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(Node && "Didn't find callseq_start for a call??"); 299116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 29920d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29930d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 29940d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner "Node doesn't have a token chain argument!"); 29959530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqStart(Node->getOperand(0).Val); 29960d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 29970d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29980d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29999c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// FindInputOutputChains - If we are replacing an operation with a call we need 30009c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// to find the call that occurs before and the call that occurs after it to 30010d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// properly serialize the calls in the block. The returned operand is the 30020d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// input chain value for the new call (e.g. the entry node or the previous 30030d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// call), and OutChain is set to be the chain node to update to point to the 30040d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// end of the call chain. 30059c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnerstatic SDOperand FindInputOutputChains(SDNode *OpNode, SDNode *&OutChain, 30069c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand Entry) { 30079530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqStart = Entry.Val; 30089530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqEnd = 0; 30099530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(OpNode, LatestCallSeqStart); 30109530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner //std::cerr<<"Found node: "; LatestCallSeqStart->dump(); std::cerr <<"\n"; 3011edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 301216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // It is possible that no ISD::CALLSEQ_START was found because there is no 3013c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman // previous call in the function. LatestCallStackDown may in that case be 301416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // the entry node itself. Do not attempt to find a matching CALLSEQ_END 301516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // unless LatestCallStackDown is an CALLSEQ_START. 30161aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (LatestCallSeqStart->getOpcode() == ISD::CALLSEQ_START) { 30179530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = FindCallSeqEnd(LatestCallSeqStart); 30181aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman //std::cerr<<"Found end node: "; LatestCallSeqEnd->dump(); std::cerr <<"\n"; 30191aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } else { 30209530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = Entry.Val; 30211aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } 30229530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(LatestCallSeqEnd && "NULL return from FindCallSeqEnd"); 3023edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 30240d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Finally, find the first call that this must come before, first we find the 30259530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // CallSeqEnd that ends the call. 30260d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain = 0; 302782299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> Visited; 302882299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(OpNode, OutChain, Visited); 30299c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 30309530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // If we found one, translate from the adj up to the callseq_start. 30310d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain) 30329530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner OutChain = FindCallSeqStart(OutChain); 30339c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 30349530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return SDOperand(LatestCallSeqEnd, 0); 30359c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 30369c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 303700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen/// SpliceCallInto - Given the result chain of a libcall (CallResult), and a 3038b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattnervoid SelectionDAGLegalize::SpliceCallInto(const SDOperand &CallResult, 3039b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SDNode *OutChain) { 30400d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Nothing to splice it into? 30410d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain == 0) return; 30420d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 30430d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(OutChain->getOperand(0).getValueType() == MVT::Other); 30440d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner //OutChain->dump(); 30450d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 30460d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Form a token factor node merging the old inval and the new inval. 30470d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InToken = DAG.getNode(ISD::TokenFactor, MVT::Other, CallResult, 30480d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->getOperand(0)); 30490d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Change the node to refer to the new token. 30500d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->setAdjCallChain(InToken); 30510d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 30529c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 30539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 305477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 305577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 305677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 305777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 305877e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize::ExpandLibCall(const char *Name, SDNode *Node, 305977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi) { 30609c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *OutChain; 30619c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand InChain = FindInputOutputChains(Node, OutChain, 30629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner DAG.getEntryNode()); 3063f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (InChain.Val == 0) 3064f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner InChain = DAG.getEntryNode(); 30659c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 306677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 306777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 306877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner MVT::ValueType ArgVT = Node->getOperand(i).getValueType(); 306977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(ArgVT); 307077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Node->getOperand(i), ArgTy)); 307177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 307277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(Name, TLI.getPointerTy()); 3073edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 30740d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 307577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(Node->getValueType(0)); 30760d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallInfo = 3077adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, false, 3078adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 30790d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 308099c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SDOperand Result; 30810d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner switch (getTypeAction(CallInfo.first.getValueType())) { 308277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner default: assert(0 && "Unknown thing"); 308377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Legal: 308499c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner Result = CallInfo.first; 308599c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 308677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Promote: 308777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(0 && "Cannot promote this yet!"); 308877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Expand: 308999c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner ExpandOp(CallInfo.first, Result, Hi); 309099c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner CallInfo.second = LegalizeOp(CallInfo.second); 309199c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 309277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 309399c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner 309499c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SpliceCallInto(CallInfo.second, OutChain); 309599c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner NeedsAnotherIteration = true; 309699c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner return Result; 309777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 309877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 30999c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 310077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// ExpandIntToFP - Expand a [US]INT_TO_FP operation, assuming that the 310177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// destination type is legal. 310277e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize:: 310377e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) { 3104c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(DestTy) && "Destination type is not legal!"); 310577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(Source.getValueType()) == Expand && 310677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner "This is not an expansion!"); 310777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(Source.getValueType() == MVT::i64 && "Only handle expand from i64!"); 310877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 31090d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (!isSigned) { 3110e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(Source.getValueType() == MVT::i64 && 3111e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner "This only works for 64-bit -> FP"); 3112e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 3113e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // incoming integer is set. To handle this, we dynamically test to see if 3114e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // it is set, and, if so, add a fudge factor. 3115e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Lo, Hi; 3116e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner ExpandOp(Source, Lo, Hi); 3117e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 311866de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 311966de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // signed, then adjust the result if the sign bit is set. 312066de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner SDOperand SignedConv = ExpandIntToFP(true, DestTy, 312166de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), Lo, Hi)); 312266de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 31237cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Hi, 31247cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Hi.getValueType()), 31257cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 3126e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 3127e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 3128e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SignSet, Four, Zero); 3129383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner uint64_t FF = 0x5f800000ULL; 3130383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 3131383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 3132e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 31335839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 3134e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 3135e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand FudgeInReg; 3136e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner if (DestTy == MVT::f32) 313752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 313852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 3139e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner else { 3140e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(DestTy == MVT::f64 && "Unexpected conversion"); 31415f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 31425f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 3143e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 3144473a99073cc29f59809a0d5dfee11f5e9e6ad2b7Chris Lattner return DAG.getNode(ISD::FADD, DestTy, SignedConv, FudgeInReg); 314577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 31460d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 3147a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 3148a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, Source.getValueType())) { 3149a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 3150a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Legal: 3151a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Expand: 3152a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner break; // This case is handled below. 315307dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 315407dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand NV = TLI.LowerOperation(DAG.getNode(ISD::SINT_TO_FP, DestTy, 315507dffd6af673c73352150583150b242a93694f00Chris Lattner Source), DAG); 315607dffd6af673c73352150583150b242a93694f00Chris Lattner if (NV.Val) 315707dffd6af673c73352150583150b242a93694f00Chris Lattner return LegalizeOp(NV); 315807dffd6af673c73352150583150b242a93694f00Chris Lattner break; // The target decided this was legal after all 315907dffd6af673c73352150583150b242a93694f00Chris Lattner } 3160a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 3161a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 316213689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // Expand the source, then glue it back together for the call. We must expand 316313689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // the source in case it is shared (this pass of legalize must traverse it). 316413689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner SDOperand SrcLo, SrcHi; 316513689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner ExpandOp(Source, SrcLo, SrcHi); 316613689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner Source = DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), SrcLo, SrcHi); 316713689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 31680d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDNode *OutChain = 0; 31690d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InChain = FindInputOutputChains(Source.Val, OutChain, 31700d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner DAG.getEntryNode()); 31710d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner const char *FnName = 0; 31720d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (DestTy == MVT::f32) 31730d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdisf"; 31740d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner else { 31750d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(DestTy == MVT::f64 && "Unknown fp value type!"); 31760d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdidf"; 31770d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 31780d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 317977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(FnName, TLI.getPointerTy()); 318077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 318177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 318277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(Source.getValueType()); 318344d105b7faf5672a2af61a3f0fdfed0d437d5777Chris Lattner 318477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Source, ArgTy)); 318577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 318677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // We don't care about token chains for libcalls. We just use the entry 318777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // node as our input and ignore the output chain. This allows us to place 318877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // calls wherever we need them to satisfy data dependences. 318977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(DestTy); 31900d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 31910d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 3192adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, true, 3193adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 31940d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 3195b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallResult.second, OutChain); 31960d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallResult.first; 319777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 3198edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3199e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3200e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 32013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandOp - Expand the specified SDOperand into its two component pieces 32023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo&Hi. Note that the Op MUST be an expanded type. As a result of this, the 32033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// LegalizeNodes map is filled in for any results that are not expanded, the 32043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandedNodes map is filled in for any results that are expanded, and the 32053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo/Hi values are returned. 32063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){ 32073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = Op.getValueType(); 320871c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 32093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDNode *Node = Op.Val; 32103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(VT) == Expand && "Not an expanded type!"); 3211ab48be377298bd509427a29e174cf4e305138819Nate Begeman assert((MVT::isInteger(VT) || VT == MVT::Vector) && 3212ab48be377298bd509427a29e174cf4e305138819Nate Begeman "Cannot expand FP values!"); 3213ab48be377298bd509427a29e174cf4e305138819Nate Begeman assert(((MVT::isInteger(NVT) && NVT < VT) || VT == MVT::Vector) && 32143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand to FP value or to larger int value!"); 32153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32166fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner // See if we already expanded it. 32176fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I 32186fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner = ExpandedNodes.find(Op); 32196fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != ExpandedNodes.end()) { 32206fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Lo = I->second.first; 32216fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Hi = I->second.second; 32226fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner return; 32233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 32243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32254e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // Expanding to multiple registers needs to perform an optimization step, and 32264e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // is not careful to avoid operations the target does not support. Make sure 32274e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // that all generated operations are legalized in the next iteration. 32284e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NeedsAnotherIteration = true; 32293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 3231d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 3232d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 3233d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner default: 32343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 32353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to expand this operator!"); 32363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 3237fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 3238fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Lo = DAG.getNode(ISD::UNDEF, NVT); 3239fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Hi = DAG.getNode(ISD::UNDEF, NVT); 3240fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 32413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: { 32423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner uint64_t Cst = cast<ConstantSDNode>(Node)->getValue(); 32433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getConstant(Cst, NVT); 32443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT); 32453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 32463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3247cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman case ISD::ConstantVec: { 3248cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman unsigned NumElements = Node->getNumOperands(); 3249cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // If we only have two elements left in the constant vector, just break it 3250cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // apart into the two scalar constants it contains. Otherwise, bisect the 3251cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // ConstantVec, and return each half as a new ConstantVec. 3252cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // FIXME: this is hard coded as big endian, it may have to change to support 3253cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // SSE and Alpha MVI 3254cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman if (NumElements == 2) { 3255cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Hi = Node->getOperand(0); 3256cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Lo = Node->getOperand(1); 3257cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } else { 3258cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman NumElements /= 2; 3259cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman std::vector<SDOperand> LoOps, HiOps; 3260cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman for (unsigned I = 0, E = NumElements; I < E; ++I) { 3261cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman HiOps.push_back(Node->getOperand(I)); 3262cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman LoOps.push_back(Node->getOperand(I+NumElements)); 3263cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 3264cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Lo = DAG.getNode(ISD::ConstantVec, MVT::Vector, LoOps); 3265cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Hi = DAG.getNode(ISD::ConstantVec, MVT::Vector, HiOps); 3266cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 3267cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman break; 3268cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 32693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3270d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner case ISD::BUILD_PAIR: 3271d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // Legalize both operands. FIXME: in the future we should handle the case 3272d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // where the two elements are not legal. 3273d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 3274d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Lo = LegalizeOp(Node->getOperand(0)); 3275d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Hi = LegalizeOp(Node->getOperand(1)); 3276d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner break; 327758f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner 327858f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner case ISD::SIGN_EXTEND_INREG: 327958f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 328058f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner // Sign extend the lo-part. 328158f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, 328258f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner DAG.getConstant(MVT::getSizeInBits(NVT)-1, 328358f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner TLI.getShiftAmountTy())); 328458f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner // sext_inreg the low part if needed. 328558f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Lo, Node->getOperand(1)); 328658f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner break; 3287d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner 3288edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner case ISD::CTPOP: 3289edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 32909b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner Lo = DAG.getNode(ISD::ADD, NVT, // ctpop(HL) -> ctpop(H)+ctpop(L) 32919b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Lo), 32929b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Hi)); 3293edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getConstant(0, NVT); 3294edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner break; 3295edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 329639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTLZ: { 329739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // ctlz (HL) -> ctlz(H) != 32 ? ctlz(H) : (ctlz(L)+32) 32983becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 329939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 330039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 33017cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand TopNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), HLZ, BitsC, 33027cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 330339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LowPart = DAG.getNode(ISD::CTLZ, NVT, Lo); 330439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LowPart = DAG.getNode(ISD::ADD, NVT, LowPart, BitsC); 330539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 330639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, TopNotZero, HLZ, LowPart); 330739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 330839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 330939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 331039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 331139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTTZ: { 331239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // cttz (HL) -> cttz(L) != 32 ? cttz(L) : (cttz(H)+32) 33133becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 331439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 331539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LTZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 33167cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand BotNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), LTZ, BitsC, 33177cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 331839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HiPart = DAG.getNode(ISD::CTTZ, NVT, Hi); 331939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HiPart = DAG.getNode(ISD::ADD, NVT, HiPart, BitsC); 332039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 332139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, BotNotZero, LTZ, HiPart); 332239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 332339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 332439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 3325edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 33263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: { 33273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 33283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 33292d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Lo = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 33303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 33313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Increment the pointer to the other half. 333238d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner unsigned IncrementSize = MVT::getSizeInBits(Lo.getValueType())/8; 33333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 33343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 333500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen //Is this safe? declaring that the two parts of the split load 33362d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //are from the same instruction? 33372d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Hi = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 3338ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner 3339ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Build a factor node to remember that this load is independent of the 3340ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // other one. 3341ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 3342ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi.getValue(1)); 3343edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 33443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember that we legalized the chain. 3345ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner AddLegalizedOperand(Op.getValue(1), TF); 33463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 33473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 33483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 33493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3350ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VLOAD: { 3351ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3352ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 3353ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElements =cast<ConstantSDNode>(Node->getOperand(2))->getValue(); 3354ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3355ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3356ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If we only have two elements, turn into a pair of scalar loads. 3357ab48be377298bd509427a29e174cf4e305138819Nate Begeman // FIXME: handle case where a vector of two elements is fine, such as 3358ab48be377298bd509427a29e174cf4e305138819Nate Begeman // 2 x double on SSE2. 3359ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (NumElements == 2) { 3360ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getLoad(EVT, Ch, Ptr, Node->getOperand(4)); 3361ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Increment the pointer to the other half. 3362ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize = MVT::getSizeInBits(EVT)/8; 3363ab48be377298bd509427a29e174cf4e305138819Nate Begeman Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 3364ab48be377298bd509427a29e174cf4e305138819Nate Begeman getIntPtrConstant(IncrementSize)); 3365ab48be377298bd509427a29e174cf4e305138819Nate Begeman //Is this safe? declaring that the two parts of the split load 3366ab48be377298bd509427a29e174cf4e305138819Nate Begeman //are from the same instruction? 3367ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getLoad(EVT, Ch, Ptr, Node->getOperand(4)); 3368ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 3369ab48be377298bd509427a29e174cf4e305138819Nate Begeman NumElements /= 2; // Split the vector in half 3370ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getVecLoad(NumElements, EVT, Ch, Ptr, Node->getOperand(4)); 3371ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize = NumElements * MVT::getSizeInBits(EVT)/8; 3372ab48be377298bd509427a29e174cf4e305138819Nate Begeman Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 3373ab48be377298bd509427a29e174cf4e305138819Nate Begeman getIntPtrConstant(IncrementSize)); 3374ab48be377298bd509427a29e174cf4e305138819Nate Begeman //Is this safe? declaring that the two parts of the split load 3375ab48be377298bd509427a29e174cf4e305138819Nate Begeman //are from the same instruction? 3376ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getVecLoad(NumElements, EVT, Ch, Ptr, Node->getOperand(4)); 3377ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3378ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3379ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Build a factor node to remember that this load is independent of the 3380ab48be377298bd509427a29e174cf4e305138819Nate Begeman // other one. 3381ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 3382ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi.getValue(1)); 3383ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3384ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Remember that we legalized the chain. 3385ab48be377298bd509427a29e174cf4e305138819Nate Begeman AddLegalizedOperand(Op.getValue(1), TF); 3386ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (!TLI.isLittleEndian()) 3387ab48be377298bd509427a29e174cf4e305138819Nate Begeman std::swap(Lo, Hi); 3388ab48be377298bd509427a29e174cf4e305138819Nate Begeman break; 3389ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3390ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VADD: 3391ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VSUB: 3392ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VMUL: { 3393ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElements =cast<ConstantSDNode>(Node->getOperand(2))->getValue(); 3394ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3395ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand LL, LH, RL, RH; 3396ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3397ab48be377298bd509427a29e174cf4e305138819Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3398ab48be377298bd509427a29e174cf4e305138819Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 3399ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3400ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If we only have two elements, turn into a pair of scalar loads. 3401ab48be377298bd509427a29e174cf4e305138819Nate Begeman // FIXME: handle case where a vector of two elements is fine, such as 3402ab48be377298bd509427a29e174cf4e305138819Nate Begeman // 2 x double on SSE2. 3403ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (NumElements == 2) { 3404ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned Opc = getScalarizedOpcode(Node->getOpcode(), EVT); 3405ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getNode(Opc, EVT, LL, RL); 3406ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getNode(Opc, EVT, LH, RH); 3407ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 3408ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getNode(Node->getOpcode(), MVT::Vector, LL, RL, LL.getOperand(2), 3409ab48be377298bd509427a29e174cf4e305138819Nate Begeman LL.getOperand(3)); 3410ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getNode(Node->getOpcode(), MVT::Vector, LH, RH, LH.getOperand(2), 3411ab48be377298bd509427a29e174cf4e305138819Nate Begeman LH.getOperand(3)); 3412ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3413ab48be377298bd509427a29e174cf4e305138819Nate Begeman break; 3414ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3415d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 34163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CALL: { 34173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 34183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Callee = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 34193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 34203d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 34213d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 34223d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 34233d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 34243d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 34253d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 34263d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 34273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 34283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Can only expand a call once so far, not i64 -> i16!"); 34293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 34303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 34313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(3); 34323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 34333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 34343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(MVT::Other); 3435d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Chain, Callee, Ops, 3436d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 34373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = SDOperand(NC, 0); 34383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = SDOperand(NC, 1); 34393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 34403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Insert the new chain mapping. 3441e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner AddLegalizedOperand(Op.getValue(1), Hi.getValue(2)); 34423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 34433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 34443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 34453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 34463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: { // Simple logical operators -> two trivial pieces. 34473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LL, LH, RL, RH; 34483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LL, LH); 34493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RL, RH); 34503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(Node->getOpcode(), NVT, LL, RL); 34513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(Node->getOpcode(), NVT, LH, RH); 34523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 34533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 34543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SELECT: { 34553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand C, LL, LH, RL, RH; 345647e9223e06390897c3834f8c527001df392570ffChris Lattner 345747e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 345847e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 345947e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 346047e9223e06390897c3834f8c527001df392570ffChris Lattner C = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 346147e9223e06390897c3834f8c527001df392570ffChris Lattner break; 346247e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 346347e9223e06390897c3834f8c527001df392570ffChris Lattner C = PromoteOp(Node->getOperand(0)); // Promote the condition. 346447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 346547e9223e06390897c3834f8c527001df392570ffChris Lattner } 34663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), LL, LH); 34673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(2), RL, RH); 34683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, C, LL, RL); 34693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, C, LH, RH); 34703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 34713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 34729373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: { 34739373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand TL, TH, FL, FH; 34749373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(2), TL, TH); 34759373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(3), FL, FH); 34769373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Lo = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 34779373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TL, FL, Node->getOperand(4)); 34789373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Hi = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 34799373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TH, FH, Node->getOperand(4)); 3480e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Lo = LegalizeOp(Lo); 3481e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Hi = LegalizeOp(Hi); 34829373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 34839373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 3484144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::SEXTLOAD: { 3485144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 3486144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 3487144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3488144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 3489144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 3490144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 3491144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 3492144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::SEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 3493144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 34949ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 34959ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 34969ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 34979ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 3498144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is obtained by SRA'ing all but one of the bits of the lo 3499144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // part. 3500144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 3501144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 3502144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman TLI.getShiftAmountTy())); 3503144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 3504144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = LegalizeOp(Hi); 3505144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 3506144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 3507144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::ZEXTLOAD: { 3508144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 3509144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 3510144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3511144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 3512144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 3513144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 3514144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 3515144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 3516144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 35179ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 35189ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 35199ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 35209ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 3521144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is just a zero. 35229ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getConstant(0, NVT)); 35239ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = LegalizeOp(Lo); 35249ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner break; 35259ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner } 35269ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner case ISD::EXTLOAD: { 35279ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); 35289ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 35299ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 35309ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 35319ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner if (EVT == NVT) 35329ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 35339ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner else 35349ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getExtLoad(ISD::EXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 35359ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner EVT); 35369ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 35379ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 35389ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 35399ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 35409ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // The high part is undefined. 35419ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getNode(ISD::UNDEF, NVT)); 3542144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 3543144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 3544144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 354513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: { 354613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner SDOperand In; 354713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 354813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 354913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 355013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Promote: 355113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner In = PromoteOp(Node->getOperand(0)); 355213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 355313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 355413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner 355513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The low part is any extension of the input (which degenerates to a copy). 355613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Lo = DAG.getNode(ISD::ANY_EXTEND, NVT, In); 355713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The high part is undefined. 355813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); 355913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 356013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 35613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: { 356206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 356306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 356406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 356506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 356606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 356706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 356806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate sign_extend_inreg to get the value we want. 356906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), In, 357015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 357106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 357206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 357306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 35743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a sign extension of the input (which degenerates to 35753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 357606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, In); 3577edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 35783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is obtained by SRA'ing all but one of the bits of the lo 35793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // part. 35802dad454af674cb41a14a85ad6ce5c85c43959acdChris Lattner unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 358127ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 358227ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner TLI.getShiftAmountTy())); 35833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 35843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 358506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case ISD::ZERO_EXTEND: { 358606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 358706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 358806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 358906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 359006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 359106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 359206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate zero_extend_inreg to get the value we want. 359323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner In = DAG.getZeroExtendInReg(In, Node->getOperand(0).getValueType()); 359406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 359506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 359606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 35973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a zero extension of the input (which degenerates to 35983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 3599dea29e25c32d2651e2efaff67bc30803ea24d991Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, In); 3600edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 36013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is just a zero. 36023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(0, NVT); 36033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 360406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 3605f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 3606308575be66ec3870d27b19df044fda18448feb41Chris Lattner case ISD::READCYCLECOUNTER: { 3607308575be66ec3870d27b19df044fda18448feb41Chris Lattner assert(TLI.getOperationAction(ISD::READCYCLECOUNTER, VT) == 3608308575be66ec3870d27b19df044fda18448feb41Chris Lattner TargetLowering::Custom && 3609308575be66ec3870d27b19df044fda18448feb41Chris Lattner "Must custom expand ReadCycleCounter"); 3610308575be66ec3870d27b19df044fda18448feb41Chris Lattner SDOperand T = TLI.LowerOperation(Op, DAG); 3611308575be66ec3870d27b19df044fda18448feb41Chris Lattner assert(T.Val && "Node must be custom expanded!"); 3612308575be66ec3870d27b19df044fda18448feb41Chris Lattner Lo = LegalizeOp(T.getValue(0)); 3613308575be66ec3870d27b19df044fda18448feb41Chris Lattner Hi = LegalizeOp(T.getValue(1)); 3614308575be66ec3870d27b19df044fda18448feb41Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), // Remember we legalized the chain. 3615308575be66ec3870d27b19df044fda18448feb41Chris Lattner LegalizeOp(T.getValue(2))); 3616f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth break; 3617308575be66ec3870d27b19df044fda18448feb41Chris Lattner } 3618f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 36194e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // These operators cannot be expanded directly, emit them as calls to 36204e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // library functions. 36214e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_SINT: 362280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_SINT, VT) == TargetLowering::Custom) { 3623f20d183c2268553c738fefb014959ea924dd0555Chris Lattner SDOperand Op; 3624f20d183c2268553c738fefb014959ea924dd0555Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 3625f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Expand: assert(0 && "cannot expand FP!"); 3626f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Legal: Op = LegalizeOp(Node->getOperand(0)); break; 3627f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Promote: Op = PromoteOp(Node->getOperand(0)); break; 3628f20d183c2268553c738fefb014959ea924dd0555Chris Lattner } 3629d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3630f20d183c2268553c738fefb014959ea924dd0555Chris Lattner Op = TLI.LowerOperation(DAG.getNode(ISD::FP_TO_SINT, VT, Op), DAG); 3631f20d183c2268553c738fefb014959ea924dd0555Chris Lattner 363280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 363380a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 363407dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 363507dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 363607dffd6af673c73352150583150b242a93694f00Chris Lattner break; 363707dffd6af673c73352150583150b242a93694f00Chris Lattner } 363880a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3639d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 36404e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 364177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixsfdi", Node, Hi); 36424e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 364377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixdfdi", Node, Hi); 36444e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 3645d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 36464e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_UINT: 364780a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_UINT, VT) == TargetLowering::Custom) { 364880a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner SDOperand Op = DAG.getNode(ISD::FP_TO_UINT, VT, 364980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner LegalizeOp(Node->getOperand(0))); 365080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 365180a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 365207dffd6af673c73352150583150b242a93694f00Chris Lattner Op = TLI.LowerOperation(Op, DAG); 365307dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 365407dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 365507dffd6af673c73352150583150b242a93694f00Chris Lattner break; 365607dffd6af673c73352150583150b242a93694f00Chris Lattner } 365780a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3658d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 36594e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 366077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunssfdi", Node, Hi); 36614e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 366277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunsdfdi", Node, Hi); 36634e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 36644e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner 3665e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SHL: 366650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 366750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SHL, VT) == TargetLowering::Custom) { 366850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SHL, VT, Node->getOperand(0), 366950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 367050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 367150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 367250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 367350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 367450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 367550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 367650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 367750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 367850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3679e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 368077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SHL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3681e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 36824759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 36834759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SHL_PARTS, use it. 3684c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SHL_PARTS, NVT)) { 36855b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SHL_PARTS, Node->getOperand(0), Node->getOperand(1), 36865b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 36874759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 36884759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 36894759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3690e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 369177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashldi3", Node, Hi); 3692e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3693e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3694e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRA: 369550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 369650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRA, VT) == TargetLowering::Custom) { 369750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRA, VT, Node->getOperand(0), 369850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 369950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 370050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 370150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 370250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 370350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 370450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 370550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 370650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 370750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3708e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 370977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRA, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3710e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 37114759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 37124759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRA_PARTS, use it. 3713c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRA_PARTS, NVT)) { 37145b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRA_PARTS, Node->getOperand(0), Node->getOperand(1), 37155b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 37164759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 37174759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 37184759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3719e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 372077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashrdi3", Node, Hi); 3721e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3722e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRL: 372350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 372450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRL, VT) == TargetLowering::Custom) { 372550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRL, VT, Node->getOperand(0), 372650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 372750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 372850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 372950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 373050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 373150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 373250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 373350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 373450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 373550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3736e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 373777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3738e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 37394759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 37404759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRL_PARTS, use it. 3741c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRL_PARTS, NVT)) { 37425b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRL_PARTS, Node->getOperand(0), Node->getOperand(1), 37435b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 37444759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 37454759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 37464759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3747e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 374877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__lshrdi3", Node, Hi); 3749e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3750e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3751edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case ISD::ADD: 37524759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::ADD_PARTS, Node->getOperand(0), Node->getOperand(1), 37534759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 375484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 375584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::SUB: 37564759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::SUB_PARTS, Node->getOperand(0), Node->getOperand(1), 37574759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 375884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 3759c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MUL: { 3760c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::MULHU, NVT)) { 3761c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman SDOperand LL, LH, RL, RH; 3762c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3763c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 376456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman unsigned SH = MVT::getSizeInBits(RH.getValueType())-1; 376556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // MULHS implicitly sign extends its inputs. Check to see if ExpandOp 376656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // extended the sign bit of the low half through the upper half, and if so 376756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // emit a MULHS instead of the alternate sequence that is valid for any 376856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // i64 x i64 multiply. 376956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman if (TLI.isOperationLegal(ISD::MULHS, NVT) && 377056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is RH an extension of the sign bit of RL? 377156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOpcode() == ISD::SRA && RH.getOperand(0) == RL && 377256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOperand(1).getOpcode() == ISD::Constant && 377356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(RH.getOperand(1))->getValue() == SH && 377456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is LH an extension of the sign bit of LL? 377556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOpcode() == ISD::SRA && LH.getOperand(0) == LL && 377656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOperand(1).getOpcode() == ISD::Constant && 377756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(LH.getOperand(1))->getValue() == SH) { 377856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHS, NVT, LL, RL); 377956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } else { 378056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 378156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 378256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 378356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 378456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 378556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } 3786c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 3787c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } else { 3788c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = ExpandLibCall("__muldi3" , Node, Hi); break; 3789c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 3790c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman break; 3791c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 379277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SDIV: Lo = ExpandLibCall("__divdi3" , Node, Hi); break; 379377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UDIV: Lo = ExpandLibCall("__udivdi3", Node, Hi); break; 379477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SREM: Lo = ExpandLibCall("__moddi3" , Node, Hi); break; 379577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UREM: Lo = ExpandLibCall("__umoddi3", Node, Hi); break; 37963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 37973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 37983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember in a map if the values will be reused later. 37996fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner bool isNew = ExpandedNodes.insert(std::make_pair(Op, 38006fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::make_pair(Lo, Hi))).second; 38016fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner assert(isNew && "Value already expanded?!?"); 38023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 38033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 38043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 38053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 38063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 38079c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnervoid SelectionDAG::Legalize() { 38083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 38093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 38109c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(*this).Run(); 38113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 38123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3813