LegalizeDAG.cpp revision 49c709f891a3e49db58b56ca94eafa98cbb12c4d
13e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===-- LegalizeDAG.cpp - Implement SelectionDAG::Legalize ----------------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 33e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// The LLVM Compiler Infrastructure 43e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 53e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file was developed by the LLVM research group and is distributed under 63e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 83e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 93e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file implements the SelectionDAG::Legalize method. 113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/MachineFunction.h" 1645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 1702659d23637f69f90640bfa3e66919517103c57aJim Laskey#include "llvm/Support/MathExtras.h" 183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Target/TargetLowering.h" 19e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner#include "llvm/Target/TargetData.h" 200f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner#include "llvm/Target/TargetOptions.h" 21adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Constants.h" 233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include <iostream> 2482299e70977500209c951404e354510feffb8efaChris Lattner#include <set> 253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerusing namespace llvm; 263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// SelectionDAGLegalize - This takes an arbitrary SelectionDAG as input and 293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// hacks on it until the target machine can handle it. This involves 303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating value sizes the machine cannot handle (promoting small sizes to 313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// large sizes or splitting up large values into small values) as well as 323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating operations the machine cannot handle. 333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// This code also does a small amount of optimization and recognition of idioms 353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// as part of its processing. For example, if a target does not support a 363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 'setcc' instruction efficiently, but does support 'brcc' instruction, this 373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// will attempt merge setcc and brc instructions into brcc's. 383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnernamespace { 403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerclass SelectionDAGLegalize { 413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner TargetLowering &TLI; 423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SelectionDAG &DAG; 433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizeAction - This enum indicates what action we should take for each 453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type the can occur in the program. 463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner enum LegalizeAction { 473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Legal, // The target natively supports this value type. 483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Promote, // This should be promoted to the next larger type. 493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Expand, // This integer type should be broken into smaller pieces. 503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner }; 513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ValueTypeActions - This is a bitvector that contains two bits for each 533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type, where the two bits correspond to the LegalizeAction enum. 543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// This can be queried with "getTypeAction(VT)". 556a648614e88586e85a36ceb5c1d3b84e4f55b458Nate Begeman unsigned long long ValueTypeActions; 563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// NeedsAnotherIteration - This is set when we expand a large integer 583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// operation into smaller integer operations, but the smaller operations are 593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// not set. This occurs only rarely in practice, for targets that don't have 603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 32-bit or larger integer registers. 613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool NeedsAnotherIteration; 623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizedNodes - For nodes that are of legal width, and that have more 643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates what regularized operand to use. This 653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// allows us to avoid legalizing the same thing more than once. 663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, SDOperand> LegalizedNodes; 673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6803c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// PromotedNodes - For nodes that are below legal width, and that have more 6903c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// than one use, this map indicates what promoted value to use. This allows 7003c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// us to avoid promoting the same thing more than once. 7103c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::map<SDOperand, SDOperand> PromotedNodes; 7203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ExpandedNodes - For nodes that need to be expanded, and which have more 743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates which which operands are the expanded 753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// version of the input. This allows us to avoid expanding the same node 763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// more than once. 773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> > ExpandedNodes; 783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 798afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner void AddLegalizedOperand(SDOperand From, SDOperand To) { 808afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner bool isNew = LegalizedNodes.insert(std::make_pair(From, To)).second; 818afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner assert(isNew && "Got into the map somehow?"); 828afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner } 8303c8546ec57523970874917854a2fb77b1ff598eChris Lattner void AddPromotedOperand(SDOperand From, SDOperand To) { 8403c8546ec57523970874917854a2fb77b1ff598eChris Lattner bool isNew = PromotedNodes.insert(std::make_pair(From, To)).second; 8503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isNew && "Got into the map somehow?"); 8603c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 878afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner 883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerpublic: 893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 909c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(SelectionDAG &DAG); 913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Run - While there is still lowering to do, perform a pass over the DAG. 933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Most regularization can be done in a single pass, but targets that require 943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// large values to be split into registers multiple times (e.g. i64 -> 4x 953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// i16) require iteration for these values (the first iteration will demote 963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// to i32, the second will demote to i16). 973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void Run() { 983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner do { 993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NeedsAnotherIteration = false; 1003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeDAG(); 1013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } while (NeedsAnotherIteration); 1023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// getTypeAction - Return how we should legalize values of this type, either 1053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// it is already legal or we need to expand it into multiple registers of 1063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// smaller integer type, or we need to promote it to a larger type. 1073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeAction getTypeAction(MVT::ValueType VT) const { 1083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return (LegalizeAction)((ValueTypeActions >> (2*VT)) & 3); 1093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// isTypeLegal - Return true if this type is legal on this target. 1123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 1133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isTypeLegal(MVT::ValueType VT) const { 1143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return getTypeAction(VT) == Legal; 1153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerprivate: 1183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void LegalizeDAG(); 1193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LegalizeOp(SDOperand O); 1213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void ExpandOp(SDOperand O, SDOperand &Lo, SDOperand &Hi); 12203c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand PromoteOp(SDOperand O); 1233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandLibCall(const char *Name, SDNode *Node, 12577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi); 12677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandIntToFP(bool isSigned, MVT::ValueType DestTy, 12777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Source); 128cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 1296269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand ExpandLegalINT_TO_FP(bool isSigned, 1306269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand LegalOp, 1316269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT); 1325a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman SDOperand PromoteLegalINT_TO_FP(SDOperand LegalOp, MVT::ValueType DestVT, 1335a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned); 1341618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner SDOperand PromoteLegalFP_TO_INT(SDOperand LegalOp, MVT::ValueType DestVT, 1351618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned); 13600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 137e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner bool ExpandShift(unsigned Opc, SDOperand Op, SDOperand Amt, 138e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi); 1395b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandShiftParts(unsigned NodeOp, SDOperand Op, SDOperand Amt, 1405b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi); 1415b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 1424759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi); 143e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 144b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner void SpliceCallInto(const SDOperand &CallResult, SDNode *OutChain); 145b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 1463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 1473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 1483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner}; 1503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 152b89175feffa7148c05d1d30a8e382b8d321edae5Chris Lattnerstatic unsigned getScalarizedOpcode(unsigned VecOp, MVT::ValueType VT) { 1535fbb5d2459a5410590f285250faa604576308a93Nate Begeman switch (VecOp) { 1545fbb5d2459a5410590f285250faa604576308a93Nate Begeman default: assert(0 && "Don't know how to scalarize this opcode!"); 1555fbb5d2459a5410590f285250faa604576308a93Nate Begeman case ISD::VADD: return MVT::isInteger(VT) ? ISD::ADD : ISD::FADD; 1565fbb5d2459a5410590f285250faa604576308a93Nate Begeman case ISD::VSUB: return MVT::isInteger(VT) ? ISD::SUB : ISD::FSUB; 1575fbb5d2459a5410590f285250faa604576308a93Nate Begeman case ISD::VMUL: return MVT::isInteger(VT) ? ISD::MUL : ISD::FMUL; 1585fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1595fbb5d2459a5410590f285250faa604576308a93Nate Begeman} 1603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1619c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris LattnerSelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag) 1629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner : TLI(dag.getTargetLoweringInfo()), DAG(dag), 1639c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner ValueTypeActions(TLI.getValueTypeActions()) { 1646a648614e88586e85a36ceb5c1d3b84e4f55b458Nate Begeman assert(MVT::LAST_VALUETYPE <= 32 && 1653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Too many value types for ValueTypeActions to hold!"); 1663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1686269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// ExpandLegalINT_TO_FP - This function is responsible for legalizing a 1696269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// INT_TO_FP operation of the specified operand when the target requests that 170cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we expand it. At this point, we know that the result and operand types are 171cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target. 1726269ed125fc492d81dc5e3f48482816fc9d47f49Jim LaskeySDOperand SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned, 1736269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0, 1746269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT) { 1756269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (Op0.getValueType() == MVT::i32) { 1766269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // simple 32-bit [signed|unsigned] integer to float/double expansion 1776269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey 1786269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get the stack frame index of a 8 byte buffer 1796269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MachineFunction &MF = DAG.getMachineFunction(); 1806269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey int SSFI = MF.getFrameInfo()->CreateStackObject(8, 8); 1816269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get address of 8 byte buffer 1826269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 1836269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // word offset constant for Hi/Lo address computation 1846269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy()); 1856269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // set up Hi and Lo (into buffer) address based on endian 1866269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Hi, Lo; 1876269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (TLI.isLittleEndian()) { 1886269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1896269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = StackSlot; 1906269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 1916269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = StackSlot; 1926269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1936269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 1946269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if signed map to unsigned space 1956269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0Mapped; 1966269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (isSigned) { 1976269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // constant used to invert sign bit (signed to unsigned mapping) 1986269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand SignBit = DAG.getConstant(0x80000000u, MVT::i32); 1996269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = DAG.getNode(ISD::XOR, MVT::i32, Op0, SignBit); 2006269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 2016269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = Op0; 2026269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2036269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the lo of the constructed double - based on integer input 2046269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store1 = DAG.getNode(ISD::STORE, MVT::Other, DAG.getEntryNode(), 2056269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped, Lo, DAG.getSrcValue(NULL)); 2066269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // initial hi portion of constructed double 2076269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand InitialHi = DAG.getConstant(0x43300000u, MVT::i32); 2086269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the hi of the constructed double - biased exponent 2096269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store2 = DAG.getNode(ISD::STORE, MVT::Other, Store1, 2106269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey InitialHi, Hi, DAG.getSrcValue(NULL)); 2116269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // load the constructed double 2126269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Load = DAG.getLoad(MVT::f64, Store2, StackSlot, 2136269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey DAG.getSrcValue(NULL)); 2146269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // FP constant to bias correct the final result 21502659d23637f69f90640bfa3e66919517103c57aJim Laskey SDOperand Bias = DAG.getConstantFP(isSigned ? 21602659d23637f69f90640bfa3e66919517103c57aJim Laskey BitsToDouble(0x4330000080000000ULL) 21702659d23637f69f90640bfa3e66919517103c57aJim Laskey : BitsToDouble(0x4330000000000000ULL), 2186269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::f64); 2196269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // subtract the bias 22001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Sub = DAG.getNode(ISD::FSUB, MVT::f64, Load, Bias); 2216269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // final result 2226269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Result; 2236269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // handle final rounding 2246269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (DestVT == MVT::f64) { 2256269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // do nothing 2266269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = Sub; 2276269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 2286269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if f32 then cast to f32 2296269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = DAG.getNode(ISD::FP_ROUND, MVT::f32, Sub); 2306269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2316269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey NeedsAnotherIteration = true; 2326269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey return Result; 2336269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2346269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey assert(!isSigned && "Legalize cannot Expand SINT_TO_FP for i64 yet"); 235cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Tmp1 = DAG.getNode(ISD::SINT_TO_FP, DestVT, Op0); 23600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2377cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Op0, 2387cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Op0.getValueType()), 2397cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 240cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 241cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 242cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SignSet, Four, Zero); 24300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2446269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // If the sign bit of the integer is set, the large number will be treated 2456269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // as a negative number. To counteract this, the dynamic code adds an 2466269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // offset depending on the data type. 247f4d32726e622c740b4befc803e604903eb1349dfChris Lattner uint64_t FF; 248f4d32726e622c740b4befc803e604903eb1349dfChris Lattner switch (Op0.getValueType()) { 249f4d32726e622c740b4befc803e604903eb1349dfChris Lattner default: assert(0 && "Unsupported integer type!"); 250f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i8 : FF = 0x43800000ULL; break; // 2^8 (as a float) 251f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i16: FF = 0x47800000ULL; break; // 2^16 (as a float) 252f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i32: FF = 0x4F800000ULL; break; // 2^32 (as a float) 253f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i64: FF = 0x5F800000ULL; break; // 2^64 (as a float) 254f4d32726e622c740b4befc803e604903eb1349dfChris Lattner } 255cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 256cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 25700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2585839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 259cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 260cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand FudgeInReg; 261cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (DestVT == MVT::f32) 262cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 263cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL)); 264cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner else { 265cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(DestVT == MVT::f64 && "Unexpected conversion"); 266cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = LegalizeOp(DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, 267cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getEntryNode(), CPIdx, 268cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL), MVT::f32)); 269cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 27000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 271cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NeedsAnotherIteration = true; 272473a99073cc29f59809a0d5dfee11f5e9e6ad2b7Chris Lattner return DAG.getNode(ISD::FADD, DestVT, Tmp1, FudgeInReg); 273cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 274cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 275149c58ce0b94e64faf3c4ccdbf894061cf7d66e1Chris Lattner/// PromoteLegalINT_TO_FP - This function is responsible for legalizing a 2761618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// *INT_TO_FP operation of the specified operand when the target requests that 277cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we promote it. At this point, we know that the result and operand types are 278cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target, and that there is a legal UINT_TO_FP or SINT_TO_FP 279cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// operation that takes a larger input. 2805a8441ea3fc145393d6274156bd05c4a006099eaNate BegemanSDOperand SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDOperand LegalOp, 2815a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman MVT::ValueType DestVT, 2825a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned) { 283cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // First step, figure out the appropriate *INT_TO_FP operation to use. 284cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner MVT::ValueType NewInTy = LegalOp.getValueType(); 28500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 286cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner unsigned OpToUse = 0; 28700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 288cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Scan for the appropriate larger type to use. 289cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner while (1) { 290cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NewInTy = (MVT::ValueType)(NewInTy+1); 291cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(MVT::isInteger(NewInTy) && "Ran out of possibilities!"); 29200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 293cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports SINT_TO_FP of this type, use it. 294cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, NewInTy)) { 295cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 296cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 297c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewInTy)) 298cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 299cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 300cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 301cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::SINT_TO_FP; 302cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 303cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 304cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 3055a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman if (isSigned) continue; 30600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 307cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports UINT_TO_FP of this type, use it. 308cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::UINT_TO_FP, NewInTy)) { 309cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 310cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 311c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewInTy)) 312cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 313cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 314cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 315cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::UINT_TO_FP; 316cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 317cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 318cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 31900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 320cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Otherwise, try a larger type. 321cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 322cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 323cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Make sure to legalize any nodes we create here in the next pass. 324cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NeedsAnotherIteration = true; 32500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 326cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Okay, we found the operation and type to use. Zero extend our input to the 327cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // desired type then run the operation on it. 328cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner return DAG.getNode(OpToUse, DestVT, 3295a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, 3305a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman NewInTy, LegalOp)); 331cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 332cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 3331618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// PromoteLegalFP_TO_INT - This function is responsible for legalizing a 3341618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// FP_TO_*INT operation of the specified operand when the target requests that 3351618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// we promote it. At this point, we know that the result and operand types are 3361618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// legal for the target, and that there is a legal FP_TO_UINT or FP_TO_SINT 3371618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// operation that returns a larger result. 3381618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris LattnerSDOperand SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDOperand LegalOp, 3391618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType DestVT, 3401618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned) { 3411618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // First step, figure out the appropriate FP_TO*INT operation to use. 3421618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType NewOutTy = DestVT; 343d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3441618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner unsigned OpToUse = 0; 345d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3461618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Scan for the appropriate larger type to use. 3471618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner while (1) { 3481618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NewOutTy = (MVT::ValueType)(NewOutTy+1); 3491618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner assert(MVT::isInteger(NewOutTy) && "Ran out of possibilities!"); 350d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3511618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_SINT returning this type, use it. 3521618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_SINT, NewOutTy)) { 3531618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3541618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 355c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewOutTy)) 3561618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3571618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3581618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3591618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_SINT; 3601618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3611618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3621618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 363d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3641618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_UINT of this type, use it. 3651618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_UINT, NewOutTy)) { 3661618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3671618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 368c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewOutTy)) 3691618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3701618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3711618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3721618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_UINT; 3731618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3741618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3751618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 376d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3771618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Otherwise, try a larger type. 3781618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 379d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3801618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Make sure to legalize any nodes we create here in the next pass. 3811618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NeedsAnotherIteration = true; 382d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3831618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Okay, we found the operation and type to use. Truncate the result of the 3841618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // extended FP_TO_*INT operation to the desired size. 3851618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return DAG.getNode(ISD::TRUNCATE, DestVT, 3861618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner DAG.getNode(OpToUse, NewOutTy, LegalOp)); 3871618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner} 3881618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 38932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner/// ComputeTopDownOrdering - Add the specified node to the Order list if it has 39032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner/// not been visited yet and if all of its operands have already been visited. 39132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattnerstatic void ComputeTopDownOrdering(SDNode *N, std::vector<SDNode*> &Order, 39232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::map<SDNode*, unsigned> &Visited) { 39332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner if (++Visited[N] != N->getNumOperands()) 39432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner return; // Haven't visited all operands yet 39532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 39632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner Order.push_back(N); 39732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 39832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner if (N->hasOneUse()) { // Tail recurse in common case. 39932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ComputeTopDownOrdering(*N->use_begin(), Order, Visited); 40032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner return; 40132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 40232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 40332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Now that we have N in, add anything that uses it if all of their operands 40432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // are now done. 40532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (SDNode::use_iterator UI = N->use_begin(), E = N->use_end(); UI != E;++UI) 40632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ComputeTopDownOrdering(*UI, Order, Visited); 40732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner} 40832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 4091618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 4103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 411ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // The legalize process is inherently a bottom-up recursive process (users 412ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // legalize their uses before themselves). Given infinite stack space, we 413ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // could just start legalizing on the root and traverse the whole graph. In 414ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // practice however, this causes us to run out of stack space on large basic 41532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // blocks. To avoid this problem, compute an ordering of the nodes where each 41632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // node is only legalized after all of its operands are legalized. 41732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::map<SDNode*, unsigned> Visited; 41832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::vector<SDNode*> Order; 419ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 42032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Compute ordering from all of the leaves in the graphs, those (like the 42132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // entry node) that have no operands. 42232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (SelectionDAG::allnodes_iterator I = DAG.allnodes_begin(), 42332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner E = DAG.allnodes_end(); I != E; ++I) { 424de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner if (I->getNumOperands() == 0) { 425de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner Visited[I] = 0 - 1U; 426de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner ComputeTopDownOrdering(I, Order, Visited); 427ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner } 428ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner } 429ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 430de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner assert(Order.size() == Visited.size() && 431de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner Order.size() == 432de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner (unsigned)std::distance(DAG.allnodes_begin(), DAG.allnodes_end()) && 43332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner "Error: DAG is cyclic!"); 43432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner Visited.clear(); 435ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 43632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (unsigned i = 0, e = Order.size(); i != e; ++i) { 43732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner SDNode *N = Order[i]; 43832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner switch (getTypeAction(N->getValueType(0))) { 43932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner default: assert(0 && "Bad type action!"); 44032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Legal: 44132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner LegalizeOp(SDOperand(N, 0)); 44232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 44332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Promote: 44432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner PromoteOp(SDOperand(N, 0)); 44532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 44632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Expand: { 44732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner SDOperand X, Y; 44832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ExpandOp(SDOperand(N, 0), X, Y); 44932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 45032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 45132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 45232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 45332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 45432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Finally, it's possible the root changed. Get the new root. 4553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand OldRoot = DAG.getRoot(); 45632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner assert(LegalizedNodes.count(OldRoot) && "Root didn't get legalized?"); 45732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner DAG.setRoot(LegalizedNodes[OldRoot]); 4583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandedNodes.clear(); 4603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizedNodes.clear(); 46171c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner PromotedNodes.clear(); 4623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remove dead nodes now. 46462fd269c146d9023efe32644e44cd97b88631d4fChris Lattner DAG.RemoveDeadNodes(OldRoot.Val); 4653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 4663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris LattnerSDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { 468c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Op.getValueType()) && 469e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner "Caller should expand or promote operands that are not legal!"); 47045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner SDNode *Node = Op.Val; 471e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 4723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If this operation defines any values that cannot be represented in a 473e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner // register on this target, make sure to expand or promote them. 47445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Node->getNumValues() > 1) { 47545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 47645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner switch (getTypeAction(Node->getValueType(i))) { 4773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: break; // Nothing to do. 4783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 4793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand T1, T2; 4803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Op.getValue(i), T1, T2); 4813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(LegalizedNodes.count(Op) && 4823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Expansion didn't add legal operands!"); 4833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return LegalizedNodes[Op]; 4843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 48603c8546ec57523970874917854a2fb77b1ff598eChris Lattner PromoteOp(Op.getValue(i)); 48703c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(LegalizedNodes.count(Op) && 48803c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Expansion didn't add legal operands!"); 48903c8546ec57523970874917854a2fb77b1ff598eChris Lattner return LegalizedNodes[Op]; 4903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 49345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 49445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 495e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::map<SDOperand, SDOperand>::iterator I = LegalizedNodes.find(Op); 496e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (I != LegalizedNodes.end()) return I->second; 4973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4989373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand Tmp1, Tmp2, Tmp3, Tmp4; 4993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Result = Op; 5013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 5033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 504d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getOpcode() >= ISD::BUILTIN_OP_END) { 505d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // If this is a target node, legalize it by legalizing the operands then 506d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // passing it through. 507d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<SDOperand> Ops; 508d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner bool Changed = false; 509d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 510d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 511d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Changed = Changed || Node->getOperand(i) != Ops.back(); 512d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 513d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Changed) 514d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getNumValues() == 1) 515d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Ops); 516d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner else { 517d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), 518d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Node->value_end()); 519d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 520d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 521d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner 522d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 523d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner AddLegalizedOperand(Op.getValue(i), Result.getValue(i)); 524d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner return Result.getValue(Op.ResNo); 525d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 526d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // Otherwise this is an unhandled builtin node. splat. 5273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 5283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to legalize this operator!"); 5293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 5303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EntryToken: 5313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::FrameIndex: 53232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::TargetFrameIndex: 53332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::Register: 53432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::TargetConstant: 5353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::GlobalAddress: 536b9debbf54c926036d5c22b3e7f0d12c79c1c15a3Chris Lattner case ISD::TargetGlobalAddress: 53703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::ExternalSymbol: 53869a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::ConstantPool: // Nothing to do. 53932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::BasicBlock: 54032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::CONDCODE: 54132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::VALUETYPE: 54232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::SRCVALUE: 54336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case ISD::STRING: 5440c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 5450c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner default: assert(0 && "This action is not supported yet!"); 5460c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner case TargetLowering::Custom: { 5470c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner SDOperand Tmp = TLI.LowerOperation(Op, DAG); 5480c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner if (Tmp.Val) { 5490c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner Result = LegalizeOp(Tmp); 5500c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner break; 5510c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } 5520c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } // FALLTHROUGH if the target doesn't want to lower this op after all. 5530c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner case TargetLowering::Legal: 5540c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner assert(isTypeLegal(Node->getValueType(0)) && "This must be legal!"); 5550c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner break; 5560c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } 5573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 55808951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertSext: 55908951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertZext: 56008951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 56108951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner if (Tmp1 != Node->getOperand(0)) 56208951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 56308951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Node->getOperand(1)); 56408951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner break; 565308575be66ec3870d27b19df044fda18448feb41Chris Lattner case ISD::MERGE_VALUES: 566308575be66ec3870d27b19df044fda18448feb41Chris Lattner return LegalizeOp(Node->getOperand(Op.ResNo)); 56769a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::CopyFromReg: 56869a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 56969a52155d2eff066b49dbac385113002fd9dba14Chris Lattner if (Tmp1 != Node->getOperand(0)) 570d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getCopyFromReg(Tmp1, 571d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Node->getOperand(1))->getReg(), 572d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getValueType(0)); 57313c184de29c09294ed63b01ac43e1b46c049278eChris Lattner else 57413c184de29c09294ed63b01ac43e1b46c049278eChris Lattner Result = Op.getValue(0); 57513c184de29c09294ed63b01ac43e1b46c049278eChris Lattner 57613c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // Since CopyFromReg produces two values, make sure to remember that we 57713c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // legalized both of them. 57813c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 57913c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 58013c184de29c09294ed63b01ac43e1b46c049278eChris Lattner return Result.getValue(Op.ResNo); 58118c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner case ISD::ImplicitDef: 58218c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 58318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner if (Tmp1 != Node->getOperand(0)) 584d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::ImplicitDef, MVT::Other, 585d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp1, Node->getOperand(1)); 58618c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner break; 587fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: { 588fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman MVT::ValueType VT = Op.getValueType(); 589fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman switch (TLI.getOperationAction(ISD::UNDEF, VT)) { 590ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman default: assert(0 && "This action is not supported yet!"); 591ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Expand: 592ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Promote: 593fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman if (MVT::isInteger(VT)) 594fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstant(0, VT); 595fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else if (MVT::isFloatingPoint(VT)) 596fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstantFP(0, VT); 597fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else 598fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman assert(0 && "Unknown value type!"); 599fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 600ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Legal: 601fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 602fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 603fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 604fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 60536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 60636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case ISD::LOCATION: 60736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner assert(Node->getNumOperands() == 5 && "Invalid LOCATION node!"); 60836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the input chain. 60936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 61036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner switch (TLI.getOperationAction(ISD::LOCATION, MVT::Other)) { 61136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Promote: 61236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner default: assert(0 && "This action is not supported yet!"); 61336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Expand: 61436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner // If the target doesn't support line numbers, ignore this node. 61536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Result = Tmp1; 61636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 61736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Legal: 6189ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner if (Tmp1 != Node->getOperand(0) || 6199ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner getTypeAction(Node->getOperand(1).getValueType()) == Promote) { 62036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner std::vector<SDOperand> Ops; 62136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Tmp1); 6229ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner if (getTypeAction(Node->getOperand(1).getValueType()) == Legal) { 6239ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(Node->getOperand(1)); // line # must be legal. 6249ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(Node->getOperand(2)); // col # must be legal. 6259ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner } else { 6269ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner // Otherwise promote them. 6279ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(PromoteOp(Node->getOperand(1))); 6289ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(PromoteOp(Node->getOperand(2))); 6299ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner } 63036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Node->getOperand(3)); // filename must be legal. 63136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Node->getOperand(4)); // working dir # must be legal. 63236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Result = DAG.getNode(ISD::LOCATION, MVT::Other, Ops); 63336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 63436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 63536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 63636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 63736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 6383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: 6393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // We know we don't need to expand constants here, constants only have one 6403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // value and we check that it is fine above. 6413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: Maybe we should handle things like targets that don't support full 6433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // 32-bit immediates? 6443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 6463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 6473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 6483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 6493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 6503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 6523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Check to see if this FP immediate is already legal. 6543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isLegal = false; 6553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 6563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner E = TLI.legal_fpimm_end(); I != E; ++I) 6573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (CFP->isExactlyValue(*I)) { 6583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner isLegal = true; 6593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!isLegal) { 6633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Otherwise we need to spill the constant to memory. 6643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool Extend = false; 6653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If a FP immediate is precise when represented as a float, we put it 6673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // into the constant pool as a float, even if it's is statically typed 6683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // as a double. 6693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = CFP->getValueType(0); 6703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isDouble = VT == MVT::f64; 6713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFP *LLVMC = ConstantFP::get(isDouble ? Type::DoubleTy : 6723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Type::FloatTy, CFP->getValue()); 67399939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner if (isDouble && CFP->isExactlyValue((float)CFP->getValue()) && 67499939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // Only do this if the target has a native EXTLOAD instruction from 67599939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // f32. 676c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::EXTLOAD, MVT::f32)) { 6773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LLVMC = cast<ConstantFP>(ConstantExpr::getCast(LLVMC, Type::FloatTy)); 6783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner VT = MVT::f32; 6793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Extend = true; 6803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 681edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 6825839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy()); 683f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner if (Extend) { 6845f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 6855f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 686f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } else { 68752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, 68852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 689f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } 6903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 693040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner case ISD::TokenFactor: 694040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Node->getNumOperands() == 2) { 695040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner bool Changed = false; 696040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op0 = LegalizeOp(Node->getOperand(0)); 697040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op1 = LegalizeOp(Node->getOperand(1)); 698040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Op0 != Node->getOperand(0) || Op1 != Node->getOperand(1)) 699040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 700040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } else { 701040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner std::vector<SDOperand> Ops; 702040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner bool Changed = false; 703040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner // Legalize the operands. 704040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 705040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op = Node->getOperand(i); 706040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Ops.push_back(LegalizeOp(Op)); 707040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Changed |= Ops[i] != Op; 708040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } 709040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Changed) 710040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Ops); 711a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 712a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner break; 713a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner 71416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_START: 71516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 7163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 717128b52d3d75f4b74367de43e891cd98b5a9b5483Chris Lattner // Do not try to legalize the target-specific arguments (#1+) 71845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner Tmp2 = Node->getOperand(0); 7191aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (Tmp1 != Tmp2) 72088de6e77bfadea8962b017f372658204ab71448cChris Lattner Node->setAdjCallChain(Tmp1); 72127d404ccd1e86b7fffaf8037bf6b6dfb0b9d683bNate Begeman 72216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // Note that we do not create new CALLSEQ_DOWN/UP nodes here. These 72388de6e77bfadea8962b017f372658204ab71448cChris Lattner // nodes are treated specially and are mutated in place. This makes the dag 72488de6e77bfadea8962b017f372658204ab71448cChris Lattner // legalization process more efficient and also makes libcall insertion 72588de6e77bfadea8962b017f372658204ab71448cChris Lattner // easier. 7263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 727fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner case ISD::DYNAMIC_STACKALLOC: 728fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 729fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 730fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 731fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 732adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Tmp3 != Node->getOperand(2)) { 733adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 734adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 735adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 736adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 737adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner } else 738513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner Result = Op.getValue(0); 739fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 740fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // Since this op produces two values, make sure to remember that we 741fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // legalized both of them. 742fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 743fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 744fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner return Result.getValue(Op.ResNo); 745fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 746d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 7473d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner case ISD::CALL: { 7483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 7493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 7503d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 7513d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 7523d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 7533d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 7543d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 7553d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 7563d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 7573d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 7583d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || Changed) { 7593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 7603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(Node->getNumValues()); 7613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 762ebda942efcb86634a6581aae76a0d0c92c4a232eChris Lattner RetTyVTs.push_back(Node->getValueType(i)); 763d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Result = SDOperand(DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 764d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL), 0); 76538d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner } else { 76638d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner Result = Result.getValue(0); 7673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 76838d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // Since calls produce multiple values, make sure to remember that we 76938d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // legalized all of them. 77038d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 77138d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 77238d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner return Result.getValue(Op.ResNo); 7733d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 774c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 775c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 776c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner if (Tmp1 != Node->getOperand(0)) 777c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); 778c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 779c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner 780c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 781c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 7827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 78347e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 78447e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 78547e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 78647e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 78747e9223e06390897c3834f8c527001df392570ffChris Lattner break; 78847e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 78947e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 79047e9223e06390897c3834f8c527001df392570ffChris Lattner break; 79147e9223e06390897c3834f8c527001df392570ffChris Lattner } 7927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 7937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 7947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 7957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 7967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 7977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 7987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 7997cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 8007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8017cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 8027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 803550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 804550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 805550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, MVT::i1); 806550b1e59c4eb5db020766012b1406fc56833251dChris Lattner 8077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 8087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 8097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 8107cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 8117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 8147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Basic block destination (Op#2) is always legal. 8157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 8167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 8177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 8187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 8227cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8237cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 824c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 8257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 8267cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 8277cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 8287cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 8297cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 8307cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, Tmp3, Node->getOperand(4)); 8317cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8327cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8347cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 8357cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 8367cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 8377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 8387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 8397cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 8407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 8417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 8427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 8437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 8447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 8467cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8477cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 8487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), 8497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, DAG.getConstant(0, Tmp2.getValueType()), 8507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 8517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 853c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 854411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case ISD::BRCONDTWOWAY: 855411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 856411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 857411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 858411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Legal: 859411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 860411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 861411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Promote: 862411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 863411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 864411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 865411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR 866411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // pair. 867411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { 868411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Promote: 869411e888c1b4155190c8cffe388631ee20693b309Chris Lattner default: assert(0 && "This action is not supported yet!"); 870411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Legal: 871411e888c1b4155190c8cffe388631ee20693b309Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 872411e888c1b4155190c8cffe388631ee20693b309Chris Lattner std::vector<SDOperand> Ops; 873411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp1); 874411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp2); 875411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(2)); 876411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(3)); 877411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); 878411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 879411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 880411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Expand: 8817cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If BRTWOWAY_CC is legal for this target, then simply expand this node 8827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // to that. Otherwise, skip BRTWOWAY_CC and expand directly to a 8837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // BRCOND/BR pair. 884c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::BRTWOWAY_CC, MVT::Other)) { 8857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 8867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 8877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 8897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 8917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 8927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 8937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 896411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Node->getOperand(2)); 8977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(3)); 8987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 899411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 900411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 901411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 9027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BRTWOWAY_CC: 9037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 904c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 9057cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 9067cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 9077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 9087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 9097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Node->getOperand(1), Tmp2, Tmp3, 9107cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 9117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 9157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 9167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 9177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 9187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If this target does not support BRTWOWAY_CC, lower it to a BRCOND/BR 9197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // pair. 9207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other)) { 9217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 9227cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 9237cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 9247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 9257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 9267cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 9277cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 9287cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 9297cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 9307cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 9317cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9327cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 9337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 9347cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 9357cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9367cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 9387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 9397cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 9407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(5)); 9417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: 9463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 9482d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 9493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 9503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 95152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(Node->getValueType(0), Tmp1, Tmp2, 95252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(2)); 9538afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner else 9548afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner Result = SDOperand(Node, 0); 955edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 9568afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // Since loads produce two values, make sure to remember that we legalized 9578afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // both of them. 9588afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 9598afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 9608afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner return Result.getValue(Op.ResNo); 9615fbb5d2459a5410590f285250faa604576308a93Nate Begeman 9620f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::EXTLOAD: 9630f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::SEXTLOAD: 96401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case ISD::ZEXTLOAD: { 9650f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9660f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 9670f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 9685f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner MVT::ValueType SrcVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 96901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), SrcVT)) { 97001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner default: assert(0 && "This action is not supported yet!"); 9711c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner case TargetLowering::Promote: 9721c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); 9735f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 9745f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), MVT::i8); 9751c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // Since loads produce two values, make sure to remember that we legalized 9761c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // both of them. 9771c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 9781c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 9791c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner return Result.getValue(Op.ResNo); 980edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 98101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Legal: 98201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Tmp1 != Node->getOperand(0) || 98301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Tmp2 != Node->getOperand(1)) 9845f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 9855f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 98601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner else 98701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = SDOperand(Node, 0); 98801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner 98901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Since loads produce two values, make sure to remember that we legalized 99001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // both of them. 99101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 99201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 99301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(Op.ResNo); 99401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Expand: 9959d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth //f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 9969d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 9979d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth SDOperand Load = DAG.getLoad(SrcVT, Tmp1, Tmp2, Node->getOperand(2)); 99831559081a4285f4b7282e765aea4ec8a8e1d396cAndrew Lenharth Result = DAG.getNode(ISD::FP_EXTEND, Node->getValueType(0), Load); 9999d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (Op.ResNo) 10009d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Load.getValue(1); 10019d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Result; 10029d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 100301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(Node->getOpcode() != ISD::EXTLOAD && 100401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner "EXTLOAD should always be supported!"); 100501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 100601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // zero/sign extend inreg. 10075f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 10085f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 100923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner SDOperand ValRes; 101023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SEXTLOAD) 101123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 101215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, DAG.getValueType(SrcVT)); 101323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner else 101423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getZeroExtendInReg(Result, SrcVT); 101501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), ValRes); 101601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 101701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Op.ResNo) 101801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(1); 101901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return ValRes; 102001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 102101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(0 && "Unreachable"); 102201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 10235dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case ISD::EXTRACT_ELEMENT: { 10245dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman MVT::ValueType OpTy = Node->getOperand(0).getValueType(); 10255dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman switch (getTypeAction(OpTy)) { 10265dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman default: 10275dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman assert(0 && "EXTRACT_ELEMENT action for type unimplemented!"); 10285dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 10295dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Legal: 10305dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) { 10315dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 1 -> Hi 10325dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::SRL, OpTy, Node->getOperand(0), 10335dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman DAG.getConstant(MVT::getSizeInBits(OpTy)/2, 10345dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman TLI.getShiftAmountTy())); 10355dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Result); 10365dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } else { 10375dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 0 -> Lo 10385dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), 10395dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Node->getOperand(0)); 10405dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 10415dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = LegalizeOp(Result); 10425dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 10435dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Expand: 10445dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // Get both the low and high parts. 10455dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 10465dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) 10475dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp2; // 1 -> Hi 10485dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman else 10495dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp1; // 0 -> Lo 10505dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 10515dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 10523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10535dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 10543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 10553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 10563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1057edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1058c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getOperand(2).getValueType()) && 1059d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner "Register type must be legal!"); 1060d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // Legalize the incoming value (must be legal). 1061d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 1062d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) 1063d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::CopyToReg, MVT::Other, Tmp1, 1064d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getOperand(1), Tmp2); 10653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 10673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 10683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 10703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 2: // ret val 10713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 10723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 10733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 10748afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 10753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 10763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 10783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 10793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 10803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Lo, Hi); 1081edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 10823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 10848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 10858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 10868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 10873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 10903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 10913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); 10923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 10943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<SDOperand> NewValues; 10953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 10963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) 10973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(i).getValueType())) { 10983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 10994e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NewValues.push_back(LegalizeOp(Node->getOperand(i))); 11003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 11023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 11033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(i), Lo, Hi); 11043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Lo); 11053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Hi); 1106edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 11073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 11098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Can't promote multiple return value yet!"); 11103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); 11123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::STORE: 11173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 11183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 11193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 11205d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 112103c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ 11225d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner if (CFP->getValueType(0) == MVT::f32) { 112300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1124cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(FloatToBits(CFP->getValue()), 1125cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i32), 1126cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 112752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 11285d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } else { 11295d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); 113000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1131cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(DoubleToBits(CFP->getValue()), 1132cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i64), 1133cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 113452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 11355d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 113684734ce8ef1a21eb347d4deca0bf32d59001f751Chris Lattner Node = Result.Val; 11375d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 11385d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner 11393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 11403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: { 11413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Val = LegalizeOp(Node->getOperand(1)); 11423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Val != Node->getOperand(1) || Tmp1 != Node->getOperand(0) || 11433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(2)) 114452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, 114552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 11463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 114903c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Truncate the value and store the result. 115003c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(1)); 115103c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp3, Tmp2, 11522d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 11539fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getValueType(Node->getOperand(1).getValueType())); 115403c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 115503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 11563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: 11573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 1158ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize; 11593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 11603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 11613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 11623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 11633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1164edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Lo = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Lo, Tmp2, 1165edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1166ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If this is a vector type, then we have to calculate the increment as 1167ab48be377298bd509427a29e174cf4e305138819Nate Begeman // the product of the element size in bytes, and the number of elements 1168ab48be377298bd509427a29e174cf4e305138819Nate Begeman // in the high half of the vector. 1169ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (MVT::Vector == Hi.getValueType()) { 1170ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElems = cast<ConstantSDNode>(Hi.getOperand(2))->getValue(); 1171ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Hi.getOperand(3))->getVT(); 1172ab48be377298bd509427a29e174cf4e305138819Nate Begeman IncrementSize = NumElems * MVT::getSizeInBits(EVT)/8; 1173ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 1174ab48be377298bd509427a29e174cf4e305138819Nate Begeman IncrementSize = MVT::getSizeInBits(Hi.getValueType())/8; 1175ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 11763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::ADD, Tmp2.getValueType(), Tmp2, 11773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 11783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Tmp2.getValueType()) && 11793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Pointers must be legal!"); 11802d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Again, claiming both parts of the store came form the same Instr 1181edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Hi, Tmp2, 1182edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1183ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1184ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner break; 11853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 118795762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 118895762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 11892c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 11902c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); 119195762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 119251b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth case ISD::READCYCLECOUNTER: 119351b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain 119451b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth if (Tmp1 != Node->getOperand(0)) 119551b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth Result = DAG.getNode(ISD::READCYCLECOUNTER, MVT::i64, Tmp1); 119649c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth 119749c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // Since rdcc produce two values, make sure to remember that we legalized 119849c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // both of them. 119949c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth AddLegalizedOperand(SDOperand(Node, 0), Result); 120049c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 120149c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth return Result.getValue(Op.ResNo); 120251b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth break; 1203f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 12040f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::TRUNCSTORE: 12050f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 12060f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 12070f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 12080f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 12090f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Legal: 12100f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 121113d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 121213d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // The only promote case we handle is TRUNCSTORE:i1 X into 121313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // -> TRUNCSTORE:i8 (and X, 1) 121413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner if (cast<VTSDNode>(Node->getOperand(4))->getVT() == MVT::i1 && 121513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TLI.getOperationAction(ISD::TRUNCSTORE, MVT::i1) == 121613d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TargetLowering::Promote) { 121713d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // Promote the bool to a mask then store. 121813d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp2 = DAG.getNode(ISD::AND, Tmp2.getValueType(), Tmp2, 121913d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner DAG.getConstant(1, Tmp2.getValueType())); 122013d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 122113d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Node->getOperand(3), DAG.getValueType(MVT::i8)); 122213d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 122313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } else if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 122413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp3 != Node->getOperand(2)) { 122545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 12269fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner Node->getOperand(3), Node->getOperand(4)); 122713d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } 12280f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 12290f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Promote: 12300f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Expand: 12310f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(0 && "Cannot handle illegal TRUNCSTORE yet!"); 12320f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner } 12330f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 12342ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 123547e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 123647e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 123747e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 123847e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 123947e9223e06390897c3834f8c527001df392570ffChris Lattner break; 124047e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 124147e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 124247e9223e06390897c3834f8c527001df392570ffChris Lattner break; 124347e9223e06390897c3834f8c527001df392570ffChris Lattner } 12443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 12452ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 124655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 1247b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { 124855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 12499373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 12509373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 12519373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1.getOperand(0), Tmp1.getOperand(1), 12529373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 12539373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 12549373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 1255550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 1256550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 1257550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, MVT::i1); 12589373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1, 12599373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 12609373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 12619373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 12629373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 126355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 126455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 126555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 != Node->getOperand(2)) 126655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), 126755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp1, Tmp2, Tmp3); 126855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 126955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 127055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner MVT::ValueType NVT = 127155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 127255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 127355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (MVT::isInteger(Tmp2.getValueType())) { 127413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner ExtOp = ISD::ANY_EXTEND; 127555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::TRUNCATE; 127655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 127755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::FP_EXTEND; 127855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::FP_ROUND; 127955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 128055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 128155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp2 = DAG.getNode(ExtOp, NVT, Tmp2); 128255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 = DAG.getNode(ExtOp, NVT, Tmp3); 128355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 128455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2,Tmp3); 128555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(TruncOp, Node->getValueType(0), Result); 128655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 128755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 128855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 12893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12909373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 12919373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 12929373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 12939373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 1294c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(0).getValueType())) { 129523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner // Everything is legal, see if we should expand this op or something. 129623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner switch (TLI.getOperationAction(ISD::SELECT_CC, 129723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0).getValueType())) { 129823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner default: assert(0 && "This action is not supported yet!"); 129923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Custom: { 130023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner SDOperand Tmp = 130123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner TLI.LowerOperation(DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), 130223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0), 130323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(1), Tmp3, Tmp4, 1304d7050a9c50211dd215cb3c2bc28b4fb6bfa4a116Chris Lattner Node->getOperand(4)), DAG); 130523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp.Val) { 130623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = LegalizeOp(Tmp); 130723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 130823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 130923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } // FALLTHROUGH if the target can't lower this operation after all. 131023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Legal: 131123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 131223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 131323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 131423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3)) { 131523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), Tmp1, Tmp2, 131623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3, Tmp4, Node->getOperand(4)); 131723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 131823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 13199373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 13209373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 13219373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 13229373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp1 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 13239373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(0), // LHS 13249373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), // RHS 13259373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4))); 13267cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 13277cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 13287cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 13297cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 13307cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 13317cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, Tmp3.getValueType(), 13327cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1.getOperand(0), Tmp1.getOperand(1), 13337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, Tmp1.getOperand(2)); 13347cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 13357cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getSelectCC(Tmp1, 13367cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 13377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, ISD::SETNE); 13387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 13399373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 13409373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 13413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 13423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 13433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 13443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 13453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 13463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 13488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // LHS 13498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // RHS 13508b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 13518b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // If this is an FP compare, the operands have already been extended. 13528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(Node->getOperand(0).getValueType())) { 13538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner MVT::ValueType VT = Node->getOperand(0).getValueType(); 135471c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 13558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 13568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Otherwise, we have to insert explicit sign or zero extends. Note 13578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // that we could insert sign extends for ALL conditions, but zero extend 13588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // is cheaper on many machines (an AND instead of two shifts), so prefer 13598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // it. 13607cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 13618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner default: assert(0 && "Unknown integer comparison!"); 13628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETEQ: 13638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETNE: 13648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGE: 13658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGT: 13668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULE: 13678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULT: 13688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // ALL of these operations will work if we either sign or zero extend 13698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // the operands (including the unsigned comparisons!). Zero extend is 13708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // usually a simpler/cheaper operation, so prefer it. 137123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 137223993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 13738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 13748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGE: 13758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGT: 13768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLT: 13778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLE: 137815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 137915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 138015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 138115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 13828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 13838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 13848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 13853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1386edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case Expand: 13873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 13883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LHSLo, LHSHi); 13893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RHSLo, RHSHi); 13907cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 13913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETEQ: 13923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETNE: 139308b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSLo == RHSHi) 139408b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 139508b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSCST->isAllOnesValue()) { 139608b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner // Comparison to -1. 139708b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Tmp1 = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 1398b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSLo; 1399edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 140008b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner } 140108b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner 14023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 14033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 14043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp2); 1405b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 14063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 14073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 14085b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 14095b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // X > -1, x < 0 14105b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Node->getOperand(1))) 14117cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner if ((cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETLT && 14125b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner CST->getValue() == 0) || // X < 0 14137cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner (cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETGT && 1414b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman (CST->isAllOnesValue()))) { // X > -1 1415b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp1 = LHSHi; 1416b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSHi; 1417b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1418b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 14195b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner 14203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: This generated code sucks. 14213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ISD::CondCode LowCC; 14227cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 14233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: assert(0 && "Unknown integer setcc!"); 14243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLT: 14253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 14263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGT: 14273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 14283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLE: 14293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 14303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGE: 14313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 14323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1433edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 14343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 14353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 14363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 14373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 14383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 14393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 14407cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp1 = DAG.getSetCC(Node->getValueType(0), LHSLo, RHSLo, LowCC); 14417cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getNode(ISD::SETCC, Node->getValueType(0), LHSHi, RHSHi, 14427cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 14437cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getSetCC(Node->getValueType(0), LHSHi, RHSHi, ISD::SETEQ); 1444b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1445b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result, Tmp1, Tmp2)); 1446b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman return Result; 14473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 14483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1449b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman 1450b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch(TLI.getOperationAction(ISD::SETCC, Node->getOperand(0).getValueType())) { 1451b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman default: 1452b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman assert(0 && "Cannot handle this action for SETCC yet!"); 1453b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1454ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth case TargetLowering::Promote: { 1455ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // First step, figure out the appropriate operation to use. 1456ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Allow SETCC to not be supported for all legal data types 1457ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Mostly this targets FP 1458ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth MVT::ValueType NewInTy = Node->getOperand(0).getValueType(); 1459ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth MVT::ValueType OldVT = NewInTy; 1460ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1461ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Scan for the appropriate larger type to use. 1462ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth while (1) { 1463ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth NewInTy = (MVT::ValueType)(NewInTy+1); 1464ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1465ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(MVT::isInteger(NewInTy) == MVT::isInteger(OldVT) && 1466ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the integer world"); 1467ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(MVT::isFloatingPoint(NewInTy) == MVT::isFloatingPoint(OldVT) && 1468ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the floating point world"); 1469ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1470ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // If the target supports SETCC of this type, use it. 1471ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth if (TLI.getOperationAction(ISD::SETCC, NewInTy) == TargetLowering::Legal) 1472ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth break; 1473ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1474ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth if (MVT::isInteger(NewInTy)) 1475ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(0 && "Cannot promote Legal Integer SETCC yet"); 1476ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth else { 1477ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth Tmp1 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp1); 1478ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth Tmp2 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp2); 1479ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1480ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 14815e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 14825e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Node->getOperand(2)); 14835e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth break; 1484ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1485b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Legal: 1486b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1487b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 1488b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1489b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1490b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Expand: 1491b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // Expand a setcc node into a select_cc of the same condition, lhs, and 1492b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // rhs that selects between const 1 (true) and const 0 (false). 1493b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman MVT::ValueType VT = Node->getValueType(0); 1494b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SELECT_CC, VT, Tmp1, Tmp2, 1495b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman DAG.getConstant(1, VT), DAG.getConstant(0, VT), 1496b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1497b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(Result); 1498b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1499b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 15003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 15013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1502e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMSET: 1503e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMCPY: 1504e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMMOVE: { 1505deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Chain 1506e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Pointer 1507e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner 1508e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { // memset = ubyte 1509e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner switch (getTypeAction(Node->getOperand(2).getValueType())) { 1510e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand a byte!"); 1511e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1512deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 1513e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1514e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1515deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); 1516e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1517e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1518e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } else { 1519edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Tmp3 = LegalizeOp(Node->getOperand(2)); // memcpy/move = pointer, 1520e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1521272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1522272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp4; 1523272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(3).getValueType())) { 15246814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner case Expand: { 15256814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner // Length is too big, just take the lo-part of the length. 15266814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner SDOperand HiPart; 15276814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner ExpandOp(Node->getOperand(3), HiPart, Tmp4); 15286814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner break; 15296814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner } 1530e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1531e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = LegalizeOp(Node->getOperand(3)); 1532e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1533e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1534e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = PromoteOp(Node->getOperand(3)); 1535272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1536272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner } 1537272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1538272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp5; 1539272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(4).getValueType())) { // uint 1540272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 1541272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Legal: 1542272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner Tmp5 = LegalizeOp(Node->getOperand(4)); 1543272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1544272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Promote: 1545e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp5 = PromoteOp(Node->getOperand(4)); 1546e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1547e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 154855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 154955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 155055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 155107dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 155207dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 155307dffd6af673c73352150583150b242a93694f00Chris Lattner TLI.LowerOperation(DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, 155407dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp2, Tmp3, Tmp4, Tmp5), DAG); 155507dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 155607dffd6af673c73352150583150b242a93694f00Chris Lattner Result = LegalizeOp(Tmp); 155707dffd6af673c73352150583150b242a93694f00Chris Lattner break; 155807dffd6af673c73352150583150b242a93694f00Chris Lattner } 155907dffd6af673c73352150583150b242a93694f00Chris Lattner // FALLTHROUGH if the target thinks it is legal. 156007dffd6af673c73352150583150b242a93694f00Chris Lattner } 156155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 1562e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 1563e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || 1564e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp5 != Node->getOperand(4)) { 1565e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<SDOperand> Ops; 1566e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 1567e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 1568e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 1569e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 157055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 157155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: { 1572e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Otherwise, the target does not support this operation. Lower the 1573e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // operation to an explicit libcall as appropriate. 1574e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 1575e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner const Type *IntPtrTy = TLI.getTargetData().getIntPtrType(); 1576e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1577e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 15783bfbf4ea990930d153e58e153f319408341a94feReid Spencer const char *FnName = 0; 1579e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { 1580e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1581e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Extend the ubyte argument to be an int value for the call. 1582e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Tmp3); 1583e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, Type::IntTy)); 1584e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1585e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 1586e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = "memset"; 1587e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else if (Node->getOpcode() == ISD::MEMCPY || 1588e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Node->getOpcode() == ISD::MEMMOVE) { 1589e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1590e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, IntPtrTy)); 1591e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1592e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = Node->getOpcode() == ISD::MEMMOVE ? "memmove" : "memcpy"; 1593e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else { 1594e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner assert(0 && "Unknown op!"); 1595e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 159645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 1597e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 1598adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(Tmp1, Type::VoidTy, false, CallingConv::C, false, 1599e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner DAG.getExternalSymbol(FnName, IntPtr), Args, DAG); 1600c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner Result = CallResult.second; 1601c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner NeedsAnotherIteration = true; 160255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 160355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 1604e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 1605e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner break; 1606e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 160752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 160852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::READPORT: 160952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 161052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 16116d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 16123e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 16133e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 16143e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 16153e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 16163e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 16173e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 16183e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 161952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = SDOperand(Node, 0); 162052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // Since these produce two values, make sure to remember that we legalized 162152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // both of them. 162252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 162352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 162452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner return Result.getValue(Op.ResNo); 162552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::WRITEPORT: 162652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 162752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 162852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 162952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 163052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 != Node->getOperand(2)) 163152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 163252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner break; 163352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 16346d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::READIO: 16356d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 16366d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 16376d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 16386d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 16396d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 16406d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 16416d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 16423e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 16433e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 16443e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 16453e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 16463e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 16473e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 16483e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 16496d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = SDOperand(Node, 0); 16506d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 16516d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 16526d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a load from memory. 16536d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0), 16546d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), DAG.getSrcValue(NULL)); 16556d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 16566d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 16576d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 16586d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 16596d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Since these produce two values, make sure to remember that we legalized 16606d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // both of them. 16616d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 16626d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 16636d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner return Result.getValue(Op.ResNo); 16646d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 16656d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::WRITEIO: 16666d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 16676d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 16686d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 16696d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 16706d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 16716d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1).getValueType())) { 16726d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 16736d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 16746d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 16756d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 16766d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 != Node->getOperand(2)) 16776d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 16786d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 16796d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 16806d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a store to memory. 16816d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0), 16826d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), Node->getOperand(2), 16836d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getSrcValue(NULL)); 16846d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 16856d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 16866d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 16876d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 16886d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 168984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::ADD_PARTS: 16905b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SUB_PARTS: 16915b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 16925b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 16935b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 169484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 169584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 169684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 169784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 169884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 169984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 1700e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (Changed) { 1701e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 1702e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 1703e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 17042c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 17052c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 17062c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 17072c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 17082c8086f4b9916b2d02842be5e375276023225fbaChris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 17092c8086f4b9916b2d02842be5e375276023225fbaChris Lattner return Result.getValue(Op.ResNo); 171084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 17112c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 17122c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 17133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 17143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 17153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 1716c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 1717c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 17183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 17193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 17203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 17213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 17223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 172303c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 172403c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 172503c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 172601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 172701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 172801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 172901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 17303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1731f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth switch (getTypeAction(Node->getOperand(1).getValueType())) { 1732f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Expand: assert(0 && "Not possible"); 1733f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Legal: 1734f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 1735f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1736f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Promote: 1737f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the RHS. 1738f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1739f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth } 17403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 17413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 17423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 17433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1744edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1745419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case ISD::BUILD_PAIR: { 1746419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman MVT::ValueType PairTy = Node->getValueType(0); 1747419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman // TODO: handle the case where the Lo and Hi operands are not of legal type 1748419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Lo 1749419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Hi 1750419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman switch (TLI.getOperationAction(ISD::BUILD_PAIR, PairTy)) { 1751419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Legal: 1752419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1753419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = DAG.getNode(ISD::BUILD_PAIR, PairTy, Tmp1, Tmp2); 1754419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1755419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Promote: 1756419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Custom: 1757419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman assert(0 && "Cannot promote/custom this yet!"); 1758419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Expand: 1759419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, PairTy, Tmp1); 1760419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::ANY_EXTEND, PairTy, Tmp2); 1761419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::SHL, PairTy, Tmp2, 1762419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman DAG.getConstant(MVT::getSizeInBits(PairTy)/2, 1763419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman TLI.getShiftAmountTy())); 1764419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::OR, PairTy, Tmp1, Tmp2)); 1765419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1766419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 1767419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1768419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 1769419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman 1770c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 1771c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 177201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 1773c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1774c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 1775c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1776c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Legal: 1777c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman if (Tmp1 != Node->getOperand(0) || 1778c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 != Node->getOperand(1)) 1779edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 1780c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2); 1781c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1782c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Promote: 1783c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Custom: 1784c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman assert(0 && "Cannot promote/custom handle this yet!"); 17854c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner case TargetLowering::Expand: 17864c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner if (MVT::isInteger(Node->getValueType(0))) { 17874c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner MVT::ValueType VT = Node->getValueType(0); 17884c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner unsigned Opc = (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 17894c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(Opc, VT, Tmp1, Tmp2); 17904c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::MUL, VT, Result, Tmp2); 17914c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::SUB, VT, Tmp1, Result); 17924c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner } else { 17934c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner // Floating point mod -> fmod libcall. 17944c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner const char *FnName = Node->getValueType(0) == MVT::f32 ? "fmodf":"fmod"; 17954c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner SDOperand Dummy; 17964c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = ExpandLibCall(FnName, Node, Dummy); 1797c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1798c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1799c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1800c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 18012c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 1802691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1803691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1804691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1805691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 1806691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1807691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 1808691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth if (Tmp1 != Node->getOperand(0)) 1809691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1810691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1811691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 1812691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType OVT = Tmp1.getValueType(); 1813691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 1814edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 1815edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 1816691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 1817691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 1818691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1819691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch(Node->getOpcode()) 1820691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth { 1821691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1822691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 1823691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1824691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1825691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 18267cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 18277cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), 18287cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ); 182900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 1830691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(OVT),NVT), Tmp1); 1831691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1832691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1833691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 183400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 183500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 1836691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getSizeInBits(OVT), NVT)); 1837691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1838691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1839691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1840691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1841691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Custom: 1842691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth assert(0 && "Cannot custom handle this yet!"); 1843691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 1844ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth switch(Node->getOpcode()) 1845ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth { 1846ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth case ISD::CTPOP: { 1847e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner static const uint64_t mask[6] = { 1848e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 1849e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 1850e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 1851e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner }; 1852ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth MVT::ValueType VT = Tmp1.getValueType(); 1853e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner MVT::ValueType ShVT = TLI.getShiftAmountTy(); 1854e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner unsigned len = getSizeInBits(VT); 1855e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 1856ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 1857e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp2 = DAG.getConstant(mask[i], VT); 1858e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp3 = DAG.getConstant(1ULL << i, ShVT); 185900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::ADD, VT, 1860ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, Tmp1, Tmp2), 1861ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, 1862ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3), 1863ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp2)); 1864ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1865ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Result = Tmp1; 1866ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1867ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 186857ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTLZ: { 186957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina /* for now, we do this: 18705c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 1); 18715c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 2); 18725c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner ... 18735c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>16); 187400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen x = x | (x >>32); // for 64-bit input 18755c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner return popcount(~x); 187600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 18775c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner but see also: http://www.hackersdelight.org/HDcode/nlz.cc */ 18785c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 187957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina MVT::ValueType ShVT = TLI.getShiftAmountTy(); 188057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina unsigned len = getSizeInBits(VT); 188157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 188257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getConstant(1ULL << i, ShVT); 188300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::OR, VT, Tmp1, 188457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3)); 188557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 188657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getNode(ISD::XOR, VT, Tmp1, DAG.getConstant(~0ULL, VT)); 18875c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 188818aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 188957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 189057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTTZ: { 189100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen // for now, we use: { return popcount(~x & (x - 1)); } 1892d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // unless the target has ctlz but not ctpop, in which case we use: 1893d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // { return 32 - nlz(~x & (x-1)); } 1894d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // see also http://www.hackersdelight.org/HDcode/ntz.cc 18955c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 18965c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp2 = DAG.getConstant(~0ULL, VT); 189700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp3 = DAG.getNode(ISD::AND, VT, 18985c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::XOR, VT, Tmp1, Tmp2), 18995c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::SUB, VT, Tmp1, 19005c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getConstant(1, VT))); 1901d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // If ISD::CTLZ is legal and CTPOP isn't, then do that instead 1902c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::CTPOP, VT) && 1903c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::CTLZ, VT)) { 190400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = LegalizeOp(DAG.getNode(ISD::SUB, VT, 1905d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getConstant(getSizeInBits(VT), VT), 1906d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getNode(ISD::CTLZ, VT, Tmp3))); 1907d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } else { 1908d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 1909d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } 191018aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 191157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 1912ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth default: 1913ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth assert(0 && "Cannot expand this yet!"); 1914ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1915ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1916691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1917691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1918691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 191900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 19202c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 19212c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 19222c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 1923da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 1924da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 1925da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 19262c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 19272c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 19282c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 19292c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 19302c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 19312c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 19322c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Promote: 19332c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Custom: 19342c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Cannot promote/custom handle this yet!"); 19352c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 1936f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1937f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FNEG: { 19382c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 19392c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 194001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = LegalizeOp(DAG.getNode(ISD::FSUB, Node->getValueType(0), 19412c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2, Tmp1)); 1942f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1943f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1944f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 19454af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 19464af6e0d7836126630f579b0a34f054321187f00bChris Lattner MVT::ValueType VT = Node->getValueType(0); 19474af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 19487cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, Tmp2, ISD::SETUGT); 19494af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp3 = DAG.getNode(ISD::FNEG, VT, Tmp1); 19504af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = DAG.getNode(ISD::SELECT, VT, Tmp2, Tmp1, Tmp3); 19514af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = LegalizeOp(Result); 1952f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1953f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1954f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: 1955f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: 1956f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: { 1957f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner MVT::ValueType VT = Node->getValueType(0); 1958f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner const char *FnName = 0; 1959f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1960f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: FnName = VT == MVT::f32 ? "sqrtf" : "sqrt"; break; 1961f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: FnName = VT == MVT::f32 ? "sinf" : "sin"; break; 1962f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: FnName = VT == MVT::f32 ? "cosf" : "cos"; break; 1963f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 1964f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 19652ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman SDOperand Dummy; 19662ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman Result = ExpandLibCall(FnName, Node, Dummy); 1967f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1968f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1969f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: 19704af6e0d7836126630f579b0a34f054321187f00bChris Lattner assert(0 && "Unreachable!"); 19712c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 19722c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 19732c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 19742c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 19752c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 19762c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 1977fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::SINT_TO_FP: 1978fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::UINT_TO_FP: { 1979fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP; 1980fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1981fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1982d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen switch (TLI.getOperationAction(Node->getOpcode(), 1983fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType())) { 1984fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner default: assert(0 && "Unknown operation action!"); 1985fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Expand: 19866269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = ExpandLegalINT_TO_FP(isSigned, 19876269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey LegalizeOp(Node->getOperand(0)), 19886269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Node->getValueType(0)); 1989fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 1990fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 1991fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Promote: 1992fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteLegalINT_TO_FP(LegalizeOp(Node->getOperand(0)), 1993fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), 1994fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner isSigned); 1995fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 1996fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 1997fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Legal: 1998fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 19995b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth case TargetLowering::Custom: { 20005b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); 20015b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth SDOperand Tmp = 20025b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 20035b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth Tmp = TLI.LowerOperation(Tmp, DAG); 20045b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth if (Tmp.Val) { 20055b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth AddLegalizedOperand(Op, Tmp); 20065b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth NeedsAnotherIteration = true; 20075b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth return Tmp; 20085b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } else { 20095b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth assert(0 && "Target Must Lower this"); 20105b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } 20115b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } 2012fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2013fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 2014fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2015fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2016fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2017fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2018fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2019fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, 2020fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), Node->getOperand(0)); 2021fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2022fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2023fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (isSigned) { 2024fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2025fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 2026fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result, DAG.getValueType(Node->getOperand(0).getValueType())); 2027fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SINT_TO_FP, Op.getValueType(), Result); 2028fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } else { 2029fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2030fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getZeroExtendInReg(Result, 2031fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType()); 2032fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::UINT_TO_FP, Op.getValueType(), Result); 2033fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2034fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2035fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2036fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2037fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2038fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::TRUNCATE: 2039fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2040fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2041fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2042fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2043fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2044fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2045fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2046fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 2047fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 2048fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // Since the result is legal, we should just be able to truncate the low 2049fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // part of the source. 2050fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Tmp1); 2051fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2052fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2053fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2054fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Op.getValueType(), Result); 2055fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2056fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2057fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2058d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 2059fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_SINT: 2060fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_UINT: 2061fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2062fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2063f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2064f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner 20651618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))){ 20661618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: assert(0 && "Unknown operation action!"); 20671618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Expand: 2068d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT) { 2069d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman SDOperand True, False; 2070d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType VT = Node->getOperand(0).getValueType(); 2071d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType NVT = Node->getValueType(0); 2072d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman unsigned ShiftAmt = MVT::getSizeInBits(Node->getValueType(0))-1; 2073d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getConstantFP((double)(1ULL << ShiftAmt), VT); 2074d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp3 = DAG.getSetCC(TLI.getSetCCResultTy(), 2075d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Node->getOperand(0), Tmp2, ISD::SETLT); 2076d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman True = DAG.getNode(ISD::FP_TO_SINT, NVT, Node->getOperand(0)); 2077d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::FP_TO_SINT, NVT, 207801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getNode(ISD::FSUB, VT, Node->getOperand(0), 2079d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2)); 2080d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::XOR, NVT, False, 2081d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getConstant(1ULL << ShiftAmt, NVT)); 2082d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, NVT, Tmp3, True, False)); 20832d56e72f09337a1cab3ba199a9467c159296f3faNate Begeman return Result; 2084d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2085d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman assert(0 && "Do not know how to expand FP_TO_SINT yet!"); 2086d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 2087d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman break; 20881618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Promote: 2089f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = PromoteLegalFP_TO_INT(Tmp1, Node->getValueType(0), 20901618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner Node->getOpcode() == ISD::FP_TO_SINT); 20911618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner AddLegalizedOperand(Op, Result); 20921618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return Result; 209307dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 209407dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 209507dffd6af673c73352150583150b242a93694f00Chris Lattner DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 209607dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp = TLI.LowerOperation(Tmp, DAG); 209707dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 209807dffd6af673c73352150583150b242a93694f00Chris Lattner AddLegalizedOperand(Op, Tmp); 209907dffd6af673c73352150583150b242a93694f00Chris Lattner NeedsAnotherIteration = true; 2100507f752f6ed28aa9f0ae680e95bfc93df4e9e2dcChris Lattner return Tmp; 210107dffd6af673c73352150583150b242a93694f00Chris Lattner } else { 210207dffd6af673c73352150583150b242a93694f00Chris Lattner // The target thinks this is legal afterall. 210307dffd6af673c73352150583150b242a93694f00Chris Lattner break; 210407dffd6af673c73352150583150b242a93694f00Chris Lattner } 210507dffd6af673c73352150583150b242a93694f00Chris Lattner } 21061618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 21071618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 21081618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 2109d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 2110fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2111fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2112fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2113fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2114fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2115fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2116fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2117fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2118fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2119fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2120fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2121d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 212213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 21233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 21243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 212503c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_EXTEND: 212603c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_ROUND: 21273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 21283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 21293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 21303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 21313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 21323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2133b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner case Expand: 21342c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2135b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner 213603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Promote: 213703c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 213813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 213913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = PromoteOp(Node->getOperand(0)); 214013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 214113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 21421713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner case ISD::ZERO_EXTEND: 21431713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 214413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 214523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 214623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 214703c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 214803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SIGN_EXTEND: 21491713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 215013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 21511713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 215215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 215315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 21541713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 215503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_EXTEND: 21561713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 21571713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner if (Result.getValueType() != Op.getValueType()) 21581713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner // Dynamically dead while we have only 2 FP types. 21591713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::FP_EXTEND, Op.getValueType(), Result); 21601713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 216103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_ROUND: 2162f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 2163f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2164f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 216503c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 21663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 21673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 21680f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 216923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 21700f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 217115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 217245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 217345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 217445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 217555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 217655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 217755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 217855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0)) 217955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 21805f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner DAG.getValueType(ExtraVT)); 218155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 218255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 218345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 218423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 218545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 218645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 218745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned BitsDiff = MVT::getSizeInBits(Node->getValueType(0)) - 218845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::getSizeInBits(ExtraVT); 218927ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner SDOperand ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 219045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SHL, Node->getValueType(0), 219145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 219245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SRA, Node->getValueType(0), 219345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 219445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 219545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // The only way we can lower this is to turn it into a STORETRUNC, 219645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 219745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 219845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 219945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 220045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 220145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner const Type *Ty = MVT::getTypeForValueType(ExtraVT); 220245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned TySize = (unsigned)TLI.getTargetData().getTypeSize(Ty); 220345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 220445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 2205edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman int SSFI = 220645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 220745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 220845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, DAG.getEntryNode(), 220952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(0), StackSlot, 22109fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getSrcValue(NULL), DAG.getValueType(ExtraVT)); 22115f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 22125f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result, StackSlot, DAG.getSrcValue(NULL), 22135f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner ExtraVT); 221445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 221545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 221645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 221745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = LegalizeOp(Result); 221855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 221945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 22200f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 22213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 222245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 22233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 222445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 222545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 222645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 22273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 22283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 22293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 22308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// PromoteOp - Given an operation that produces a value in an invalid type, 22318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// promote it to compute the value into a larger type. The produced value will 22328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// have the correct bits for the low portion of the register, but no guarantee 22338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// is made about the top bits: it may be zero, sign-extended, or garbage. 223403c8546ec57523970874917854a2fb77b1ff598eChris LattnerSDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) { 223503c8546ec57523970874917854a2fb77b1ff598eChris Lattner MVT::ValueType VT = Op.getValueType(); 223671c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 223703c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(getTypeAction(VT) == Promote && 223803c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Caller should expand or legalize operands that are not promotable!"); 223903c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(NVT > VT && MVT::isInteger(NVT) == MVT::isInteger(VT) && 224003c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Cannot promote to smaller type!"); 224103c8546ec57523970874917854a2fb77b1ff598eChris Lattner 224203c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Tmp1, Tmp2, Tmp3; 224303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 224403c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Result; 224503c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDNode *Node = Op.Val; 224603c8546ec57523970874917854a2fb77b1ff598eChris Lattner 22476fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op); 22486fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != PromotedNodes.end()) return I->second; 224945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 22500f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // Promotion needs an optimization step to clean up after it, and is not 22510f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // careful to avoid operations the target does not support. Make sure that 22520f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // all generated operations are legalized in the next iteration. 22530f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner NeedsAnotherIteration = true; 22540f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 225503c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 2256d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2257d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 225803c8546ec57523970874917854a2fb77b1ff598eChris Lattner default: 225903c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 226003c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(0 && "Do not know how to promote this operator!"); 226103c8546ec57523970874917854a2fb77b1ff598eChris Lattner abort(); 2262fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2263fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getNode(ISD::UNDEF, NVT); 2264fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 226503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::Constant: 2266ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner if (VT != MVT::i1) 2267ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND, NVT, Op); 2268ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner else 2269ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, NVT, Op); 227003c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantSDNode>(Result) && "Didn't constant fold zext?"); 227103c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 227203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::ConstantFP: 227303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::FP_EXTEND, NVT, Op); 227403c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantFPSDNode>(Result) && "Didn't constant fold fp_extend?"); 227503c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2276ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner 227782fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner case ISD::SETCC: 2278c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(TLI.getSetCCResultTy()) && "SetCC type is not legal??"); 22797cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(),Node->getOperand(0), 22807cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(1), Node->getOperand(2)); 228182fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = LegalizeOp(Result); 228282fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner break; 228303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 228403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 228503c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 228603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Legal: 228703c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 228803c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.getValueType() >= NVT && 228903c8546ec57523970874917854a2fb77b1ff598eChris Lattner "This truncation doesn't make sense!"); 229003c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (Result.getValueType() > NVT) // Truncate to NVT instead of VT 229103c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Result); 229203c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2293e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner case Promote: 2294e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // The truncation is not required, because we don't guarantee anything 2295e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // about high bits anyway. 2296e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner Result = PromoteOp(Node->getOperand(0)); 2297e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner break; 229803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Expand: 229979e46acd35df36477029e9f534ab1a366a98df56Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 230079e46acd35df36477029e9f534ab1a366a98df56Nate Begeman // Truncate the low part of the expanded value to the result type 2301e21c305ed85b2be4a27784ba52471f6b68fdd255Chris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Tmp1); 230203c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 230303c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 23048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SIGN_EXTEND: 23058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::ZERO_EXTEND: 230613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 23078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 23088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Smaller reg should have been promoted!"); 23098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 23108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Just do extend all the way to the larger type. 23118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 23128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 23138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 23158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Promote the reg if it's smaller. 23168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 23178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The high bits are not guaranteed to be anything. Insert an extend. 23188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND) 2319595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 232015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 232113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner else if (Node->getOpcode() == ISD::ZERO_EXTEND) 232223993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 232323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 23248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 23268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 23288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_EXTEND: 23298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Case not implemented. Dynamically dead with 2 FP types!"); 23308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_ROUND: 23318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 23328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Cannot expand FP regs!"); 23338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: assert(0 && "Unreachable with 2 FP types!"); 23348b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 23358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Do an FP_ROUND_INREG. 23368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 233715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 233815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 23398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 23418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 23438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SINT_TO_FP: 23448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UINT_TO_FP: 23458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 23468b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 23478b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 234877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 234977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 23508b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23518b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 23528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 23538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 23548b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP) 23558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 235615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 235715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 23588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 235923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 236023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 236177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 236277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 23638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 236577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, NVT, 236677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOperand(0)); 236777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // Round if we cannot tolerate excess precision. 236877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (NoExcessFPPrecision) 236915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 237015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 237177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 23728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 23738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 23758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_SINT: 23768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_UINT: 23778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 23788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 23798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 23808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 23828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input result is prerounded, so we don't have to do anything 23838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // special. 23848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 23858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 23878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "not implemented"); 23888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 2389d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // If we're promoting a UINT to a larger size, check to see if the new node 2390d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 2391d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // we can use that instead. This allows us to generate better code for 2392d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 2393d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // legal, such as PowerPC. 2394d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT && 2395c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) && 2396b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman (TLI.isOperationLegal(ISD::FP_TO_SINT, NVT) || 2397b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman TLI.getOperationAction(ISD::FP_TO_SINT, NVT)==TargetLowering::Custom)){ 2398d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(ISD::FP_TO_SINT, NVT, Tmp1); 2399d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2400d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2401d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 24028b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 24038b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 24042c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 24052c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 24062c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 24072c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(Tmp1.getValueType() == NVT); 24082c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 24092c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NOTE: we do not have to do any extra rounding here for 24102c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NoExcessFPPrecision, because we know the input will have the appropriate 24112c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // precision, and these operations don't modify precision at all. 24122c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 24132c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 2414da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2415da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2416da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 2417da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 2418da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner assert(Tmp1.getValueType() == NVT); 2419da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2420da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner if(NoExcessFPPrecision) 242115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 242215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 2423da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner break; 2424da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner 242503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::AND: 242603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::OR: 242703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::XOR: 24280f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::ADD: 24298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SUB: 24300f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::MUL: 24310f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // The input may have strange things in the top bits of the registers, but 243201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. They may have weird bits going out, but 24330f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // that too is okay if they are integer operations. 24340f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 24350f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 24360f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 24370f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 243801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 243901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 244001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 244101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 244201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // The input may have strange things in the top bits of the registers, but 244301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. 244401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 244501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 244601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 244701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 244801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 244901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Floating point operations will give excess precision that we may not be 245001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // able to tolerate. If we DO allow excess precision, just leave it, 245101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // otherwise excise it. 24528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // FIXME: Why would we need to round FP ops more than integer ones? 24538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Is Round(Add(Add(A,B),C)) != Round(Add(Round(Add(A,B)), C)) 245401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 245515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 245615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 24570f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 24580f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 24598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SDIV: 24608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SREM: 24618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be sign extended. 24628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 24638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 24648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(NVT)) { 246515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 246615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 246715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 246815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 24698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 24708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 24718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 24728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 24738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 247415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 247515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 24768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 247701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 247801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 247901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // These operators require that their input be fp extended. 248001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 248101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 248201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 248301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 248401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 248501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 248601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 248701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getValueType(VT)); 248801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 24898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 24908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UDIV: 24918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UREM: 24928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be zero extended. 24938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 24948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 24958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(MVT::isInteger(NVT) && "Operators don't apply to FP!"); 249623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 249723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 24988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 24998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 25008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 25018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SHL: 25028b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 25038b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 25048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SHL, NVT, Tmp1, Tmp2); 25058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 25068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRA: 25078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly sign extended. 25088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 250915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 251015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 25118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 25128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRA, NVT, Tmp1, Tmp2); 25138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 25148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRL: 25158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly zero extended. 25168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 251723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 25188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 25198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRL, NVT, Tmp1, Tmp2); 25208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 252103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::LOAD: 252203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 252303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2524ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Result = DAG.getExtLoad(ISD::EXTLOAD, NVT, Tmp1, Tmp2, 2525ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Node->getOperand(2), VT); 252603c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Remember that we legalized the chain. 252703c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 252803c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 25294c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::SEXTLOAD: 25304c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::ZEXTLOAD: 25314c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::EXTLOAD: 25324c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 25334c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 25348136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), NVT, Tmp1, Tmp2, 25358136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Node->getOperand(2), 25368136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner cast<VTSDNode>(Node->getOperand(3))->getVT()); 25374c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner // Remember that we legalized the chain. 25384c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 25394c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner break; 254003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SELECT: 254147e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 254247e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 254347e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 254447e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0));// Legalize the condition. 254547e9223e06390897c3834f8c527001df392570ffChris Lattner break; 254647e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 254747e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 254847e9223e06390897c3834f8c527001df392570ffChris Lattner break; 254947e9223e06390897c3834f8c527001df392570ffChris Lattner } 255003c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Legalize the op0 255103c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); // Legalize the op1 255203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2, Tmp3); 255303c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 25549373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 25559373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2 = PromoteOp(Node->getOperand(2)); // True 25569373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = PromoteOp(Node->getOperand(3)); // False 25579373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 25589373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), Tmp2, Tmp3, 25599373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4)); 25609373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 2561d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 25628ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner case ISD::CALL: { 25638ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 25648ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 25658ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 25663d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 25673d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) 25683d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 25693d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 25708ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 25718ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner "Can only promote single result calls"); 25728ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner std::vector<MVT::ValueType> RetTyVTs; 25738ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.reserve(2); 25748ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(NVT); 25758ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(MVT::Other); 2576d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 2577d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 25788ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Result = SDOperand(NC, 0); 25798ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 25808ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner // Insert the new chain mapping. 25818ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 25828ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner break; 2583edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 2584fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2585fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2586fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2587fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = Node->getOperand(0); 2588fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Zero extend the argument 2589fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2590fecf095292991bdf9396fec474011446107f9813Andrew Lenharth // Perform the larger operation, then subtract if needed. 2591fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2592fecf095292991bdf9396fec474011446107f9813Andrew Lenharth switch(Node->getOpcode()) 2593fecf095292991bdf9396fec474011446107f9813Andrew Lenharth { 2594fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2595fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = Tmp1; 2596fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2597fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2598fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 2599d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 26007cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), ISD::SETEQ); 260100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 2602fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(VT),NVT), Tmp1); 2603fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2604fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2605fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 260600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 260700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 2608fecf095292991bdf9396fec474011446107f9813Andrew Lenharth getSizeInBits(VT), NVT)); 2609fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2610fecf095292991bdf9396fec474011446107f9813Andrew Lenharth } 2611fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 261203c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 261303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 261403c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.Val && "Didn't set a result!"); 261503c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddPromotedOperand(Op, Result); 261603c8546ec57523970874917854a2fb77b1ff598eChris Lattner return Result; 261703c8546ec57523970874917854a2fb77b1ff598eChris Lattner} 26183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 261984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// ExpandAddSub - Find a clever way to expand this add operation into 262084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// subcomponents. 26214759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattnervoid SelectionDAGLegalize:: 26224759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris LattnerExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 26234759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi) { 262484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner // Expand the subcomponents. 262584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 262684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(LHS, LHSL, LHSH); 262784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(RHS, RHSL, RHSH); 262884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 262984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 263084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSL); 263184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSH); 263284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSL); 263384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSH); 2634e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2635e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 263684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Hi = Lo.getValue(1); 263784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner} 263884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 26395b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattnervoid SelectionDAGLegalize::ExpandShiftParts(unsigned NodeOp, 26405b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand Op, SDOperand Amt, 26415b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi) { 26425b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner // Expand the subcomponents. 26435b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand LHSL, LHSH; 26445b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandOp(Op, LHSL, LHSH); 26455b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 26465b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner std::vector<SDOperand> Ops; 26475b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSL); 26485b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSH); 26495b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(Amt); 2650cc0675a4be9a5133abd48ee272ff999ae48feabfChris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2651e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 26525b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Hi = Lo.getValue(1); 26535b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner} 26545b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 26555b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 2656e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// ExpandShift - Try to find a clever way to expand this shift operation out to 2657e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// smaller elements. If we can't find a way that is more efficient than a 2658e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// libcall on this target, return false. Otherwise, return true with the 2659e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// low-parts expanded into Lo and Hi. 2660e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattnerbool SelectionDAGLegalize::ExpandShift(unsigned Opc, SDOperand Op,SDOperand Amt, 2661e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi) { 2662e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner assert((Opc == ISD::SHL || Opc == ISD::SRA || Opc == ISD::SRL) && 2663e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner "This is not a shift!"); 2664f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2665e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(Op.getValueType()); 2666f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand ShAmt = LegalizeOp(Amt); 2667f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman MVT::ValueType ShTy = ShAmt.getValueType(); 2668f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned VTBits = MVT::getSizeInBits(Op.getValueType()); 2669f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned NVTBits = MVT::getSizeInBits(NVT); 2670f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2671f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Handle the case when Amt is an immediate. Other cases are currently broken 2672f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and are disabled. 2673f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Amt.Val)) { 2674f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned Cst = CN->getValue(); 2675f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Expand the incoming operand to be shifted, so that we have its parts 2676f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand InL, InH; 2677f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman ExpandOp(Op, InL, InH); 2678f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman switch(Opc) { 2679f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SHL: 2680f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2681f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2682f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2683f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2684f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2685f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst-NVTBits,ShTy)); 2686ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2687ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = DAG.getConstant(0, NVT); 2688ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = InL; 2689f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2690f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst, ShTy)); 2691f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::OR, NVT, 2692f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(Cst, ShTy)), 2693f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(NVTBits-Cst, ShTy))); 2694f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2695f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2696f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRL: 2697f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2698f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2699f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2700f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2701f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst-NVTBits,ShTy)); 2702f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2703ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2704ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2705ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = DAG.getConstant(0, NVT); 2706f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2707f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2708f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2709f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2710f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst, ShTy)); 2711f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2712f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2713f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRA: 2714f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2715edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 2716f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2717f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2718edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Lo = DAG.getNode(ISD::SRA, NVT, InH, 2719f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(Cst-NVTBits, ShTy)); 2720edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2721f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2722ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2723ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2724edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2725ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2726f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2727f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2728f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2729f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2730f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Cst, ShTy)); 2731f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2732f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2733f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2734f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2735f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // FIXME: The following code for expanding shifts using ISD::SELECT is buggy, 2736f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // so disable it for now. Currently targets are handling this via SHL_PARTS 2737f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and friends. 2738f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return false; 2739e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2740e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we have an efficient select operation (or if the selects will all fold 2741e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // away), lower to some complex code, otherwise just emit the libcall. 2742c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::SELECT, NVT) && !isa<ConstantSDNode>(Amt)) 2743e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return false; 2744e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2745e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand InL, InH; 2746e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ExpandOp(Op, InL, InH); 2747e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand NAmt = DAG.getNode(ISD::SUB, ShTy, // NAmt = 32-ShAmt 2748e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits, ShTy), ShAmt); 2749e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2750e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner // Compare the unmasked shift amount against 32. 27517cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand Cond = DAG.getSetCC(TLI.getSetCCResultTy(), ShAmt, 27527cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(NVTBits, ShTy), ISD::SETGE); 2753e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner 2754e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getShiftAmountFlavor() != TargetLowering::Mask) { 2755e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ShAmt = DAG.getNode(ISD::AND, ShTy, ShAmt, // ShAmt &= 31 2756e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2757e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner NAmt = DAG.getNode(ISD::AND, ShTy, NAmt, // NAmt &= 31 2758e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2759e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2760e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2761e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (Opc == ISD::SHL) { 2762e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << Amt) | (Lo >> NAmt) 2763e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, ShAmt), 2764e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, NAmt)); 2765e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(ISD::SHL, NVT, InL, ShAmt); // T2 = Lo << Amt&31 2766edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2767e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2768e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, DAG.getConstant(0, NVT), T2); 2769e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } else { 277077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand HiLoPart = DAG.getNode(ISD::SELECT, NVT, 27717cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getSetCC(TLI.getSetCCResultTy(), NAmt, 27727cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(32, ShTy), 27737cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ), 277477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(0, NVT), 277577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, NAmt)); 2776e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << NAmt) | (Lo >> Amt) 277777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiLoPart, 2778e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, ShAmt)); 2779e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(Opc, NVT, InH, ShAmt); // T2 = InH >> ShAmt&31 2780e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2781e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand HiPart; 278277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Opc == ISD::SRA) 278377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiPart = DAG.getNode(ISD::SRA, NVT, InH, 278477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2785e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner else 2786e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner HiPart = DAG.getConstant(0, NVT); 2787e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2788e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, HiPart, T2); 2789e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2790e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return true; 2791e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner} 279277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 27939530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindLatestCallSeqStart - Scan up the dag to find the latest (highest 27949530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqStart operation and occurs later than 27959c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// Found. 27969530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic void FindLatestCallSeqStart(SDNode *Node, SDNode *&Found) { 27979c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->getNodeDepth() <= Found->getNodeDepth()) return; 27982f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner 279916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_START, we already know this node occurs later 28009c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 280116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) { 28029c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 28039c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 28049c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 28059c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28069c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 28079c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(Node->getNumOperands() != 0 && 28089c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner "All leaves should have depth equal to the entry node!"); 2809829cb818065673a50101435f3c25e50ca82a02bfNate Begeman for (unsigned i = 0, e = Node->getNumOperands()-1; i != e; ++i) 28109530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(i).Val, Found); 28119c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28129c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 28139530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(Node->getNumOperands()-1).Val, 28149c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found); 28159c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 28169c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28179c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28189530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindEarliestCallSeqEnd - Scan down the dag to find the earliest (lowest 28199530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqEnd operation and occurs more recent 28209c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// than Found. 282182299e70977500209c951404e354510feffb8efaChris Lattnerstatic void FindEarliestCallSeqEnd(SDNode *Node, SDNode *&Found, 282282299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> &Visited) { 282382299e70977500209c951404e354510feffb8efaChris Lattner if ((Found && Node->getNodeDepth() >= Found->getNodeDepth()) || 282482299e70977500209c951404e354510feffb8efaChris Lattner !Visited.insert(Node).second) return; 28259c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 282616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_END, we already know this node occurs earlier 28279c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 282816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) { 28299c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 28309c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 28319c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 28329c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28339c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 28349c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end(); 28359c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (UI == E) return; 28369c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (--E; UI != E; ++UI) 283782299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 28389c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28399c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 284082299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 28419c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 28429c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28439530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqEnd - Given a chained node that is part of a call sequence, 284416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_END node that terminates the call sequence. 28459530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqEnd(SDNode *Node) { 284616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 28479c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return Node; 2848f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (Node->use_empty()) 28499530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return 0; // No CallSeqEnd 28509c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28519c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand TheChain(Node, Node->getNumValues()-1); 28522789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner if (TheChain.getValueType() != MVT::Other) 28532789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner TheChain = SDOperand(Node, 0); 28541aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (TheChain.getValueType() != MVT::Other) 28551aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman return 0; 2856edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2857edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman for (SDNode::use_iterator UI = Node->use_begin(), 28582f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner E = Node->use_end(); UI != E; ++UI) { 2859edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 28609c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Make sure to only follow users of our token chain. 28619c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *User = *UI; 28629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 28639c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (User->getOperand(i) == TheChain) 2864eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner if (SDNode *Result = FindCallSeqEnd(User)) 2865eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner return Result; 28669c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 28672f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner return 0; 28689c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 28699c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28709530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqStart - Given a chained node that is part of a call sequence, 287116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_START node that initiates the call sequence. 28729530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqStart(SDNode *Node) { 28739530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(Node && "Didn't find callseq_start for a call??"); 287416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 28750d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 28760d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 28770d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner "Node doesn't have a token chain argument!"); 28789530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqStart(Node->getOperand(0).Val); 28790d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 28800d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 28810d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 28829c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// FindInputOutputChains - If we are replacing an operation with a call we need 28839c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// to find the call that occurs before and the call that occurs after it to 28840d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// properly serialize the calls in the block. The returned operand is the 28850d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// input chain value for the new call (e.g. the entry node or the previous 28860d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// call), and OutChain is set to be the chain node to update to point to the 28870d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// end of the call chain. 28889c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnerstatic SDOperand FindInputOutputChains(SDNode *OpNode, SDNode *&OutChain, 28899c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand Entry) { 28909530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqStart = Entry.Val; 28919530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqEnd = 0; 28929530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(OpNode, LatestCallSeqStart); 28939530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner //std::cerr<<"Found node: "; LatestCallSeqStart->dump(); std::cerr <<"\n"; 2894edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 289516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // It is possible that no ISD::CALLSEQ_START was found because there is no 2896c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman // previous call in the function. LatestCallStackDown may in that case be 289716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // the entry node itself. Do not attempt to find a matching CALLSEQ_END 289816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // unless LatestCallStackDown is an CALLSEQ_START. 28991aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (LatestCallSeqStart->getOpcode() == ISD::CALLSEQ_START) { 29009530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = FindCallSeqEnd(LatestCallSeqStart); 29011aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman //std::cerr<<"Found end node: "; LatestCallSeqEnd->dump(); std::cerr <<"\n"; 29021aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } else { 29039530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = Entry.Val; 29041aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } 29059530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(LatestCallSeqEnd && "NULL return from FindCallSeqEnd"); 2906edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 29070d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Finally, find the first call that this must come before, first we find the 29089530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // CallSeqEnd that ends the call. 29090d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain = 0; 291082299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> Visited; 291182299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(OpNode, OutChain, Visited); 29129c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29139530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // If we found one, translate from the adj up to the callseq_start. 29140d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain) 29159530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner OutChain = FindCallSeqStart(OutChain); 29169c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29179530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return SDOperand(LatestCallSeqEnd, 0); 29189c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 29199c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 292000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen/// SpliceCallInto - Given the result chain of a libcall (CallResult), and a 2921b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattnervoid SelectionDAGLegalize::SpliceCallInto(const SDOperand &CallResult, 2922b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SDNode *OutChain) { 29230d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Nothing to splice it into? 29240d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain == 0) return; 29250d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29260d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(OutChain->getOperand(0).getValueType() == MVT::Other); 29270d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner //OutChain->dump(); 29280d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29290d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Form a token factor node merging the old inval and the new inval. 29300d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InToken = DAG.getNode(ISD::TokenFactor, MVT::Other, CallResult, 29310d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->getOperand(0)); 29320d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Change the node to refer to the new token. 29330d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->setAdjCallChain(InToken); 29340d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 29359c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 29369c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 293777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 293877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 293977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 294077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 294177e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize::ExpandLibCall(const char *Name, SDNode *Node, 294277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi) { 29439c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *OutChain; 29449c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand InChain = FindInputOutputChains(Node, OutChain, 29459c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner DAG.getEntryNode()); 2946f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (InChain.Val == 0) 2947f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner InChain = DAG.getEntryNode(); 29489c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 294977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 295077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 295177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner MVT::ValueType ArgVT = Node->getOperand(i).getValueType(); 295277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(ArgVT); 295377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Node->getOperand(i), ArgTy)); 295477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 295577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(Name, TLI.getPointerTy()); 2956edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 29570d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 295877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(Node->getValueType(0)); 29590d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallInfo = 2960adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, false, 2961adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 29620d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 296399c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SDOperand Result; 29640d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner switch (getTypeAction(CallInfo.first.getValueType())) { 296577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner default: assert(0 && "Unknown thing"); 296677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Legal: 296799c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner Result = CallInfo.first; 296899c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 296977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Promote: 297077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(0 && "Cannot promote this yet!"); 297177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Expand: 297299c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner ExpandOp(CallInfo.first, Result, Hi); 297399c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner CallInfo.second = LegalizeOp(CallInfo.second); 297499c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 297577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 297699c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner 297799c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SpliceCallInto(CallInfo.second, OutChain); 297899c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner NeedsAnotherIteration = true; 297999c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner return Result; 298077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 298177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 29829c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 298377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// ExpandIntToFP - Expand a [US]INT_TO_FP operation, assuming that the 298477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// destination type is legal. 298577e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize:: 298677e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) { 2987c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(DestTy) && "Destination type is not legal!"); 298877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(Source.getValueType()) == Expand && 298977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner "This is not an expansion!"); 299077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(Source.getValueType() == MVT::i64 && "Only handle expand from i64!"); 299177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 29920d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (!isSigned) { 2993e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(Source.getValueType() == MVT::i64 && 2994e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner "This only works for 64-bit -> FP"); 2995e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 2996e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // incoming integer is set. To handle this, we dynamically test to see if 2997e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // it is set, and, if so, add a fudge factor. 2998e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Lo, Hi; 2999e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner ExpandOp(Source, Lo, Hi); 3000e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 300166de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 300266de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // signed, then adjust the result if the sign bit is set. 300366de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner SDOperand SignedConv = ExpandIntToFP(true, DestTy, 300466de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), Lo, Hi)); 300566de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 30067cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Hi, 30077cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Hi.getValueType()), 30087cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 3009e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 3010e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 3011e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SignSet, Four, Zero); 3012383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner uint64_t FF = 0x5f800000ULL; 3013383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 3014383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 3015e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 30165839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 3017e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 3018e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand FudgeInReg; 3019e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner if (DestTy == MVT::f32) 302052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 302152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 3022e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner else { 3023e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(DestTy == MVT::f64 && "Unexpected conversion"); 30245f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 30255f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 3026e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 3027473a99073cc29f59809a0d5dfee11f5e9e6ad2b7Chris Lattner return DAG.getNode(ISD::FADD, DestTy, SignedConv, FudgeInReg); 302877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 30290d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 3030a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 3031a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, Source.getValueType())) { 3032a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 3033a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Legal: 3034a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Expand: 3035a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner break; // This case is handled below. 303607dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 303707dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand NV = TLI.LowerOperation(DAG.getNode(ISD::SINT_TO_FP, DestTy, 303807dffd6af673c73352150583150b242a93694f00Chris Lattner Source), DAG); 303907dffd6af673c73352150583150b242a93694f00Chris Lattner if (NV.Val) 304007dffd6af673c73352150583150b242a93694f00Chris Lattner return LegalizeOp(NV); 304107dffd6af673c73352150583150b242a93694f00Chris Lattner break; // The target decided this was legal after all 304207dffd6af673c73352150583150b242a93694f00Chris Lattner } 3043a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 3044a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 304513689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // Expand the source, then glue it back together for the call. We must expand 304613689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // the source in case it is shared (this pass of legalize must traverse it). 304713689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner SDOperand SrcLo, SrcHi; 304813689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner ExpandOp(Source, SrcLo, SrcHi); 304913689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner Source = DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), SrcLo, SrcHi); 305013689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 30510d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDNode *OutChain = 0; 30520d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InChain = FindInputOutputChains(Source.Val, OutChain, 30530d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner DAG.getEntryNode()); 30540d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner const char *FnName = 0; 30550d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (DestTy == MVT::f32) 30560d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdisf"; 30570d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner else { 30580d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(DestTy == MVT::f64 && "Unknown fp value type!"); 30590d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdidf"; 30600d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 30610d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 306277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(FnName, TLI.getPointerTy()); 306377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 306477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 306577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(Source.getValueType()); 306644d105b7faf5672a2af61a3f0fdfed0d437d5777Chris Lattner 306777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Source, ArgTy)); 306877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 306977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // We don't care about token chains for libcalls. We just use the entry 307077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // node as our input and ignore the output chain. This allows us to place 307177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // calls wherever we need them to satisfy data dependences. 307277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(DestTy); 30730d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 30740d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 3075adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, true, 3076adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 30770d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 3078b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallResult.second, OutChain); 30790d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallResult.first; 308077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 3081edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3082e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3083e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 30843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandOp - Expand the specified SDOperand into its two component pieces 30853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo&Hi. Note that the Op MUST be an expanded type. As a result of this, the 30863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// LegalizeNodes map is filled in for any results that are not expanded, the 30873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandedNodes map is filled in for any results that are expanded, and the 30883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo/Hi values are returned. 30893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){ 30903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = Op.getValueType(); 309171c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 30923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDNode *Node = Op.Val; 30933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(VT) == Expand && "Not an expanded type!"); 3094ab48be377298bd509427a29e174cf4e305138819Nate Begeman assert((MVT::isInteger(VT) || VT == MVT::Vector) && 3095ab48be377298bd509427a29e174cf4e305138819Nate Begeman "Cannot expand FP values!"); 3096ab48be377298bd509427a29e174cf4e305138819Nate Begeman assert(((MVT::isInteger(NVT) && NVT < VT) || VT == MVT::Vector) && 30973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand to FP value or to larger int value!"); 30983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 30996fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner // See if we already expanded it. 31006fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I 31016fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner = ExpandedNodes.find(Op); 31026fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != ExpandedNodes.end()) { 31036fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Lo = I->second.first; 31046fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Hi = I->second.second; 31056fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner return; 31063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 31073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 31084e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // Expanding to multiple registers needs to perform an optimization step, and 31094e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // is not careful to avoid operations the target does not support. Make sure 31104e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // that all generated operations are legalized in the next iteration. 31114e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NeedsAnotherIteration = true; 31123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 31133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 3114d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 3115d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 3116d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner default: 31173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 31183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to expand this operator!"); 31193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 3120fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 3121fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Lo = DAG.getNode(ISD::UNDEF, NVT); 3122fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Hi = DAG.getNode(ISD::UNDEF, NVT); 3123fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 31243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: { 31253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner uint64_t Cst = cast<ConstantSDNode>(Node)->getValue(); 31263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getConstant(Cst, NVT); 31273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT); 31283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 31293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 31303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3131d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner case ISD::BUILD_PAIR: 3132d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // Legalize both operands. FIXME: in the future we should handle the case 3133d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // where the two elements are not legal. 3134d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 3135d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Lo = LegalizeOp(Node->getOperand(0)); 3136d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Hi = LegalizeOp(Node->getOperand(1)); 3137d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner break; 3138d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner 3139edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner case ISD::CTPOP: 3140edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 31419b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner Lo = DAG.getNode(ISD::ADD, NVT, // ctpop(HL) -> ctpop(H)+ctpop(L) 31429b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Lo), 31439b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Hi)); 3144edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getConstant(0, NVT); 3145edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner break; 3146edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 314739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTLZ: { 314839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // ctlz (HL) -> ctlz(H) != 32 ? ctlz(H) : (ctlz(L)+32) 31493becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 315039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 315139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 31527cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand TopNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), HLZ, BitsC, 31537cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 315439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LowPart = DAG.getNode(ISD::CTLZ, NVT, Lo); 315539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LowPart = DAG.getNode(ISD::ADD, NVT, LowPart, BitsC); 315639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 315739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, TopNotZero, HLZ, LowPart); 315839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 315939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 316039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 316139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 316239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTTZ: { 316339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // cttz (HL) -> cttz(L) != 32 ? cttz(L) : (cttz(H)+32) 31643becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 316539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 316639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LTZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 31677cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand BotNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), LTZ, BitsC, 31687cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 316939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HiPart = DAG.getNode(ISD::CTTZ, NVT, Hi); 317039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HiPart = DAG.getNode(ISD::ADD, NVT, HiPart, BitsC); 317139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 317239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, BotNotZero, LTZ, HiPart); 317339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 317439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 317539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 3176edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 31773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: { 31783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 31793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 31802d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Lo = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 31813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 31823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Increment the pointer to the other half. 318338d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner unsigned IncrementSize = MVT::getSizeInBits(Lo.getValueType())/8; 31843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 31853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 318600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen //Is this safe? declaring that the two parts of the split load 31872d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //are from the same instruction? 31882d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Hi = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 3189ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner 3190ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Build a factor node to remember that this load is independent of the 3191ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // other one. 3192ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 3193ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi.getValue(1)); 3194edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 31953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember that we legalized the chain. 3196ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner AddLegalizedOperand(Op.getValue(1), TF); 31973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 31983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 31993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 32003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3201ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VLOAD: { 3202ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3203ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 3204ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElements =cast<ConstantSDNode>(Node->getOperand(2))->getValue(); 3205ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3206ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3207ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If we only have two elements, turn into a pair of scalar loads. 3208ab48be377298bd509427a29e174cf4e305138819Nate Begeman // FIXME: handle case where a vector of two elements is fine, such as 3209ab48be377298bd509427a29e174cf4e305138819Nate Begeman // 2 x double on SSE2. 3210ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (NumElements == 2) { 3211ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getLoad(EVT, Ch, Ptr, Node->getOperand(4)); 3212ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Increment the pointer to the other half. 3213ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize = MVT::getSizeInBits(EVT)/8; 3214ab48be377298bd509427a29e174cf4e305138819Nate Begeman Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 3215ab48be377298bd509427a29e174cf4e305138819Nate Begeman getIntPtrConstant(IncrementSize)); 3216ab48be377298bd509427a29e174cf4e305138819Nate Begeman //Is this safe? declaring that the two parts of the split load 3217ab48be377298bd509427a29e174cf4e305138819Nate Begeman //are from the same instruction? 3218ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getLoad(EVT, Ch, Ptr, Node->getOperand(4)); 3219ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 3220ab48be377298bd509427a29e174cf4e305138819Nate Begeman NumElements /= 2; // Split the vector in half 3221ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getVecLoad(NumElements, EVT, Ch, Ptr, Node->getOperand(4)); 3222ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize = NumElements * MVT::getSizeInBits(EVT)/8; 3223ab48be377298bd509427a29e174cf4e305138819Nate Begeman Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 3224ab48be377298bd509427a29e174cf4e305138819Nate Begeman getIntPtrConstant(IncrementSize)); 3225ab48be377298bd509427a29e174cf4e305138819Nate Begeman //Is this safe? declaring that the two parts of the split load 3226ab48be377298bd509427a29e174cf4e305138819Nate Begeman //are from the same instruction? 3227ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getVecLoad(NumElements, EVT, Ch, Ptr, Node->getOperand(4)); 3228ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3229ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3230ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Build a factor node to remember that this load is independent of the 3231ab48be377298bd509427a29e174cf4e305138819Nate Begeman // other one. 3232ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 3233ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi.getValue(1)); 3234ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3235ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Remember that we legalized the chain. 3236ab48be377298bd509427a29e174cf4e305138819Nate Begeman AddLegalizedOperand(Op.getValue(1), TF); 3237ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (!TLI.isLittleEndian()) 3238ab48be377298bd509427a29e174cf4e305138819Nate Begeman std::swap(Lo, Hi); 3239ab48be377298bd509427a29e174cf4e305138819Nate Begeman break; 3240ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3241ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VADD: 3242ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VSUB: 3243ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VMUL: { 3244ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElements =cast<ConstantSDNode>(Node->getOperand(2))->getValue(); 3245ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3246ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand LL, LH, RL, RH; 3247ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3248ab48be377298bd509427a29e174cf4e305138819Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3249ab48be377298bd509427a29e174cf4e305138819Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 3250ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3251ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If we only have two elements, turn into a pair of scalar loads. 3252ab48be377298bd509427a29e174cf4e305138819Nate Begeman // FIXME: handle case where a vector of two elements is fine, such as 3253ab48be377298bd509427a29e174cf4e305138819Nate Begeman // 2 x double on SSE2. 3254ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (NumElements == 2) { 3255ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned Opc = getScalarizedOpcode(Node->getOpcode(), EVT); 3256ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getNode(Opc, EVT, LL, RL); 3257ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getNode(Opc, EVT, LH, RH); 3258ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 3259ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getNode(Node->getOpcode(), MVT::Vector, LL, RL, LL.getOperand(2), 3260ab48be377298bd509427a29e174cf4e305138819Nate Begeman LL.getOperand(3)); 3261ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getNode(Node->getOpcode(), MVT::Vector, LH, RH, LH.getOperand(2), 3262ab48be377298bd509427a29e174cf4e305138819Nate Begeman LH.getOperand(3)); 3263ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3264ab48be377298bd509427a29e174cf4e305138819Nate Begeman break; 3265ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3266d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 32673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CALL: { 32683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 32693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Callee = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 32703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32713d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 32723d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 32733d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 32743d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 32753d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 32763d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 32773d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 32783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 32793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Can only expand a call once so far, not i64 -> i16!"); 32803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 32823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(3); 32833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 32843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 32853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(MVT::Other); 3286d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Chain, Callee, Ops, 3287d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 32883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = SDOperand(NC, 0); 32893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = SDOperand(NC, 1); 32903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Insert the new chain mapping. 3292e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner AddLegalizedOperand(Op.getValue(1), Hi.getValue(2)); 32933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 32943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 32953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 32963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 32973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: { // Simple logical operators -> two trivial pieces. 32983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LL, LH, RL, RH; 32993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LL, LH); 33003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RL, RH); 33013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(Node->getOpcode(), NVT, LL, RL); 33023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(Node->getOpcode(), NVT, LH, RH); 33033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 33043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 33053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SELECT: { 33063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand C, LL, LH, RL, RH; 330747e9223e06390897c3834f8c527001df392570ffChris Lattner 330847e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 330947e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 331047e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 331147e9223e06390897c3834f8c527001df392570ffChris Lattner C = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 331247e9223e06390897c3834f8c527001df392570ffChris Lattner break; 331347e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 331447e9223e06390897c3834f8c527001df392570ffChris Lattner C = PromoteOp(Node->getOperand(0)); // Promote the condition. 331547e9223e06390897c3834f8c527001df392570ffChris Lattner break; 331647e9223e06390897c3834f8c527001df392570ffChris Lattner } 33173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), LL, LH); 33183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(2), RL, RH); 33193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, C, LL, RL); 33203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, C, LH, RH); 33213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 33223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 33239373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: { 33249373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand TL, TH, FL, FH; 33259373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(2), TL, TH); 33269373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(3), FL, FH); 33279373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Lo = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 33289373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TL, FL, Node->getOperand(4)); 33299373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Hi = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 33309373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TH, FH, Node->getOperand(4)); 3331e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Lo = LegalizeOp(Lo); 3332e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Hi = LegalizeOp(Hi); 33339373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 33349373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 3335144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::SEXTLOAD: { 3336144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 3337144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 3338144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3339144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 3340144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 3341144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 3342144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 3343144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::SEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 3344144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 33459ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 33469ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 33479ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 33489ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 3349144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is obtained by SRA'ing all but one of the bits of the lo 3350144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // part. 3351144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 3352144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 3353144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman TLI.getShiftAmountTy())); 3354144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 3355144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = LegalizeOp(Hi); 3356144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 3357144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 3358144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::ZEXTLOAD: { 3359144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 3360144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 3361144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3362144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 3363144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 3364144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 3365144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 3366144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 3367144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 33689ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 33699ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 33709ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 33719ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 3372144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is just a zero. 33739ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getConstant(0, NVT)); 33749ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = LegalizeOp(Lo); 33759ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner break; 33769ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner } 33779ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner case ISD::EXTLOAD: { 33789ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); 33799ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 33809ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 33819ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 33829ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner if (EVT == NVT) 33839ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 33849ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner else 33859ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getExtLoad(ISD::EXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 33869ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner EVT); 33879ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 33889ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 33899ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 33909ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 33919ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // The high part is undefined. 33929ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getNode(ISD::UNDEF, NVT)); 3393144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 3394144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 3395144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 339613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: { 339713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner SDOperand In; 339813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 339913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 340013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 340113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Promote: 340213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner In = PromoteOp(Node->getOperand(0)); 340313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 340413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 340513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner 340613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The low part is any extension of the input (which degenerates to a copy). 340713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Lo = DAG.getNode(ISD::ANY_EXTEND, NVT, In); 340813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The high part is undefined. 340913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); 341013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 341113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 34123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: { 341306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 341406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 341506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 341606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 341706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 341806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 341906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate sign_extend_inreg to get the value we want. 342006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), In, 342115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 342206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 342306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 342406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 34253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a sign extension of the input (which degenerates to 34263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 342706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, In); 3428edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 34293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is obtained by SRA'ing all but one of the bits of the lo 34303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // part. 34312dad454af674cb41a14a85ad6ce5c85c43959acdChris Lattner unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 343227ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 343327ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner TLI.getShiftAmountTy())); 34343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 34353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 343606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case ISD::ZERO_EXTEND: { 343706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 343806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 343906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 344006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 344106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 344206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 344306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate zero_extend_inreg to get the value we want. 344423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner In = DAG.getZeroExtendInReg(In, Node->getOperand(0).getValueType()); 344506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 344606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 344706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 34483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a zero extension of the input (which degenerates to 34493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 3450dea29e25c32d2651e2efaff67bc30803ea24d991Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, In); 3451edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 34523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is just a zero. 34533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(0, NVT); 34543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 345506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 3456f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 3457308575be66ec3870d27b19df044fda18448feb41Chris Lattner case ISD::READCYCLECOUNTER: { 3458308575be66ec3870d27b19df044fda18448feb41Chris Lattner assert(TLI.getOperationAction(ISD::READCYCLECOUNTER, VT) == 3459308575be66ec3870d27b19df044fda18448feb41Chris Lattner TargetLowering::Custom && 3460308575be66ec3870d27b19df044fda18448feb41Chris Lattner "Must custom expand ReadCycleCounter"); 3461308575be66ec3870d27b19df044fda18448feb41Chris Lattner SDOperand T = TLI.LowerOperation(Op, DAG); 3462308575be66ec3870d27b19df044fda18448feb41Chris Lattner assert(T.Val && "Node must be custom expanded!"); 3463308575be66ec3870d27b19df044fda18448feb41Chris Lattner Lo = LegalizeOp(T.getValue(0)); 3464308575be66ec3870d27b19df044fda18448feb41Chris Lattner Hi = LegalizeOp(T.getValue(1)); 3465308575be66ec3870d27b19df044fda18448feb41Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), // Remember we legalized the chain. 3466308575be66ec3870d27b19df044fda18448feb41Chris Lattner LegalizeOp(T.getValue(2))); 3467f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth break; 3468308575be66ec3870d27b19df044fda18448feb41Chris Lattner } 3469f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 34704e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // These operators cannot be expanded directly, emit them as calls to 34714e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // library functions. 34724e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_SINT: 347380a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_SINT, VT) == TargetLowering::Custom) { 3474f20d183c2268553c738fefb014959ea924dd0555Chris Lattner SDOperand Op; 3475f20d183c2268553c738fefb014959ea924dd0555Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 3476f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Expand: assert(0 && "cannot expand FP!"); 3477f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Legal: Op = LegalizeOp(Node->getOperand(0)); break; 3478f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Promote: Op = PromoteOp(Node->getOperand(0)); break; 3479f20d183c2268553c738fefb014959ea924dd0555Chris Lattner } 3480d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3481f20d183c2268553c738fefb014959ea924dd0555Chris Lattner Op = TLI.LowerOperation(DAG.getNode(ISD::FP_TO_SINT, VT, Op), DAG); 3482f20d183c2268553c738fefb014959ea924dd0555Chris Lattner 348380a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 348480a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 348507dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 348607dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 348707dffd6af673c73352150583150b242a93694f00Chris Lattner break; 348807dffd6af673c73352150583150b242a93694f00Chris Lattner } 348980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3490d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 34914e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 349277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixsfdi", Node, Hi); 34934e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 349477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixdfdi", Node, Hi); 34954e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 3496d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 34974e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_UINT: 349880a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_UINT, VT) == TargetLowering::Custom) { 349980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner SDOperand Op = DAG.getNode(ISD::FP_TO_UINT, VT, 350080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner LegalizeOp(Node->getOperand(0))); 350180a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 350280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 350307dffd6af673c73352150583150b242a93694f00Chris Lattner Op = TLI.LowerOperation(Op, DAG); 350407dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 350507dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 350607dffd6af673c73352150583150b242a93694f00Chris Lattner break; 350707dffd6af673c73352150583150b242a93694f00Chris Lattner } 350880a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3509d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 35104e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 351177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunssfdi", Node, Hi); 35124e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 351377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunsdfdi", Node, Hi); 35144e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 35154e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner 3516e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SHL: 351750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 351850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SHL, VT) == TargetLowering::Custom) { 351950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SHL, VT, Node->getOperand(0), 352050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 352150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 352250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 352350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 352450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 352550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 352650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 352750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 352850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 352950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3530e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 353177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SHL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3532e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 35334759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 35344759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SHL_PARTS, use it. 3535c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SHL_PARTS, NVT)) { 35365b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SHL_PARTS, Node->getOperand(0), Node->getOperand(1), 35375b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 35384759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 35394759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 35404759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3541e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 354277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashldi3", Node, Hi); 3543e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3544e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3545e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRA: 354650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 354750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRA, VT) == TargetLowering::Custom) { 354850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRA, VT, Node->getOperand(0), 354950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 355050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 355150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 355250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 355350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 355450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 355550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 355650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 355750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 355850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3559e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 356077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRA, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3561e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 35624759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 35634759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRA_PARTS, use it. 3564c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRA_PARTS, NVT)) { 35655b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRA_PARTS, Node->getOperand(0), Node->getOperand(1), 35665b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 35674759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 35684759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 35694759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3570e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 357177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashrdi3", Node, Hi); 3572e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3573e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRL: 357450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 357550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRL, VT) == TargetLowering::Custom) { 357650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRL, VT, Node->getOperand(0), 357750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 357850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 357950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 358050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 358150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 358250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 358350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 358450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 358550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 358650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3587e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 358877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3589e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 35904759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 35914759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRL_PARTS, use it. 3592c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRL_PARTS, NVT)) { 35935b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRL_PARTS, Node->getOperand(0), Node->getOperand(1), 35945b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 35954759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 35964759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 35974759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3598e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 359977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__lshrdi3", Node, Hi); 3600e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3601e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3602edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case ISD::ADD: 36034759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::ADD_PARTS, Node->getOperand(0), Node->getOperand(1), 36044759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 360584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 360684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::SUB: 36074759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::SUB_PARTS, Node->getOperand(0), Node->getOperand(1), 36084759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 360984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 3610c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MUL: { 3611c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::MULHU, NVT)) { 3612c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman SDOperand LL, LH, RL, RH; 3613c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3614c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 361556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman unsigned SH = MVT::getSizeInBits(RH.getValueType())-1; 361656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // MULHS implicitly sign extends its inputs. Check to see if ExpandOp 361756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // extended the sign bit of the low half through the upper half, and if so 361856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // emit a MULHS instead of the alternate sequence that is valid for any 361956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // i64 x i64 multiply. 362056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman if (TLI.isOperationLegal(ISD::MULHS, NVT) && 362156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is RH an extension of the sign bit of RL? 362256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOpcode() == ISD::SRA && RH.getOperand(0) == RL && 362356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOperand(1).getOpcode() == ISD::Constant && 362456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(RH.getOperand(1))->getValue() == SH && 362556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is LH an extension of the sign bit of LL? 362656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOpcode() == ISD::SRA && LH.getOperand(0) == LL && 362756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOperand(1).getOpcode() == ISD::Constant && 362856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(LH.getOperand(1))->getValue() == SH) { 362956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHS, NVT, LL, RL); 363056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } else { 363156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 363256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 363356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 363456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 363556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 363656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } 3637c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 3638c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } else { 3639c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = ExpandLibCall("__muldi3" , Node, Hi); break; 3640c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 3641c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman break; 3642c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 364377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SDIV: Lo = ExpandLibCall("__divdi3" , Node, Hi); break; 364477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UDIV: Lo = ExpandLibCall("__udivdi3", Node, Hi); break; 364577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SREM: Lo = ExpandLibCall("__moddi3" , Node, Hi); break; 364677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UREM: Lo = ExpandLibCall("__umoddi3", Node, Hi); break; 36473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 36483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 36493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember in a map if the values will be reused later. 36506fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner bool isNew = ExpandedNodes.insert(std::make_pair(Op, 36516fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::make_pair(Lo, Hi))).second; 36526fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner assert(isNew && "Value already expanded?!?"); 36533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 36543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 36553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 36563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 36573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 36589c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnervoid SelectionDAG::Legalize() { 36593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 36603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 36619c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(*this).Run(); 36623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 36633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3664