LegalizeDAG.cpp revision 02659d23637f69f90640bfa3e66919517103c57a
13e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===-- LegalizeDAG.cpp - Implement SelectionDAG::Legalize ----------------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 33e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// The LLVM Compiler Infrastructure 43e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 53e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file was developed by the LLVM research group and is distributed under 63e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 83e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 93e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file implements the SelectionDAG::Legalize method. 113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/MachineConstantPool.h" 163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/MachineFunction.h" 1745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 1802659d23637f69f90640bfa3e66919517103c57aJim Laskey#include "llvm/Support/MathExtras.h" 193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Target/TargetLowering.h" 20e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner#include "llvm/Target/TargetData.h" 210f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner#include "llvm/Target/TargetOptions.h" 22adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Constants.h" 243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include <iostream> 2582299e70977500209c951404e354510feffb8efaChris Lattner#include <set> 263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerusing namespace llvm; 273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// SelectionDAGLegalize - This takes an arbitrary SelectionDAG as input and 303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// hacks on it until the target machine can handle it. This involves 313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating value sizes the machine cannot handle (promoting small sizes to 323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// large sizes or splitting up large values into small values) as well as 333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating operations the machine cannot handle. 343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// This code also does a small amount of optimization and recognition of idioms 363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// as part of its processing. For example, if a target does not support a 373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 'setcc' instruction efficiently, but does support 'brcc' instruction, this 383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// will attempt merge setcc and brc instructions into brcc's. 393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnernamespace { 413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerclass SelectionDAGLegalize { 423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner TargetLowering &TLI; 433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SelectionDAG &DAG; 443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizeAction - This enum indicates what action we should take for each 463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type the can occur in the program. 473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner enum LegalizeAction { 483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Legal, // The target natively supports this value type. 493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Promote, // This should be promoted to the next larger type. 503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Expand, // This integer type should be broken into smaller pieces. 513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner }; 523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ValueTypeActions - This is a bitvector that contains two bits for each 543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type, where the two bits correspond to the LegalizeAction enum. 553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// This can be queried with "getTypeAction(VT)". 563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner unsigned ValueTypeActions; 573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// NeedsAnotherIteration - This is set when we expand a large integer 593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// operation into smaller integer operations, but the smaller operations are 603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// not set. This occurs only rarely in practice, for targets that don't have 613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 32-bit or larger integer registers. 623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool NeedsAnotherIteration; 633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizedNodes - For nodes that are of legal width, and that have more 653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates what regularized operand to use. This 663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// allows us to avoid legalizing the same thing more than once. 673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, SDOperand> LegalizedNodes; 683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6903c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// PromotedNodes - For nodes that are below legal width, and that have more 7003c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// than one use, this map indicates what promoted value to use. This allows 7103c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// us to avoid promoting the same thing more than once. 7203c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::map<SDOperand, SDOperand> PromotedNodes; 7303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ExpandedNodes - For nodes that need to be expanded, and which have more 753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates which which operands are the expanded 763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// version of the input. This allows us to avoid expanding the same node 773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// more than once. 783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> > ExpandedNodes; 793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 808afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner void AddLegalizedOperand(SDOperand From, SDOperand To) { 818afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner bool isNew = LegalizedNodes.insert(std::make_pair(From, To)).second; 828afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner assert(isNew && "Got into the map somehow?"); 838afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner } 8403c8546ec57523970874917854a2fb77b1ff598eChris Lattner void AddPromotedOperand(SDOperand From, SDOperand To) { 8503c8546ec57523970874917854a2fb77b1ff598eChris Lattner bool isNew = PromotedNodes.insert(std::make_pair(From, To)).second; 8603c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isNew && "Got into the map somehow?"); 8703c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 888afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner 893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerpublic: 903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 919c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(SelectionDAG &DAG); 923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Run - While there is still lowering to do, perform a pass over the DAG. 943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Most regularization can be done in a single pass, but targets that require 953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// large values to be split into registers multiple times (e.g. i64 -> 4x 963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// i16) require iteration for these values (the first iteration will demote 973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// to i32, the second will demote to i16). 983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void Run() { 993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner do { 1003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NeedsAnotherIteration = false; 1013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeDAG(); 1023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } while (NeedsAnotherIteration); 1033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// getTypeAction - Return how we should legalize values of this type, either 1063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// it is already legal or we need to expand it into multiple registers of 1073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// smaller integer type, or we need to promote it to a larger type. 1083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeAction getTypeAction(MVT::ValueType VT) const { 1093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return (LegalizeAction)((ValueTypeActions >> (2*VT)) & 3); 1103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// isTypeLegal - Return true if this type is legal on this target. 1133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 1143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isTypeLegal(MVT::ValueType VT) const { 1153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return getTypeAction(VT) == Legal; 1163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerprivate: 1193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void LegalizeDAG(); 1203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LegalizeOp(SDOperand O); 1223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void ExpandOp(SDOperand O, SDOperand &Lo, SDOperand &Hi); 12303c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand PromoteOp(SDOperand O); 1243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandLibCall(const char *Name, SDNode *Node, 12677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi); 12777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandIntToFP(bool isSigned, MVT::ValueType DestTy, 12877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Source); 129cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 1306269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand ExpandLegalINT_TO_FP(bool isSigned, 1316269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand LegalOp, 1326269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT); 1335a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman SDOperand PromoteLegalINT_TO_FP(SDOperand LegalOp, MVT::ValueType DestVT, 1345a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned); 1351618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner SDOperand PromoteLegalFP_TO_INT(SDOperand LegalOp, MVT::ValueType DestVT, 1361618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned); 13700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 138e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner bool ExpandShift(unsigned Opc, SDOperand Op, SDOperand Amt, 139e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi); 1405b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandShiftParts(unsigned NodeOp, SDOperand Op, SDOperand Amt, 1415b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi); 1425b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 1434759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi); 144e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 145b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner void SpliceCallInto(const SDOperand &CallResult, SDNode *OutChain); 146b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 1473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 1483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 1493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner}; 1513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1549c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris LattnerSelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag) 1559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner : TLI(dag.getTargetLoweringInfo()), DAG(dag), 1569c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner ValueTypeActions(TLI.getValueTypeActions()) { 1573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::LAST_VALUETYPE <= 16 && 1583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Too many value types for ValueTypeActions to hold!"); 1593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1616269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// ExpandLegalINT_TO_FP - This function is responsible for legalizing a 1626269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// INT_TO_FP operation of the specified operand when the target requests that 163cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we expand it. At this point, we know that the result and operand types are 164cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target. 1656269ed125fc492d81dc5e3f48482816fc9d47f49Jim LaskeySDOperand SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned, 1666269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0, 1676269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT) { 1686269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (Op0.getValueType() == MVT::i32) { 1696269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // simple 32-bit [signed|unsigned] integer to float/double expansion 1706269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey 1716269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get the stack frame index of a 8 byte buffer 1726269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MachineFunction &MF = DAG.getMachineFunction(); 1736269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey int SSFI = MF.getFrameInfo()->CreateStackObject(8, 8); 1746269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get address of 8 byte buffer 1756269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 1766269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // word offset constant for Hi/Lo address computation 1776269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy()); 1786269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // set up Hi and Lo (into buffer) address based on endian 1796269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Hi, Lo; 1806269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (TLI.isLittleEndian()) { 1816269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1826269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = StackSlot; 1836269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 1846269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = StackSlot; 1856269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1866269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 1876269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if signed map to unsigned space 1886269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0Mapped; 1896269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (isSigned) { 1906269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // constant used to invert sign bit (signed to unsigned mapping) 1916269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand SignBit = DAG.getConstant(0x80000000u, MVT::i32); 1926269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = DAG.getNode(ISD::XOR, MVT::i32, Op0, SignBit); 1936269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 1946269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = Op0; 1956269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 1966269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the lo of the constructed double - based on integer input 1976269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store1 = DAG.getNode(ISD::STORE, MVT::Other, DAG.getEntryNode(), 1986269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped, Lo, DAG.getSrcValue(NULL)); 1996269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // initial hi portion of constructed double 2006269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand InitialHi = DAG.getConstant(0x43300000u, MVT::i32); 2016269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the hi of the constructed double - biased exponent 2026269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store2 = DAG.getNode(ISD::STORE, MVT::Other, Store1, 2036269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey InitialHi, Hi, DAG.getSrcValue(NULL)); 2046269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // load the constructed double 2056269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Load = DAG.getLoad(MVT::f64, Store2, StackSlot, 2066269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey DAG.getSrcValue(NULL)); 2076269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // FP constant to bias correct the final result 20802659d23637f69f90640bfa3e66919517103c57aJim Laskey SDOperand Bias = DAG.getConstantFP(isSigned ? 20902659d23637f69f90640bfa3e66919517103c57aJim Laskey BitsToDouble(0x4330000080000000ULL) 21002659d23637f69f90640bfa3e66919517103c57aJim Laskey : BitsToDouble(0x4330000000000000ULL), 2116269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::f64); 2126269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // subtract the bias 2136269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Sub = DAG.getNode(ISD::SUB, MVT::f64, Load, Bias); 2146269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // final result 2156269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Result; 2166269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // handle final rounding 2176269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (DestVT == MVT::f64) { 2186269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // do nothing 2196269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = Sub; 2206269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 2216269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if f32 then cast to f32 2226269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = DAG.getNode(ISD::FP_ROUND, MVT::f32, Sub); 2236269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2246269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey NeedsAnotherIteration = true; 2256269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey return Result; 2266269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2276269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey assert(!isSigned && "Legalize cannot Expand SINT_TO_FP for i64 yet"); 228cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Tmp1 = DAG.getNode(ISD::SINT_TO_FP, DestVT, Op0); 22900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2307cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Op0, 2317cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Op0.getValueType()), 2327cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 233cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 234cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 235cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SignSet, Four, Zero); 23600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2376269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // If the sign bit of the integer is set, the large number will be treated 2386269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // as a negative number. To counteract this, the dynamic code adds an 2396269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // offset depending on the data type. 240f4d32726e622c740b4befc803e604903eb1349dfChris Lattner uint64_t FF; 241f4d32726e622c740b4befc803e604903eb1349dfChris Lattner switch (Op0.getValueType()) { 242f4d32726e622c740b4befc803e604903eb1349dfChris Lattner default: assert(0 && "Unsupported integer type!"); 243f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i8 : FF = 0x43800000ULL; break; // 2^8 (as a float) 244f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i16: FF = 0x47800000ULL; break; // 2^16 (as a float) 245f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i32: FF = 0x4F800000ULL; break; // 2^32 (as a float) 246f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i64: FF = 0x5F800000ULL; break; // 2^64 (as a float) 247f4d32726e622c740b4befc803e604903eb1349dfChris Lattner } 248cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 249cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 25000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 251cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner MachineConstantPool *CP = DAG.getMachineFunction().getConstantPool(); 252cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand CPIdx = DAG.getConstantPool(CP->getConstantPoolIndex(FudgeFactor), 253cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner TLI.getPointerTy()); 254cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 255cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand FudgeInReg; 256cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (DestVT == MVT::f32) 257cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 258cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL)); 259cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner else { 260cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(DestVT == MVT::f64 && "Unexpected conversion"); 261cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = LegalizeOp(DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, 262cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getEntryNode(), CPIdx, 263cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL), MVT::f32)); 264cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 26500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 266cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NeedsAnotherIteration = true; 267cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner return DAG.getNode(ISD::ADD, DestVT, Tmp1, FudgeInReg); 268cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 269cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 270149c58ce0b94e64faf3c4ccdbf894061cf7d66e1Chris Lattner/// PromoteLegalINT_TO_FP - This function is responsible for legalizing a 2711618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// *INT_TO_FP operation of the specified operand when the target requests that 272cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we promote it. At this point, we know that the result and operand types are 273cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target, and that there is a legal UINT_TO_FP or SINT_TO_FP 274cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// operation that takes a larger input. 2755a8441ea3fc145393d6274156bd05c4a006099eaNate BegemanSDOperand SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDOperand LegalOp, 2765a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman MVT::ValueType DestVT, 2775a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned) { 278cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // First step, figure out the appropriate *INT_TO_FP operation to use. 279cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner MVT::ValueType NewInTy = LegalOp.getValueType(); 28000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 281cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner unsigned OpToUse = 0; 28200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 283cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Scan for the appropriate larger type to use. 284cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner while (1) { 285cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NewInTy = (MVT::ValueType)(NewInTy+1); 286cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(MVT::isInteger(NewInTy) && "Ran out of possibilities!"); 28700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 288cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports SINT_TO_FP of this type, use it. 289cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, NewInTy)) { 290cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 291cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 292cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (!TLI.hasNativeSupportFor(NewInTy)) 293cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 294cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 295cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 296cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::SINT_TO_FP; 297cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 298cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 299cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 3005a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman if (isSigned) continue; 30100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 302cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports UINT_TO_FP of this type, use it. 303cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::UINT_TO_FP, NewInTy)) { 304cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 305cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 306cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (!TLI.hasNativeSupportFor(NewInTy)) 307cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 308cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 309cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 310cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::UINT_TO_FP; 311cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 312cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 313cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 31400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 315cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Otherwise, try a larger type. 316cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 317cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 318cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Make sure to legalize any nodes we create here in the next pass. 319cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NeedsAnotherIteration = true; 32000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 321cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Okay, we found the operation and type to use. Zero extend our input to the 322cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // desired type then run the operation on it. 323cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner return DAG.getNode(OpToUse, DestVT, 3245a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, 3255a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman NewInTy, LegalOp)); 326cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 327cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 3281618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// PromoteLegalFP_TO_INT - This function is responsible for legalizing a 3291618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// FP_TO_*INT operation of the specified operand when the target requests that 3301618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// we promote it. At this point, we know that the result and operand types are 3311618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// legal for the target, and that there is a legal FP_TO_UINT or FP_TO_SINT 3321618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// operation that returns a larger result. 3331618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris LattnerSDOperand SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDOperand LegalOp, 3341618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType DestVT, 3351618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned) { 3361618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // First step, figure out the appropriate FP_TO*INT operation to use. 3371618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType NewOutTy = DestVT; 338d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3391618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner unsigned OpToUse = 0; 340d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3411618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Scan for the appropriate larger type to use. 3421618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner while (1) { 3431618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NewOutTy = (MVT::ValueType)(NewOutTy+1); 3441618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner assert(MVT::isInteger(NewOutTy) && "Ran out of possibilities!"); 345d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3461618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_SINT returning this type, use it. 3471618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_SINT, NewOutTy)) { 3481618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3491618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 3501618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (!TLI.hasNativeSupportFor(NewOutTy)) 3511618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3521618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3531618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3541618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_SINT; 3551618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3561618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3571618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 358d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3591618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_UINT of this type, use it. 3601618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_UINT, NewOutTy)) { 3611618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3621618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 3631618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (!TLI.hasNativeSupportFor(NewOutTy)) 3641618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3651618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3661618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3671618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_UINT; 3681618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3691618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3701618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 371d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3721618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Otherwise, try a larger type. 3731618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 374d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3751618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Make sure to legalize any nodes we create here in the next pass. 3761618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NeedsAnotherIteration = true; 377d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3781618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Okay, we found the operation and type to use. Truncate the result of the 3791618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // extended FP_TO_*INT operation to the desired size. 3801618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return DAG.getNode(ISD::TRUNCATE, DestVT, 3811618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner DAG.getNode(OpToUse, NewOutTy, LegalOp)); 3821618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner} 3831618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 3841618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 3853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 3863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand OldRoot = DAG.getRoot(); 3873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand NewRoot = LegalizeOp(OldRoot); 3883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner DAG.setRoot(NewRoot); 3893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandedNodes.clear(); 3913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizedNodes.clear(); 39271c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner PromotedNodes.clear(); 3933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remove dead nodes now. 39562fd269c146d9023efe32644e44cd97b88631d4fChris Lattner DAG.RemoveDeadNodes(OldRoot.Val); 3963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 3973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris LattnerSDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { 399e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner assert(getTypeAction(Op.getValueType()) == Legal && 400e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner "Caller should expand or promote operands that are not legal!"); 40145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner SDNode *Node = Op.Val; 402e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 4033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If this operation defines any values that cannot be represented in a 404e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner // register on this target, make sure to expand or promote them. 40545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Node->getNumValues() > 1) { 40645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 40745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner switch (getTypeAction(Node->getValueType(i))) { 4083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: break; // Nothing to do. 4093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 4103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand T1, T2; 4113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Op.getValue(i), T1, T2); 4123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(LegalizedNodes.count(Op) && 4133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Expansion didn't add legal operands!"); 4143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return LegalizedNodes[Op]; 4153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 41703c8546ec57523970874917854a2fb77b1ff598eChris Lattner PromoteOp(Op.getValue(i)); 41803c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(LegalizedNodes.count(Op) && 41903c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Expansion didn't add legal operands!"); 42003c8546ec57523970874917854a2fb77b1ff598eChris Lattner return LegalizedNodes[Op]; 4213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 42445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 42545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 426e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::map<SDOperand, SDOperand>::iterator I = LegalizedNodes.find(Op); 427e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (I != LegalizedNodes.end()) return I->second; 4283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4299373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand Tmp1, Tmp2, Tmp3, Tmp4; 4303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Result = Op; 4323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 4343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 435d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getOpcode() >= ISD::BUILTIN_OP_END) { 436d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // If this is a target node, legalize it by legalizing the operands then 437d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // passing it through. 438d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<SDOperand> Ops; 439d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner bool Changed = false; 440d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 441d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 442d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Changed = Changed || Node->getOperand(i) != Ops.back(); 443d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 444d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Changed) 445d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getNumValues() == 1) 446d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Ops); 447d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner else { 448d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), 449d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Node->value_end()); 450d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 451d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 452d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner 453d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 454d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner AddLegalizedOperand(Op.getValue(i), Result.getValue(i)); 455d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner return Result.getValue(Op.ResNo); 456d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 457d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // Otherwise this is an unhandled builtin node. splat. 4583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 4593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to legalize this operator!"); 4603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 4613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EntryToken: 4623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::FrameIndex: 4633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::GlobalAddress: 46403c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::ExternalSymbol: 46569a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::ConstantPool: // Nothing to do. 4663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(Node->getValueType(0)) == Legal && 4673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "This must be legal!"); 4683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 46969a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::CopyFromReg: 47069a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 47169a52155d2eff066b49dbac385113002fd9dba14Chris Lattner if (Tmp1 != Node->getOperand(0)) 472d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getCopyFromReg(Tmp1, 473d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Node->getOperand(1))->getReg(), 474d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getValueType(0)); 47513c184de29c09294ed63b01ac43e1b46c049278eChris Lattner else 47613c184de29c09294ed63b01ac43e1b46c049278eChris Lattner Result = Op.getValue(0); 47713c184de29c09294ed63b01ac43e1b46c049278eChris Lattner 47813c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // Since CopyFromReg produces two values, make sure to remember that we 47913c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // legalized both of them. 48013c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 48113c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 48213c184de29c09294ed63b01ac43e1b46c049278eChris Lattner return Result.getValue(Op.ResNo); 48318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner case ISD::ImplicitDef: 48418c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 48518c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner if (Tmp1 != Node->getOperand(0)) 486d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::ImplicitDef, MVT::Other, 487d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp1, Node->getOperand(1)); 48818c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner break; 489fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: { 490fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman MVT::ValueType VT = Op.getValueType(); 491fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman switch (TLI.getOperationAction(ISD::UNDEF, VT)) { 492ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman default: assert(0 && "This action is not supported yet!"); 493ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Expand: 494ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Promote: 495fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman if (MVT::isInteger(VT)) 496fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstant(0, VT); 497fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else if (MVT::isFloatingPoint(VT)) 498fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstantFP(0, VT); 499fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else 500fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman assert(0 && "Unknown value type!"); 501fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 502ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Legal: 503fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 504fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 505fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 506fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 5073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: 5083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // We know we don't need to expand constants here, constants only have one 5093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // value and we check that it is fine above. 5103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: Maybe we should handle things like targets that don't support full 5123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // 32-bit immediates? 5133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 5153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 5163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 5173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 5183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 5193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 5213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Check to see if this FP immediate is already legal. 5233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isLegal = false; 5243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 5253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner E = TLI.legal_fpimm_end(); I != E; ++I) 5263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (CFP->isExactlyValue(*I)) { 5273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner isLegal = true; 5283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!isLegal) { 5323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Otherwise we need to spill the constant to memory. 5333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MachineConstantPool *CP = DAG.getMachineFunction().getConstantPool(); 5343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool Extend = false; 5363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If a FP immediate is precise when represented as a float, we put it 5383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // into the constant pool as a float, even if it's is statically typed 5393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // as a double. 5403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = CFP->getValueType(0); 5413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isDouble = VT == MVT::f64; 5423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFP *LLVMC = ConstantFP::get(isDouble ? Type::DoubleTy : 5433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Type::FloatTy, CFP->getValue()); 54499939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner if (isDouble && CFP->isExactlyValue((float)CFP->getValue()) && 54599939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // Only do this if the target has a native EXTLOAD instruction from 54699939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // f32. 54799939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner TLI.getOperationAction(ISD::EXTLOAD, 54899939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner MVT::f32) == TargetLowering::Legal) { 5493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LLVMC = cast<ConstantFP>(ConstantExpr::getCast(LLVMC, Type::FloatTy)); 5503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner VT = MVT::f32; 5513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Extend = true; 5523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 553edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 5543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand CPIdx = DAG.getConstantPool(CP->getConstantPoolIndex(LLVMC), 5553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner TLI.getPointerTy()); 556f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner if (Extend) { 5575f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 5585f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 559f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } else { 56052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, 56152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 562f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } 5633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 566a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner case ISD::TokenFactor: { 567a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner std::vector<SDOperand> Ops; 568a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner bool Changed = false; 569a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 5701e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner SDOperand Op = Node->getOperand(i); 5711e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner // Fold single-use TokenFactor nodes into this token factor as we go. 572e131e5b81e5853f3c2a8c63651898ecd37eaf6f8Chris Lattner // FIXME: This is something that the DAGCombiner should do!! 5731e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner if (Op.getOpcode() == ISD::TokenFactor && Op.hasOneUse()) { 5741e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Changed = true; 5751e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner for (unsigned j = 0, e = Op.getNumOperands(); j != e; ++j) 5761e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Ops.push_back(LegalizeOp(Op.getOperand(j))); 5771e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner } else { 5781e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Ops.push_back(LegalizeOp(Op)); // Legalize the operands 5791e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Changed |= Ops[i] != Op; 5801e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner } 581a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 582a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner if (Changed) 583a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Ops); 584a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner break; 585a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 586a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner 58716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_START: 58816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 5893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 590128b52d3d75f4b74367de43e891cd98b5a9b5483Chris Lattner // Do not try to legalize the target-specific arguments (#1+) 59145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner Tmp2 = Node->getOperand(0); 59245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Tmp1 != Tmp2) { 59388de6e77bfadea8962b017f372658204ab71448cChris Lattner Node->setAdjCallChain(Tmp1); 59445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 59545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // If moving the operand from pointing to Tmp2 dropped its use count to 1, 59645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // this will cause the maps used to memoize results to get confused. 59745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Create and add a dummy use, just to increase its use count. This will 59845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // be removed at the end of legalize when dead nodes are removed. 59945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Tmp2.Val->hasOneUse()) 60045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp2, 60145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner DAG.getConstant(0, MVT::i32)); 60245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } 60316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // Note that we do not create new CALLSEQ_DOWN/UP nodes here. These 60488de6e77bfadea8962b017f372658204ab71448cChris Lattner // nodes are treated specially and are mutated in place. This makes the dag 60588de6e77bfadea8962b017f372658204ab71448cChris Lattner // legalization process more efficient and also makes libcall insertion 60688de6e77bfadea8962b017f372658204ab71448cChris Lattner // easier. 6073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 608fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner case ISD::DYNAMIC_STACKALLOC: 609fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 610fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 611fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 612fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 613adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Tmp3 != Node->getOperand(2)) { 614adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 615adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 616adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 617adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 618adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner } else 619513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner Result = Op.getValue(0); 620fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 621fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // Since this op produces two values, make sure to remember that we 622fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // legalized both of them. 623fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 624fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 625fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner return Result.getValue(Op.ResNo); 626fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 627d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 6283d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner case ISD::CALL: { 6293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 6313d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 6323d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 6333d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 6343d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 6353d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 6363d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 6373d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 6383d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 6393d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || Changed) { 6403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 6413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(Node->getNumValues()); 6423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 643ebda942efcb86634a6581aae76a0d0c92c4a232eChris Lattner RetTyVTs.push_back(Node->getValueType(i)); 644d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Result = SDOperand(DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 645d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL), 0); 64638d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner } else { 64738d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner Result = Result.getValue(0); 6483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 64938d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // Since calls produce multiple values, make sure to remember that we 65038d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // legalized all of them. 65138d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 65238d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 65338d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner return Result.getValue(Op.ResNo); 6543d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 655c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 656c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 657c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner if (Tmp1 != Node->getOperand(0)) 658c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); 659c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 660c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner 661c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 662c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 66447e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 66547e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 66647e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 66747e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 66847e9223e06390897c3834f8c527001df392570ffChris Lattner break; 66947e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 67047e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 67147e9223e06390897c3834f8c527001df392570ffChris Lattner break; 67247e9223e06390897c3834f8c527001df392570ffChris Lattner } 6737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 6747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 6757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 6767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 6777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 6787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 6797cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 6807cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 6817cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 6827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 6837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 6847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 6857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 6867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 6877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 6887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 6897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 6907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 6917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Basic block destination (Op#2) is always legal. 6927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 6937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 6947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 6957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 6967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 6977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 6987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 6997cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 7007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 7017cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (getTypeAction(Node->getOperand(2).getValueType()) == Legal) { 7027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 7037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 7047cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 7057cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 7067cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 7077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, Tmp3, Node->getOperand(4)); 7087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7107cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 7127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 7137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 7147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 7157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 7167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 7177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 7187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 7197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 7207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 7217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 7227cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 7237cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 7257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), 7267cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, DAG.getConstant(0, Tmp2.getValueType()), 7277cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 7287cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7297cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 730c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 731411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case ISD::BRCONDTWOWAY: 732411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 733411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 734411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 735411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Legal: 736411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 737411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 738411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Promote: 739411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 740411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 741411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 742411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR 743411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // pair. 744411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { 745411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Promote: 746411e888c1b4155190c8cffe388631ee20693b309Chris Lattner default: assert(0 && "This action is not supported yet!"); 747411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Legal: 748411e888c1b4155190c8cffe388631ee20693b309Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 749411e888c1b4155190c8cffe388631ee20693b309Chris Lattner std::vector<SDOperand> Ops; 750411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp1); 751411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp2); 752411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(2)); 753411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(3)); 754411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); 755411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 756411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 757411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Expand: 7587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If BRTWOWAY_CC is legal for this target, then simply expand this node 7597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // to that. Otherwise, skip BRTWOWAY_CC and expand directly to a 7607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // BRCOND/BR pair. 7617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other) == 7627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman TargetLowering::Legal) { 7637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 7647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 7657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 7667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 7677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 7697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 7707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 7717cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 774411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Node->getOperand(2)); 7757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(3)); 7767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 777411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 778411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 779411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 7807cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BRTWOWAY_CC: 7817cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 7827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (getTypeAction(Node->getOperand(2).getValueType()) == Legal) { 7837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 7847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 7857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 7867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 7877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Node->getOperand(1), Tmp2, Tmp3, 7887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 7897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 7937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 7947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 7957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 7967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If this target does not support BRTWOWAY_CC, lower it to a BRCOND/BR 7977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // pair. 7987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other)) { 7997cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 8007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 8017cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 8027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 8037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 8047cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 8057cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 8067cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 8077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 8097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8107cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 8117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 8127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 8137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 8167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 8177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 8187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(5)); 8197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8227cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: 8243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 8262d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 8273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 8283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 82952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(Node->getValueType(0), Tmp1, Tmp2, 83052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(2)); 8318afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner else 8328afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner Result = SDOperand(Node, 0); 833edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 8348afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // Since loads produce two values, make sure to remember that we legalized 8358afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // both of them. 8368afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 8378afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 8388afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner return Result.getValue(Op.ResNo); 8393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 8400f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::EXTLOAD: 8410f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::SEXTLOAD: 84201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case ISD::ZEXTLOAD: { 8430f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8440f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 8450f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 8465f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner MVT::ValueType SrcVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 84701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), SrcVT)) { 84801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner default: assert(0 && "This action is not supported yet!"); 8491c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner case TargetLowering::Promote: 8501c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); 8515f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 8525f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), MVT::i8); 8531c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // Since loads produce two values, make sure to remember that we legalized 8541c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // both of them. 8551c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 8561c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 8571c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner return Result.getValue(Op.ResNo); 858edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 85901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Legal: 86001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Tmp1 != Node->getOperand(0) || 86101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Tmp2 != Node->getOperand(1)) 8625f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 8635f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 86401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner else 86501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = SDOperand(Node, 0); 86601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner 86701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Since loads produce two values, make sure to remember that we legalized 86801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // both of them. 86901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 87001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 87101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(Op.ResNo); 87201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Expand: 8739d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth //f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 8749d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 8759d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth SDOperand Load = DAG.getLoad(SrcVT, Tmp1, Tmp2, Node->getOperand(2)); 87631559081a4285f4b7282e765aea4ec8a8e1d396cAndrew Lenharth Result = DAG.getNode(ISD::FP_EXTEND, Node->getValueType(0), Load); 8779d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (Op.ResNo) 8789d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Load.getValue(1); 8799d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Result; 8809d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 88101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(Node->getOpcode() != ISD::EXTLOAD && 88201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner "EXTLOAD should always be supported!"); 88301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 88401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // zero/sign extend inreg. 8855f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 8865f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 88723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner SDOperand ValRes; 88823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SEXTLOAD) 88923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 89015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, DAG.getValueType(SrcVT)); 89123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner else 89223993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getZeroExtendInReg(Result, SrcVT); 89301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), ValRes); 89401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 89501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Op.ResNo) 89601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(1); 89701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return ValRes; 89801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 89901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(0 && "Unreachable"); 90001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 9013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EXTRACT_ELEMENT: 9023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Get both the low and high parts. 9033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 9043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) 9053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = Tmp2; // 1 -> Hi 9063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner else 9073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = Tmp1; // 0 -> Lo 9083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 9113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 912edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 913d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(getTypeAction(Node->getOperand(2).getValueType()) == Legal && 914d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner "Register type must be legal!"); 915d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // Legalize the incoming value (must be legal). 916d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 917d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) 918d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::CopyToReg, MVT::Other, Tmp1, 919d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getOperand(1), Tmp2); 9203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 9233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 9253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 2: // ret val 9263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 9273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 9283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 9298afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 9303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 9313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 9333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 9343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 9353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Lo, Hi); 936edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 9373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 9398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 9408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 9418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 9423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 9453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 9463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); 9473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 9493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<SDOperand> NewValues; 9503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 9513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) 9523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(i).getValueType())) { 9533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 9544e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NewValues.push_back(LegalizeOp(Node->getOperand(i))); 9553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 9573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 9583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(i), Lo, Hi); 9593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Lo); 9603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Hi); 961edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 9623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 9648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Can't promote multiple return value yet!"); 9653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); 9673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::STORE: 9723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 9743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9755d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 97603c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ 9775d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner if (CFP->getValueType(0) == MVT::f32) { 9785d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner union { 9795d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner unsigned I; 9805d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner float F; 9815d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } V; 9825d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner V.F = CFP->getValue(); 98300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 9846d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getConstant(V.I, MVT::i32), Tmp2, 98552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 9865d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } else { 9875d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); 9885d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner union { 9895d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner uint64_t I; 9905d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner double F; 9915d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } V; 9925d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner V.F = CFP->getValue(); 99300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 99452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getConstant(V.I, MVT::i64), Tmp2, 99552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 9965d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 99784734ce8ef1a21eb347d4deca0bf32d59001f751Chris Lattner Node = Result.Val; 9985d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 9995d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner 10003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 10013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: { 10023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Val = LegalizeOp(Node->getOperand(1)); 10033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Val != Node->getOperand(1) || Tmp1 != Node->getOperand(0) || 10043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(2)) 100552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, 100652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 10073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 101003c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Truncate the value and store the result. 101103c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(1)); 101203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp3, Tmp2, 10132d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 10149fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getValueType(Node->getOperand(1).getValueType())); 101503c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 101603c8546ec57523970874917854a2fb77b1ff598eChris Lattner 10173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: 10183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 10193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 10203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 10213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 10223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 10233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1024edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Lo = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Lo, Tmp2, 1025edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1026ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner unsigned IncrementSize = MVT::getSizeInBits(Hi.getValueType())/8; 10273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::ADD, Tmp2.getValueType(), Tmp2, 10283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 10293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Tmp2.getValueType()) && 10303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Pointers must be legal!"); 10312d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Again, claiming both parts of the store came form the same Instr 1032edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Hi, Tmp2, 1033edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1034ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1035ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner break; 10363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 103895762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 103995762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10402c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 10412c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); 104295762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 10430f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::TRUNCSTORE: 10440f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10450f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 10460f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 10470f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 10480f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Legal: 10490f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 10500f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 10510f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 != Node->getOperand(2)) 105245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 10539fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner Node->getOperand(3), Node->getOperand(4)); 10540f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 10550f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Promote: 10560f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Expand: 10570f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(0 && "Cannot handle illegal TRUNCSTORE yet!"); 10580f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner } 10590f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 10602ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 106147e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 106247e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 106347e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 106447e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 106547e9223e06390897c3834f8c527001df392570ffChris Lattner break; 106647e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 106747e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 106847e9223e06390897c3834f8c527001df392570ffChris Lattner break; 106947e9223e06390897c3834f8c527001df392570ffChris Lattner } 10703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 10712ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 107255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 107355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Tmp2.getValueType())) { 107455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 10759373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 10769373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 10779373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1.getOperand(0), Tmp1.getOperand(1), 10789373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 10799373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 10809373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 10819373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1, 10829373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 10839373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 10849373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 10859373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 108655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 108755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 108855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 != Node->getOperand(2)) 108955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), 109055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp1, Tmp2, Tmp3); 109155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 109255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 109355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner MVT::ValueType NVT = 109455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 109555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 109655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (MVT::isInteger(Tmp2.getValueType())) { 109755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::ZERO_EXTEND; 109855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::TRUNCATE; 109955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 110055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::FP_EXTEND; 110155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::FP_ROUND; 110255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 110355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 110455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp2 = DAG.getNode(ExtOp, NVT, Tmp2); 110555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 = DAG.getNode(ExtOp, NVT, Tmp3); 110655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 110755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2,Tmp3); 110855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(TruncOp, Node->getValueType(0), Result); 110955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 111055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 111155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 11123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11139373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 11149373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 11159373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 11169373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 11179373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (getTypeAction(Node->getOperand(0).getValueType()) == Legal) { 11189373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 11199373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 11209373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 11219373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3)) { 11229373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), Tmp1, Tmp2, 11239373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3, Tmp4, Node->getOperand(4)); 11249373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 11259373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 11269373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 11279373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp1 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 11289373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(0), // LHS 11299373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), // RHS 11309373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4))); 11317cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 11327cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 11337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 11347cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 11357cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 11367cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, Tmp3.getValueType(), 11377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1.getOperand(0), Tmp1.getOperand(1), 11387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, Tmp1.getOperand(2)); 11397cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 11407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getSelectCC(Tmp1, 11417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 11427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, ISD::SETNE); 11437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 11449373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 11459373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 11463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 11473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 11483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 11493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 11503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 11513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 11527cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 11537cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 11543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 11568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // LHS 11578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // RHS 11588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 11598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // If this is an FP compare, the operands have already been extended. 11608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(Node->getOperand(0).getValueType())) { 11618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner MVT::ValueType VT = Node->getOperand(0).getValueType(); 116271c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 11638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 11648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Otherwise, we have to insert explicit sign or zero extends. Note 11658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // that we could insert sign extends for ALL conditions, but zero extend 11668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // is cheaper on many machines (an AND instead of two shifts), so prefer 11678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // it. 11687cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 11698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner default: assert(0 && "Unknown integer comparison!"); 11708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETEQ: 11718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETNE: 11728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGE: 11738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGT: 11748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULE: 11758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULT: 11768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // ALL of these operations will work if we either sign or zero extend 11778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // the operands (including the unsigned comparisons!). Zero extend is 11788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // usually a simpler/cheaper operation, so prefer it. 117923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 118023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 11818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 11828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGE: 11838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGT: 11848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLT: 11858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLE: 118615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 118715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 118815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 118915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 11908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 11918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 11928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 11938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 11947cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 11957cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 11963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1197edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case Expand: 11983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 11993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LHSLo, LHSHi); 12003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RHSLo, RHSHi); 12017cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 12023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETEQ: 12033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETNE: 120408b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSLo == RHSHi) 120508b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 120608b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSCST->isAllOnesValue()) { 120708b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner // Comparison to -1. 120808b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Tmp1 = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 12097cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, 12107cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner RHSLo, Node->getOperand(2)); 1211edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 121208b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner } 121308b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner 12143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 12153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 12163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp2); 12177cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, 12187cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Tmp1.getValueType()), 12197cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 12203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 12225b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 12235b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // X > -1, x < 0 12245b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Node->getOperand(1))) 12257cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner if ((cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETLT && 12265b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner CST->getValue() == 0) || // X < 0 12277cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner (cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETGT && 12285b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner (CST->isAllOnesValue()))) // X > -1 12297cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner return DAG.getNode(ISD::SETCC, Node->getValueType(0), LHSHi, RHSHi, 12307cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 12315b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner 12323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: This generated code sucks. 12333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ISD::CondCode LowCC; 12347cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 12353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: assert(0 && "Unknown integer setcc!"); 12363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLT: 12373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 12383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGT: 12393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 12403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLE: 12413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 12423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGE: 12433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 12443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1245edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 12463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 12473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 12483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 12493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 12513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 12527cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp1 = DAG.getSetCC(Node->getValueType(0), LHSLo, RHSLo, LowCC); 12537cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getNode(ISD::SETCC, Node->getValueType(0), LHSHi, RHSHi, 12547cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 12557cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getSetCC(Node->getValueType(0), LHSHi, RHSHi, ISD::SETEQ); 1256f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner Result = DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1257f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner Result, Tmp1, Tmp2); 12583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1263e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMSET: 1264e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMCPY: 1265e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMMOVE: { 1266deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Chain 1267e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Pointer 1268e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner 1269e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { // memset = ubyte 1270e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner switch (getTypeAction(Node->getOperand(2).getValueType())) { 1271e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand a byte!"); 1272e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1273deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 1274e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1275e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1276deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); 1277e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1278e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1279e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } else { 1280edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Tmp3 = LegalizeOp(Node->getOperand(2)); // memcpy/move = pointer, 1281e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1282272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1283272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp4; 1284272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(3).getValueType())) { 12856814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner case Expand: { 12866814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner // Length is too big, just take the lo-part of the length. 12876814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner SDOperand HiPart; 12886814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner ExpandOp(Node->getOperand(3), HiPart, Tmp4); 12896814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner break; 12906814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner } 1291e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1292e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = LegalizeOp(Node->getOperand(3)); 1293e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1294e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1295e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = PromoteOp(Node->getOperand(3)); 1296272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1297272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner } 1298272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1299272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp5; 1300272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(4).getValueType())) { // uint 1301272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 1302272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Legal: 1303272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner Tmp5 = LegalizeOp(Node->getOperand(4)); 1304272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1305272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Promote: 1306e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp5 = PromoteOp(Node->getOperand(4)); 1307e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1308e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 130955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 131055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 131155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 131255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 1313e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 1314e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || 1315e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp5 != Node->getOperand(4)) { 1316e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<SDOperand> Ops; 1317e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 1318e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 1319e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 1320e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 132155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 132255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: { 1323e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Otherwise, the target does not support this operation. Lower the 1324e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // operation to an explicit libcall as appropriate. 1325e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 1326e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner const Type *IntPtrTy = TLI.getTargetData().getIntPtrType(); 1327e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1328e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 13293bfbf4ea990930d153e58e153f319408341a94feReid Spencer const char *FnName = 0; 1330e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { 1331e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1332e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Extend the ubyte argument to be an int value for the call. 1333e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Tmp3); 1334e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, Type::IntTy)); 1335e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1336e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 1337e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = "memset"; 1338e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else if (Node->getOpcode() == ISD::MEMCPY || 1339e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Node->getOpcode() == ISD::MEMMOVE) { 1340e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1341e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, IntPtrTy)); 1342e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1343e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = Node->getOpcode() == ISD::MEMMOVE ? "memmove" : "memcpy"; 1344e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else { 1345e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner assert(0 && "Unknown op!"); 1346e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 134745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 1348e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 1349adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(Tmp1, Type::VoidTy, false, CallingConv::C, false, 1350e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner DAG.getExternalSymbol(FnName, IntPtr), Args, DAG); 1351c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner Result = CallResult.second; 1352c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner NeedsAnotherIteration = true; 135355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 135455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 135555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Custom: 135655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner std::vector<SDOperand> Ops; 135755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 135855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 135955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 136050381b6c4180e9a2b983d4623da2e485cd768632Chris Lattner Result = TLI.LowerOperation(Result, DAG); 136155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = LegalizeOp(Result); 136255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 1363e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 1364e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner break; 1365e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 136652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 136752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::READPORT: 136852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 136952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 13706d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 13713e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 13723e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 13733e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 13743e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 13753e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 13763e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 13773e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 137852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = SDOperand(Node, 0); 137952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // Since these produce two values, make sure to remember that we legalized 138052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // both of them. 138152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 138252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 138352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner return Result.getValue(Op.ResNo); 138452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::WRITEPORT: 138552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 138652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 138752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 138852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 138952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 != Node->getOperand(2)) 139052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 139152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner break; 139252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 13936d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::READIO: 13946d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 13956d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 13966d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 13976d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 13986d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 13996d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 14006d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 14013e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 14023e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 14033e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 14043e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 14053e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 14063e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 14073e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 14086d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = SDOperand(Node, 0); 14096d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14106d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 14116d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a load from memory. 14126d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0), 14136d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), DAG.getSrcValue(NULL)); 14146d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 14156d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14166d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 14176d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14186d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Since these produce two values, make sure to remember that we legalized 14196d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // both of them. 14206d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 14216d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 14226d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner return Result.getValue(Op.ResNo); 14236d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14246d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::WRITEIO: 14256d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 14266d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 14276d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 14286d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14296d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 14306d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1).getValueType())) { 14316d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 14326d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 14336d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 14346d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 14356d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 != Node->getOperand(2)) 14366d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 14376d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14386d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 14396d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a store to memory. 14406d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0), 14416d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), Node->getOperand(2), 14426d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getSrcValue(NULL)); 14436d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 14446d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14456d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 14466d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14476d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 144884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::ADD_PARTS: 14495b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SUB_PARTS: 14505b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 14515b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 14525b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 145384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 145484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 145584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 145684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 145784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 145884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 1459e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (Changed) { 1460e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 1461e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 1462e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 14632c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 14642c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 14652c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 14662c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 14672c8086f4b9916b2d02842be5e375276023225fbaChris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 14682c8086f4b9916b2d02842be5e375276023225fbaChris Lattner return Result.getValue(Op.ResNo); 146984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 14702c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 14712c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 14723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 14733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 14743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 1475c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 1476c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 14773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 14783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 14793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 14803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 14813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 148203c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 148303c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 148403c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 14853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1486f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth switch (getTypeAction(Node->getOperand(1).getValueType())) { 1487f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Expand: assert(0 && "Not possible"); 1488f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Legal: 1489f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 1490f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1491f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Promote: 1492f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the RHS. 1493f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1494f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth } 14953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 14963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 14973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 14983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1499edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1500c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 1501c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 1502c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1503c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 1504c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1505c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Legal: 1506c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman if (Tmp1 != Node->getOperand(0) || 1507c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 != Node->getOperand(1)) 1508edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 1509c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2); 1510c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1511c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Promote: 1512c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Custom: 1513c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman assert(0 && "Cannot promote/custom handle this yet!"); 15144c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner case TargetLowering::Expand: 15154c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner if (MVT::isInteger(Node->getValueType(0))) { 15164c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner MVT::ValueType VT = Node->getValueType(0); 15174c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner unsigned Opc = (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 15184c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(Opc, VT, Tmp1, Tmp2); 15194c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::MUL, VT, Result, Tmp2); 15204c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::SUB, VT, Tmp1, Result); 15214c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner } else { 15224c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner // Floating point mod -> fmod libcall. 15234c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner const char *FnName = Node->getValueType(0) == MVT::f32 ? "fmodf":"fmod"; 15244c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner SDOperand Dummy; 15254c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = ExpandLibCall(FnName, Node, Dummy); 1526c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1527c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1528c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1529c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 15302c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 1531691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1532691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1533691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1534691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 1535691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1536691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 1537691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth if (Tmp1 != Node->getOperand(0)) 1538691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1539691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1540691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 1541691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType OVT = Tmp1.getValueType(); 1542691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 1543edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 1544edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 1545691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 1546691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 1547691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1548691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch(Node->getOpcode()) 1549691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth { 1550691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1551691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 1552691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1553691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1554691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 15557cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 15567cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), 15577cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ); 155800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 1559691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(OVT),NVT), Tmp1); 1560691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1561691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1562691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 156300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 156400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 1565691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getSizeInBits(OVT), NVT)); 1566691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1567691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1568691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1569691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1570691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Custom: 1571691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth assert(0 && "Cannot custom handle this yet!"); 1572691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 1573ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth switch(Node->getOpcode()) 1574ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth { 1575ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth case ISD::CTPOP: { 1576e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner static const uint64_t mask[6] = { 1577e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 1578e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 1579e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 1580e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner }; 1581ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth MVT::ValueType VT = Tmp1.getValueType(); 1582e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner MVT::ValueType ShVT = TLI.getShiftAmountTy(); 1583e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner unsigned len = getSizeInBits(VT); 1584e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 1585ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 1586e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp2 = DAG.getConstant(mask[i], VT); 1587e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp3 = DAG.getConstant(1ULL << i, ShVT); 158800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::ADD, VT, 1589ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, Tmp1, Tmp2), 1590ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, 1591ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3), 1592ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp2)); 1593ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1594ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Result = Tmp1; 1595ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1596ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 159757ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTLZ: { 159857ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina /* for now, we do this: 15995c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 1); 16005c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 2); 16015c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner ... 16025c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>16); 160300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen x = x | (x >>32); // for 64-bit input 16045c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner return popcount(~x); 160500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 16065c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner but see also: http://www.hackersdelight.org/HDcode/nlz.cc */ 16075c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 160857ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina MVT::ValueType ShVT = TLI.getShiftAmountTy(); 160957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina unsigned len = getSizeInBits(VT); 161057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 161157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getConstant(1ULL << i, ShVT); 161200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::OR, VT, Tmp1, 161357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3)); 161457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 161557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getNode(ISD::XOR, VT, Tmp1, DAG.getConstant(~0ULL, VT)); 16165c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 161718aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 161857ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 161957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTTZ: { 162000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen // for now, we use: { return popcount(~x & (x - 1)); } 1621d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // unless the target has ctlz but not ctpop, in which case we use: 1622d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // { return 32 - nlz(~x & (x-1)); } 1623d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // see also http://www.hackersdelight.org/HDcode/ntz.cc 16245c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 16255c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp2 = DAG.getConstant(~0ULL, VT); 162600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp3 = DAG.getNode(ISD::AND, VT, 16275c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::XOR, VT, Tmp1, Tmp2), 16285c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::SUB, VT, Tmp1, 16295c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getConstant(1, VT))); 1630d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // If ISD::CTLZ is legal and CTPOP isn't, then do that instead 1631d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman if (TLI.getOperationAction(ISD::CTPOP, VT) != TargetLowering::Legal && 1632d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman TLI.getOperationAction(ISD::CTLZ, VT) == TargetLowering::Legal) { 163300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = LegalizeOp(DAG.getNode(ISD::SUB, VT, 1634d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getConstant(getSizeInBits(VT), VT), 1635d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getNode(ISD::CTLZ, VT, Tmp3))); 1636d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } else { 1637d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 1638d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } 163918aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 164057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 1641ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth default: 1642ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth assert(0 && "Cannot expand this yet!"); 1643ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1644ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1645691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1646691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1647691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 164800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 16492c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 16502c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 16512c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 1652da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 1653da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 1654da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 16552c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 16562c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 16572c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 16582c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 16592c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 16602c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 16612c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Promote: 16622c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Custom: 16632c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Cannot promote/custom handle this yet!"); 16642c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 1665f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1666f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FNEG: { 16672c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 16682c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 16692c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = LegalizeOp(DAG.getNode(ISD::SUB, Node->getValueType(0), 16702c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2, Tmp1)); 1671f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1672f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1673f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 16744af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 16754af6e0d7836126630f579b0a34f054321187f00bChris Lattner MVT::ValueType VT = Node->getValueType(0); 16764af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 16777cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, Tmp2, ISD::SETUGT); 16784af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp3 = DAG.getNode(ISD::FNEG, VT, Tmp1); 16794af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = DAG.getNode(ISD::SELECT, VT, Tmp2, Tmp1, Tmp3); 16804af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = LegalizeOp(Result); 1681f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1682f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1683f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: 1684f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: 1685f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: { 1686f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner MVT::ValueType VT = Node->getValueType(0); 1687f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner const char *FnName = 0; 1688f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1689f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: FnName = VT == MVT::f32 ? "sqrtf" : "sqrt"; break; 1690f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: FnName = VT == MVT::f32 ? "sinf" : "sin"; break; 1691f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: FnName = VT == MVT::f32 ? "cosf" : "cos"; break; 1692f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 1693f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 16942ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman SDOperand Dummy; 16952ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman Result = ExpandLibCall(FnName, Node, Dummy); 1696f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1697f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1698f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: 16994af6e0d7836126630f579b0a34f054321187f00bChris Lattner assert(0 && "Unreachable!"); 17002c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 17012c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 17022c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 17032c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 17042c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 17052c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 1706fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::SINT_TO_FP: 1707fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::UINT_TO_FP: { 1708fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP; 1709fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1710fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1711d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen switch (TLI.getOperationAction(Node->getOpcode(), 1712fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType())) { 1713fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner default: assert(0 && "Unknown operation action!"); 1714fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Expand: 17156269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = ExpandLegalINT_TO_FP(isSigned, 17166269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey LegalizeOp(Node->getOperand(0)), 17176269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Node->getValueType(0)); 1718fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 1719fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 1720fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Promote: 1721fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteLegalINT_TO_FP(LegalizeOp(Node->getOperand(0)), 1722fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), 1723fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner isSigned); 1724fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 1725fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 1726fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Legal: 1727fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1728fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1729fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 1730fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1731fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1732fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1733fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1734fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1735fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, 1736fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), Node->getOperand(0)); 1737fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1738fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1739fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (isSigned) { 1740fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1741fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 1742fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result, DAG.getValueType(Node->getOperand(0).getValueType())); 1743fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SINT_TO_FP, Op.getValueType(), Result); 1744fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } else { 1745fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1746fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getZeroExtendInReg(Result, 1747fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType()); 1748fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::UINT_TO_FP, Op.getValueType(), Result); 1749fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1750fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1751fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1752fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1753fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1754fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::TRUNCATE: 1755fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1756fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1757fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1758fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1759fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1760fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1761fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1762fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 1763fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 1764fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // Since the result is legal, we should just be able to truncate the low 1765fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // part of the source. 1766fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Tmp1); 1767fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1768fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1769fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1770fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Op.getValueType(), Result); 1771fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1772fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1773fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1774d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 1775fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_SINT: 1776fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_UINT: 1777fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1778fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1779f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1780f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner 17811618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))){ 17821618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: assert(0 && "Unknown operation action!"); 17831618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Expand: 1784d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT) { 1785d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman SDOperand True, False; 1786d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType VT = Node->getOperand(0).getValueType(); 1787d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType NVT = Node->getValueType(0); 1788d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman unsigned ShiftAmt = MVT::getSizeInBits(Node->getValueType(0))-1; 1789d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getConstantFP((double)(1ULL << ShiftAmt), VT); 1790d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp3 = DAG.getSetCC(TLI.getSetCCResultTy(), 1791d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Node->getOperand(0), Tmp2, ISD::SETLT); 1792d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman True = DAG.getNode(ISD::FP_TO_SINT, NVT, Node->getOperand(0)); 1793d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::FP_TO_SINT, NVT, 1794d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getNode(ISD::SUB, VT, Node->getOperand(0), 1795d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2)); 1796d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::XOR, NVT, False, 1797d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getConstant(1ULL << ShiftAmt, NVT)); 1798d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, NVT, Tmp3, True, False)); 17992d56e72f09337a1cab3ba199a9467c159296f3faNate Begeman return Result; 1800d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 1801d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman assert(0 && "Do not know how to expand FP_TO_SINT yet!"); 1802d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 1803d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman break; 18041618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Promote: 1805f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = PromoteLegalFP_TO_INT(Tmp1, Node->getValueType(0), 18061618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner Node->getOpcode() == ISD::FP_TO_SINT); 18071618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner AddLegalizedOperand(Op, Result); 18081618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return Result; 18091618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 18101618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 1811f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner case TargetLowering::Custom: 1812f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1813f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = TLI.LowerOperation(Result, DAG); 1814f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner AddLegalizedOperand(Op, Result); 1815f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner NeedsAnotherIteration = true; 1816f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner return Result; 18171618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 1818d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 1819fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1820fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1821fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1822fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1823fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 1824fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1825fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1826fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 1827fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1828fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1829fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1830d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 18313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 18323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 183303c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_EXTEND: 183403c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_ROUND: 18353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 18363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 18373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 18383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 18393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 18403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1841b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner case Expand: 18422c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 1843b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner 184403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Promote: 184503c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 18461713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner case ISD::ZERO_EXTEND: 18471713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 184847e9223e06390897c3834f8c527001df392570ffChris Lattner // NOTE: Any extend would work here... 184947e9223e06390897c3834f8c527001df392570ffChris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, Op.getValueType(), Result); 185023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 185123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 185203c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 185303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SIGN_EXTEND: 18541713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 185547e9223e06390897c3834f8c527001df392570ffChris Lattner // NOTE: Any extend would work here... 1856d5d56825123665b60d4eada0a4ad7d0adc5cf3a3Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, Op.getValueType(), Result); 18571713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 185815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 185915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 18601713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 186103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_EXTEND: 18621713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 18631713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner if (Result.getValueType() != Op.getValueType()) 18641713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner // Dynamically dead while we have only 2 FP types. 18651713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::FP_EXTEND, Op.getValueType(), Result); 18661713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 186703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_ROUND: 1868f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 1869f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 1870f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 187103c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 18723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 18733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 18740f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 187523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 18760f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 187715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 187845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 187945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 188045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 188155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 188255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 188355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 188455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0)) 188555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 18865f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner DAG.getValueType(ExtraVT)); 188755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 188855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 188945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 189023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 189145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 189245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 189345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned BitsDiff = MVT::getSizeInBits(Node->getValueType(0)) - 189445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::getSizeInBits(ExtraVT); 189527ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner SDOperand ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 189645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SHL, Node->getValueType(0), 189745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 189845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SRA, Node->getValueType(0), 189945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 190045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 190145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // The only way we can lower this is to turn it into a STORETRUNC, 190245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 190345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 190445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 190545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 190645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 190745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner const Type *Ty = MVT::getTypeForValueType(ExtraVT); 190845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned TySize = (unsigned)TLI.getTargetData().getTypeSize(Ty); 190945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 191045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 1911edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman int SSFI = 191245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 191345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 191445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, DAG.getEntryNode(), 191552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(0), StackSlot, 19169fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getSrcValue(NULL), DAG.getValueType(ExtraVT)); 19175f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 19185f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result, StackSlot, DAG.getSrcValue(NULL), 19195f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner ExtraVT); 192045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 192145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 192245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 192345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = LegalizeOp(Result); 192455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 192545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 19260f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 19273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 192845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 19293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 193045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 193145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 193245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 19333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 19343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 19353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 19368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// PromoteOp - Given an operation that produces a value in an invalid type, 19378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// promote it to compute the value into a larger type. The produced value will 19388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// have the correct bits for the low portion of the register, but no guarantee 19398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// is made about the top bits: it may be zero, sign-extended, or garbage. 194003c8546ec57523970874917854a2fb77b1ff598eChris LattnerSDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) { 194103c8546ec57523970874917854a2fb77b1ff598eChris Lattner MVT::ValueType VT = Op.getValueType(); 194271c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 194303c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(getTypeAction(VT) == Promote && 194403c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Caller should expand or legalize operands that are not promotable!"); 194503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(NVT > VT && MVT::isInteger(NVT) == MVT::isInteger(VT) && 194603c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Cannot promote to smaller type!"); 194703c8546ec57523970874917854a2fb77b1ff598eChris Lattner 194803c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Tmp1, Tmp2, Tmp3; 194903c8546ec57523970874917854a2fb77b1ff598eChris Lattner 195003c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Result; 195103c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDNode *Node = Op.Val; 195203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 195345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (!Node->hasOneUse()) { 195445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner std::map<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op); 195545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (I != PromotedNodes.end()) return I->second; 195645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } else { 195745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner assert(!PromotedNodes.count(Op) && "Repromoted this node??"); 195845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } 195945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 19600f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // Promotion needs an optimization step to clean up after it, and is not 19610f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // careful to avoid operations the target does not support. Make sure that 19620f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // all generated operations are legalized in the next iteration. 19630f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner NeedsAnotherIteration = true; 19640f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 196503c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 1966d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 1967d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 196803c8546ec57523970874917854a2fb77b1ff598eChris Lattner default: 196903c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 197003c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(0 && "Do not know how to promote this operator!"); 197103c8546ec57523970874917854a2fb77b1ff598eChris Lattner abort(); 1972fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 1973fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getNode(ISD::UNDEF, NVT); 1974fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 197503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::Constant: 197603c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, NVT, Op); 197703c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantSDNode>(Result) && "Didn't constant fold zext?"); 197803c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 197903c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::ConstantFP: 198003c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::FP_EXTEND, NVT, Op); 198103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantFPSDNode>(Result) && "Didn't constant fold fp_extend?"); 198203c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 1983ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner 198482fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner case ISD::SETCC: 198582fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner assert(getTypeAction(TLI.getSetCCResultTy()) == Legal && 198682fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner "SetCC type is not legal??"); 19877cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(),Node->getOperand(0), 19887cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(1), Node->getOperand(2)); 198982fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = LegalizeOp(Result); 199082fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner break; 199103c8546ec57523970874917854a2fb77b1ff598eChris Lattner 199203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 199303c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 199403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Legal: 199503c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 199603c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.getValueType() >= NVT && 199703c8546ec57523970874917854a2fb77b1ff598eChris Lattner "This truncation doesn't make sense!"); 199803c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (Result.getValueType() > NVT) // Truncate to NVT instead of VT 199903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Result); 200003c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2001e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner case Promote: 2002e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // The truncation is not required, because we don't guarantee anything 2003e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // about high bits anyway. 2004e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner Result = PromoteOp(Node->getOperand(0)); 2005e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner break; 200603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Expand: 200779e46acd35df36477029e9f534ab1a366a98df56Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 200879e46acd35df36477029e9f534ab1a366a98df56Nate Begeman // Truncate the low part of the expanded value to the result type 2009e21c305ed85b2be4a27784ba52471f6b68fdd255Chris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Tmp1); 201003c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 201103c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 20128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SIGN_EXTEND: 20138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::ZERO_EXTEND: 20148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 20158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Smaller reg should have been promoted!"); 20168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 20178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Just do extend all the way to the larger type. 20188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 20198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 20208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 20228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Promote the reg if it's smaller. 20238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 20248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The high bits are not guaranteed to be anything. Insert an extend. 20258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND) 2026595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 202715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 20288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 202923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 203023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 20318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 20338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20348b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 20358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_EXTEND: 20368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Case not implemented. Dynamically dead with 2 FP types!"); 20378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_ROUND: 20388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 20398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Cannot expand FP regs!"); 20408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: assert(0 && "Unreachable with 2 FP types!"); 20418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 20428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Do an FP_ROUND_INREG. 20438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 204415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 204515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 20468b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20478b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 20488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 20508b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SINT_TO_FP: 20518b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UINT_TO_FP: 20528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 20538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 20548b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 205577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 205677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 20578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 20598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 20608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 20618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP) 20628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 206315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 206415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 20658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 206623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 206723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 206877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 206977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 20708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 207277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, NVT, 207377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOperand(0)); 207477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // Round if we cannot tolerate excess precision. 207577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (NoExcessFPPrecision) 207615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 207715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 207877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 20798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 20808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 20828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_SINT: 20838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_UINT: 20848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 20858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 20868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 20878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 20898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input result is prerounded, so we don't have to do anything 20908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // special. 20918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 20928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 20948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "not implemented"); 20958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 2096d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // If we're promoting a UINT to a larger size, check to see if the new node 2097d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 2098d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // we can use that instead. This allows us to generate better code for 2099d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 2100d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // legal, such as PowerPC. 2101d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT && 2102d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman TargetLowering::Legal != TLI.getOperationAction(ISD::FP_TO_UINT, NVT) && 2103d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman TargetLowering::Legal == TLI.getOperationAction(ISD::FP_TO_SINT, NVT)) { 2104d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(ISD::FP_TO_SINT, NVT, Tmp1); 2105d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2106d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2107d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 21088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 21102c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 21112c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 21122c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21132c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(Tmp1.getValueType() == NVT); 21142c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 21152c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NOTE: we do not have to do any extra rounding here for 21162c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NoExcessFPPrecision, because we know the input will have the appropriate 21172c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // precision, and these operations don't modify precision at all. 21182c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 21192c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 2120da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2121da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2122da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 2123da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 2124da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner assert(Tmp1.getValueType() == NVT); 2125da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2126da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner if(NoExcessFPPrecision) 212715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 212815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 2129da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner break; 2130da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner 213103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::AND: 213203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::OR: 213303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::XOR: 21340f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::ADD: 21358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SUB: 21360f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::MUL: 21370f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // The input may have strange things in the top bits of the registers, but 21380f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // these operations don't care. They may have wierd bits going out, but 21390f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // that too is okay if they are integer operations. 21400f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21410f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 21420f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 21430f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 21440f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 21450f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // However, if this is a floating point operation, they will give excess 21460f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // precision that we may not be able to tolerate. If we DO allow excess 21470f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // precision, just leave it, otherwise excise it. 21488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // FIXME: Why would we need to round FP ops more than integer ones? 21498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Is Round(Add(Add(A,B),C)) != Round(Add(Round(Add(A,B)), C)) 21500f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 215115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 215215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 21530f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 21540f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 21558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SDIV: 21568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SREM: 21578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be sign extended. 21588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 21608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(NVT)) { 216115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 216215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 216315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 216415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 21658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 21668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 21678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 21688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 21698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 217015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 217115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 21728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 21748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UDIV: 21758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UREM: 21768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be zero extended. 21778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 21798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(MVT::isInteger(NVT) && "Operators don't apply to FP!"); 218023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 218123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 21828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 21838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 21858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SHL: 21868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 21888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SHL, NVT, Tmp1, Tmp2); 21898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRA: 21918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly sign extended. 21928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 219315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 219415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 21958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 21968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRA, NVT, Tmp1, Tmp2); 21978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRL: 21998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly zero extended. 22008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 220123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 22028b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 22038b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRL, NVT, Tmp1, Tmp2); 22048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 220503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::LOAD: 220603c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 220703c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2208232ee95a09a583b7d66b90ee7ddf7fdb9c194a04Chris Lattner // FIXME: When the DAG combiner exists, change this to use EXTLOAD! 22096841dec8c1c071b5a417fb4172633c68301be36cChris Lattner if (MVT::isInteger(NVT)) 22105f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Tmp1, Tmp2, 22115f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Node->getOperand(2), VT); 22126841dec8c1c071b5a417fb4172633c68301be36cChris Lattner else 22135f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, NVT, Tmp1, Tmp2, 22145f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Node->getOperand(2), VT); 221503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 221603c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Remember that we legalized the chain. 221703c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 221803c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 221903c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SELECT: 222047e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 222147e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 222247e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 222347e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0));// Legalize the condition. 222447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 222547e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 222647e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 222747e9223e06390897c3834f8c527001df392570ffChris Lattner break; 222847e9223e06390897c3834f8c527001df392570ffChris Lattner } 222903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Legalize the op0 223003c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); // Legalize the op1 223103c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2, Tmp3); 223203c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 22339373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 22349373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2 = PromoteOp(Node->getOperand(2)); // True 22359373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = PromoteOp(Node->getOperand(3)); // False 22369373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 22379373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), Tmp2, Tmp3, 22389373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4)); 22399373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 2240d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 22418ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner case ISD::CALL: { 22428ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 22438ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 22448ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 22453d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 22463d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) 22473d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 22483d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 22498ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 22508ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner "Can only promote single result calls"); 22518ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner std::vector<MVT::ValueType> RetTyVTs; 22528ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.reserve(2); 22538ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(NVT); 22548ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(MVT::Other); 2255d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 2256d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 22578ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Result = SDOperand(NC, 0); 22588ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 22598ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner // Insert the new chain mapping. 22608ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 22618ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner break; 2262edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 2263fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2264fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2265fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2266fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = Node->getOperand(0); 2267fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Zero extend the argument 2268fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2269fecf095292991bdf9396fec474011446107f9813Andrew Lenharth // Perform the larger operation, then subtract if needed. 2270fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2271fecf095292991bdf9396fec474011446107f9813Andrew Lenharth switch(Node->getOpcode()) 2272fecf095292991bdf9396fec474011446107f9813Andrew Lenharth { 2273fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2274fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = Tmp1; 2275fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2276fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2277fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 2278d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 22797cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), ISD::SETEQ); 228000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 2281fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(VT),NVT), Tmp1); 2282fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2283fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2284fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 228500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 228600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 2287fecf095292991bdf9396fec474011446107f9813Andrew Lenharth getSizeInBits(VT), NVT)); 2288fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2289fecf095292991bdf9396fec474011446107f9813Andrew Lenharth } 2290fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 229103c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 229203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 229303c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.Val && "Didn't set a result!"); 229403c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddPromotedOperand(Op, Result); 229503c8546ec57523970874917854a2fb77b1ff598eChris Lattner return Result; 229603c8546ec57523970874917854a2fb77b1ff598eChris Lattner} 22973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 229884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// ExpandAddSub - Find a clever way to expand this add operation into 229984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// subcomponents. 23004759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattnervoid SelectionDAGLegalize:: 23014759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris LattnerExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 23024759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi) { 230384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner // Expand the subcomponents. 230484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 230584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(LHS, LHSL, LHSH); 230684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(RHS, RHSL, RHSH); 230784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 2308bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner // FIXME: this should be moved to the dag combiner someday. 2309e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner assert(NodeOp == ISD::ADD_PARTS || NodeOp == ISD::SUB_PARTS); 2310e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (LHSL.getValueType() == MVT::i32) { 2311e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner SDOperand LowEl; 2312e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(LHSL)) 2313e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (C->getValue() == 0) 2314e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner LowEl = RHSL; 2315e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHSL)) 2316e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (C->getValue() == 0) 2317e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner LowEl = LHSL; 2318e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (LowEl.Val) { 2319e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner // Turn this into an add/sub of the high part only. 2320e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner SDOperand HiEl = 2321e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner DAG.getNode(NodeOp == ISD::ADD_PARTS ? ISD::ADD : ISD::SUB, 2322e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner LowEl.getValueType(), LHSH, RHSH); 2323e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = LowEl; 2324e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Hi = HiEl; 2325e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner return; 2326bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner } 2327e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 2328bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner 232984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 233084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSL); 233184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSH); 233284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSL); 233384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSH); 2334e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner 2335e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2336e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 233784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Hi = Lo.getValue(1); 233884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner} 233984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 23405b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattnervoid SelectionDAGLegalize::ExpandShiftParts(unsigned NodeOp, 23415b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand Op, SDOperand Amt, 23425b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi) { 23435b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner // Expand the subcomponents. 23445b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand LHSL, LHSH; 23455b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandOp(Op, LHSL, LHSH); 23465b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 23475b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner std::vector<SDOperand> Ops; 23485b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSL); 23495b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSH); 23505b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(Amt); 2351e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs; 2352e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner VTs.push_back(LHSL.getValueType()); 2353e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner VTs.push_back(LHSH.getValueType()); 2354e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner VTs.push_back(Amt.getValueType()); 2355e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 23565b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Hi = Lo.getValue(1); 23575b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner} 23585b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 23595b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 2360e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// ExpandShift - Try to find a clever way to expand this shift operation out to 2361e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// smaller elements. If we can't find a way that is more efficient than a 2362e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// libcall on this target, return false. Otherwise, return true with the 2363e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// low-parts expanded into Lo and Hi. 2364e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattnerbool SelectionDAGLegalize::ExpandShift(unsigned Opc, SDOperand Op,SDOperand Amt, 2365e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi) { 2366e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner assert((Opc == ISD::SHL || Opc == ISD::SRA || Opc == ISD::SRL) && 2367e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner "This is not a shift!"); 2368f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2369e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(Op.getValueType()); 2370f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand ShAmt = LegalizeOp(Amt); 2371f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman MVT::ValueType ShTy = ShAmt.getValueType(); 2372f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned VTBits = MVT::getSizeInBits(Op.getValueType()); 2373f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned NVTBits = MVT::getSizeInBits(NVT); 2374f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2375f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Handle the case when Amt is an immediate. Other cases are currently broken 2376f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and are disabled. 2377f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Amt.Val)) { 2378f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned Cst = CN->getValue(); 2379f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Expand the incoming operand to be shifted, so that we have its parts 2380f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand InL, InH; 2381f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman ExpandOp(Op, InL, InH); 2382f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman switch(Opc) { 2383f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SHL: 2384f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2385f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2386f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2387f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2388f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2389f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst-NVTBits,ShTy)); 2390ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2391ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = DAG.getConstant(0, NVT); 2392ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = InL; 2393f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2394f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst, ShTy)); 2395f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::OR, NVT, 2396f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(Cst, ShTy)), 2397f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(NVTBits-Cst, ShTy))); 2398f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2399f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2400f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRL: 2401f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2402f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2403f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2404f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2405f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst-NVTBits,ShTy)); 2406f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2407ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2408ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2409ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = DAG.getConstant(0, NVT); 2410f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2411f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2412f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2413f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2414f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst, ShTy)); 2415f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2416f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2417f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRA: 2418f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2419edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 2420f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2421f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2422edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Lo = DAG.getNode(ISD::SRA, NVT, InH, 2423f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(Cst-NVTBits, ShTy)); 2424edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2425f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2426ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2427ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2428edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2429ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2430f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2431f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2432f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2433f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2434f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Cst, ShTy)); 2435f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2436f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2437f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2438f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2439f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // FIXME: The following code for expanding shifts using ISD::SELECT is buggy, 2440f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // so disable it for now. Currently targets are handling this via SHL_PARTS 2441f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and friends. 2442f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return false; 2443e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2444e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we have an efficient select operation (or if the selects will all fold 2445e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // away), lower to some complex code, otherwise just emit the libcall. 2446e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getOperationAction(ISD::SELECT, NVT) != TargetLowering::Legal && 2447e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner !isa<ConstantSDNode>(Amt)) 2448e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return false; 2449e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2450e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand InL, InH; 2451e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ExpandOp(Op, InL, InH); 2452e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand NAmt = DAG.getNode(ISD::SUB, ShTy, // NAmt = 32-ShAmt 2453e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits, ShTy), ShAmt); 2454e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2455e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner // Compare the unmasked shift amount against 32. 24567cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand Cond = DAG.getSetCC(TLI.getSetCCResultTy(), ShAmt, 24577cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(NVTBits, ShTy), ISD::SETGE); 2458e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner 2459e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getShiftAmountFlavor() != TargetLowering::Mask) { 2460e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ShAmt = DAG.getNode(ISD::AND, ShTy, ShAmt, // ShAmt &= 31 2461e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2462e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner NAmt = DAG.getNode(ISD::AND, ShTy, NAmt, // NAmt &= 31 2463e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2464e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2465e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2466e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (Opc == ISD::SHL) { 2467e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << Amt) | (Lo >> NAmt) 2468e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, ShAmt), 2469e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, NAmt)); 2470e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(ISD::SHL, NVT, InL, ShAmt); // T2 = Lo << Amt&31 2471edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2472e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2473e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, DAG.getConstant(0, NVT), T2); 2474e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } else { 247577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand HiLoPart = DAG.getNode(ISD::SELECT, NVT, 24767cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getSetCC(TLI.getSetCCResultTy(), NAmt, 24777cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(32, ShTy), 24787cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ), 247977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(0, NVT), 248077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, NAmt)); 2481e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << NAmt) | (Lo >> Amt) 248277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiLoPart, 2483e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, ShAmt)); 2484e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(Opc, NVT, InH, ShAmt); // T2 = InH >> ShAmt&31 2485e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2486e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand HiPart; 248777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Opc == ISD::SRA) 248877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiPart = DAG.getNode(ISD::SRA, NVT, InH, 248977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2490e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner else 2491e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner HiPart = DAG.getConstant(0, NVT); 2492e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2493e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, HiPart, T2); 2494e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2495e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return true; 2496e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner} 249777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 24989530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindLatestCallSeqStart - Scan up the dag to find the latest (highest 24999530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqStart operation and occurs later than 25009c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// Found. 25019530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic void FindLatestCallSeqStart(SDNode *Node, SDNode *&Found) { 25029c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->getNodeDepth() <= Found->getNodeDepth()) return; 25032f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner 250416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_START, we already know this node occurs later 25059c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 250616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) { 25079c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 25089c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 25099c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 25109c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25119c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 25129c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(Node->getNumOperands() != 0 && 25139c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner "All leaves should have depth equal to the entry node!"); 25149c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = Node->getNumOperands()-1; i != e; ++i) 25159530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(i).Val, Found); 25169c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25179c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 25189530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(Node->getNumOperands()-1).Val, 25199c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found); 25209c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 25219c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25229c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25239530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindEarliestCallSeqEnd - Scan down the dag to find the earliest (lowest 25249530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqEnd operation and occurs more recent 25259c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// than Found. 252682299e70977500209c951404e354510feffb8efaChris Lattnerstatic void FindEarliestCallSeqEnd(SDNode *Node, SDNode *&Found, 252782299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> &Visited) { 252882299e70977500209c951404e354510feffb8efaChris Lattner if ((Found && Node->getNodeDepth() >= Found->getNodeDepth()) || 252982299e70977500209c951404e354510feffb8efaChris Lattner !Visited.insert(Node).second) return; 25309c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 253116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_END, we already know this node occurs earlier 25329c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 253316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) { 25349c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 25359c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 25369c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 25379c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25389c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 25399c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end(); 25409c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (UI == E) return; 25419c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (--E; UI != E; ++UI) 254282299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 25439c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25449c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 254582299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 25469c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 25479c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25489530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqEnd - Given a chained node that is part of a call sequence, 254916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_END node that terminates the call sequence. 25509530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqEnd(SDNode *Node) { 255116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 25529c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return Node; 2553f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (Node->use_empty()) 25549530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return 0; // No CallSeqEnd 25559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25569c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->hasOneUse()) // Simple case, only has one user to check. 25579530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqEnd(*Node->use_begin()); 2558edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 25599c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand TheChain(Node, Node->getNumValues()-1); 25602789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner if (TheChain.getValueType() != MVT::Other) 25612789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner TheChain = SDOperand(Node, 0); 25629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(TheChain.getValueType() == MVT::Other && "Is not a token chain!"); 2563edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2564edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman for (SDNode::use_iterator UI = Node->use_begin(), 25652f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner E = Node->use_end(); UI != E; ++UI) { 2566edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 25679c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Make sure to only follow users of our token chain. 25689c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *User = *UI; 25699c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 25709c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (User->getOperand(i) == TheChain) 2571eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner if (SDNode *Result = FindCallSeqEnd(User)) 2572eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner return Result; 25739c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 25742f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner return 0; 25759c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 25769c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25779530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqStart - Given a chained node that is part of a call sequence, 257816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_START node that initiates the call sequence. 25799530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqStart(SDNode *Node) { 25809530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(Node && "Didn't find callseq_start for a call??"); 258116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 25820d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 25830d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 25840d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner "Node doesn't have a token chain argument!"); 25859530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqStart(Node->getOperand(0).Val); 25860d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 25870d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 25880d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 25899c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// FindInputOutputChains - If we are replacing an operation with a call we need 25909c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// to find the call that occurs before and the call that occurs after it to 25910d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// properly serialize the calls in the block. The returned operand is the 25920d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// input chain value for the new call (e.g. the entry node or the previous 25930d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// call), and OutChain is set to be the chain node to update to point to the 25940d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// end of the call chain. 25959c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnerstatic SDOperand FindInputOutputChains(SDNode *OpNode, SDNode *&OutChain, 25969c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand Entry) { 25979530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqStart = Entry.Val; 25989530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqEnd = 0; 25999530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(OpNode, LatestCallSeqStart); 26009530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner //std::cerr<<"Found node: "; LatestCallSeqStart->dump(); std::cerr <<"\n"; 2601edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 260216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // It is possible that no ISD::CALLSEQ_START was found because there is no 2603c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman // previous call in the function. LatestCallStackDown may in that case be 260416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // the entry node itself. Do not attempt to find a matching CALLSEQ_END 260516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // unless LatestCallStackDown is an CALLSEQ_START. 26069530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner if (LatestCallSeqStart->getOpcode() == ISD::CALLSEQ_START) 26079530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = FindCallSeqEnd(LatestCallSeqStart); 2608c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman else 26099530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = Entry.Val; 26109530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(LatestCallSeqEnd && "NULL return from FindCallSeqEnd"); 2611edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 26120d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Finally, find the first call that this must come before, first we find the 26139530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // CallSeqEnd that ends the call. 26140d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain = 0; 261582299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> Visited; 261682299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(OpNode, OutChain, Visited); 26179c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26189530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // If we found one, translate from the adj up to the callseq_start. 26190d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain) 26209530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner OutChain = FindCallSeqStart(OutChain); 26219c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26229530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return SDOperand(LatestCallSeqEnd, 0); 26239c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 26249c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 262500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen/// SpliceCallInto - Given the result chain of a libcall (CallResult), and a 2626b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattnervoid SelectionDAGLegalize::SpliceCallInto(const SDOperand &CallResult, 2627b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SDNode *OutChain) { 26280d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Nothing to splice it into? 26290d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain == 0) return; 26300d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26310d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(OutChain->getOperand(0).getValueType() == MVT::Other); 26320d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner //OutChain->dump(); 26330d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26340d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Form a token factor node merging the old inval and the new inval. 26350d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InToken = DAG.getNode(ISD::TokenFactor, MVT::Other, CallResult, 26360d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->getOperand(0)); 26370d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Change the node to refer to the new token. 26380d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->setAdjCallChain(InToken); 26390d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 26409c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26419c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 264277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 264377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 264477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 264577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 264677e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize::ExpandLibCall(const char *Name, SDNode *Node, 264777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi) { 26489c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *OutChain; 26499c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand InChain = FindInputOutputChains(Node, OutChain, 26509c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner DAG.getEntryNode()); 2651f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (InChain.Val == 0) 2652f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner InChain = DAG.getEntryNode(); 26539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 265477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 265577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 265677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner MVT::ValueType ArgVT = Node->getOperand(i).getValueType(); 265777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(ArgVT); 265877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Node->getOperand(i), ArgTy)); 265977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 266077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(Name, TLI.getPointerTy()); 2661edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 26620d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 266377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(Node->getValueType(0)); 26640d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallInfo = 2665adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, false, 2666adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 2667b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallInfo.second, OutChain); 2668b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 2669b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner NeedsAnotherIteration = true; 26700d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26710d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner switch (getTypeAction(CallInfo.first.getValueType())) { 267277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner default: assert(0 && "Unknown thing"); 267377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Legal: 26740d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallInfo.first; 267577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Promote: 267677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(0 && "Cannot promote this yet!"); 267777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Expand: 267877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Lo; 26790d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner ExpandOp(CallInfo.first, Lo, Hi); 268077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner return Lo; 268177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 268277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 268377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 26849c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 268577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// ExpandIntToFP - Expand a [US]INT_TO_FP operation, assuming that the 268677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// destination type is legal. 268777e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize:: 268877e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) { 268977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(DestTy) == Legal && "Destination type is not legal!"); 269077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(Source.getValueType()) == Expand && 269177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner "This is not an expansion!"); 269277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(Source.getValueType() == MVT::i64 && "Only handle expand from i64!"); 269377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 26940d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (!isSigned) { 2695e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(Source.getValueType() == MVT::i64 && 2696e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner "This only works for 64-bit -> FP"); 2697e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 2698e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // incoming integer is set. To handle this, we dynamically test to see if 2699e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // it is set, and, if so, add a fudge factor. 2700e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Lo, Hi; 2701e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner ExpandOp(Source, Lo, Hi); 2702e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 270366de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 270466de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // signed, then adjust the result if the sign bit is set. 270566de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner SDOperand SignedConv = ExpandIntToFP(true, DestTy, 270666de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), Lo, Hi)); 270766de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 27087cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Hi, 27097cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Hi.getValueType()), 27107cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 2711e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 2712e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 2713e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SignSet, Four, Zero); 2714383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner uint64_t FF = 0x5f800000ULL; 2715383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 2716383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 2717e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 2718e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner MachineConstantPool *CP = DAG.getMachineFunction().getConstantPool(); 2719e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CPIdx = DAG.getConstantPool(CP->getConstantPoolIndex(FudgeFactor), 2720e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner TLI.getPointerTy()); 2721e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 2722e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand FudgeInReg; 2723e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner if (DestTy == MVT::f32) 272452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 272552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 2726e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner else { 2727e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(DestTy == MVT::f64 && "Unexpected conversion"); 27285f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 27295f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 2730e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 2731e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner return DAG.getNode(ISD::ADD, DestTy, SignedConv, FudgeInReg); 273277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 27330d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 2734a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 2735a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, Source.getValueType())) { 2736a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 2737a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Legal: 2738a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Expand: 2739a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner break; // This case is handled below. 2740a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Custom: 2741a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner Source = DAG.getNode(ISD::SINT_TO_FP, DestTy, Source); 274250381b6c4180e9a2b983d4623da2e485cd768632Chris Lattner return LegalizeOp(TLI.LowerOperation(Source, DAG)); 2743a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 2744a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 274513689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // Expand the source, then glue it back together for the call. We must expand 274613689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // the source in case it is shared (this pass of legalize must traverse it). 274713689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner SDOperand SrcLo, SrcHi; 274813689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner ExpandOp(Source, SrcLo, SrcHi); 274913689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner Source = DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), SrcLo, SrcHi); 275013689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 27510d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDNode *OutChain = 0; 27520d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InChain = FindInputOutputChains(Source.Val, OutChain, 27530d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner DAG.getEntryNode()); 27540d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner const char *FnName = 0; 27550d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (DestTy == MVT::f32) 27560d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdisf"; 27570d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner else { 27580d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(DestTy == MVT::f64 && "Unknown fp value type!"); 27590d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdidf"; 27600d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 27610d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 276277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(FnName, TLI.getPointerTy()); 276377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 276477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 276577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(Source.getValueType()); 276644d105b7faf5672a2af61a3f0fdfed0d437d5777Chris Lattner 276777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Source, ArgTy)); 276877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 276977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // We don't care about token chains for libcalls. We just use the entry 277077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // node as our input and ignore the output chain. This allows us to place 277177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // calls wherever we need them to satisfy data dependences. 277277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(DestTy); 27730d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 27740d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 2775adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, true, 2776adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 27770d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 2778b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallResult.second, OutChain); 27790d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallResult.first; 278077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 2781edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2782e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2783e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 27843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandOp - Expand the specified SDOperand into its two component pieces 27853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo&Hi. Note that the Op MUST be an expanded type. As a result of this, the 27863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// LegalizeNodes map is filled in for any results that are not expanded, the 27873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandedNodes map is filled in for any results that are expanded, and the 27883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo/Hi values are returned. 27893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){ 27903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = Op.getValueType(); 279171c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 27923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDNode *Node = Op.Val; 27933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(VT) == Expand && "Not an expanded type!"); 27943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::isInteger(VT) && "Cannot expand FP values!"); 27953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::isInteger(NVT) && NVT < VT && 27963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand to FP value or to larger int value!"); 27973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 27983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If there is more than one use of this, see if we already expanded it. 27993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // There is no use remembering values that only have a single use, as the map 28003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // entries will never be reused. 28013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!Node->hasOneUse()) { 28023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I 28033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner = ExpandedNodes.find(Op); 28043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (I != ExpandedNodes.end()) { 28053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = I->second.first; 28063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = I->second.second; 28073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return; 28083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 280945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } else { 281045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner assert(!ExpandedNodes.count(Op) && "Re-expanding a node!"); 28113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 28123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 28134e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // Expanding to multiple registers needs to perform an optimization step, and 28144e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // is not careful to avoid operations the target does not support. Make sure 28154e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // that all generated operations are legalized in the next iteration. 28164e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NeedsAnotherIteration = true; 28173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 28183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 2819d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2820d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 2821d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner default: 28223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 28233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to expand this operator!"); 28243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 2825fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2826fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Lo = DAG.getNode(ISD::UNDEF, NVT); 2827fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Hi = DAG.getNode(ISD::UNDEF, NVT); 2828fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 28293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: { 28303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner uint64_t Cst = cast<ConstantSDNode>(Node)->getValue(); 28313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getConstant(Cst, NVT); 28323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT); 28333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 28343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 28353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2836d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner case ISD::BUILD_PAIR: 2837d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // Legalize both operands. FIXME: in the future we should handle the case 2838d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // where the two elements are not legal. 2839d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 2840d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Lo = LegalizeOp(Node->getOperand(0)); 2841d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Hi = LegalizeOp(Node->getOperand(1)); 2842d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner break; 2843d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner 2844edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner case ISD::CTPOP: 2845edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 28469b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner Lo = DAG.getNode(ISD::ADD, NVT, // ctpop(HL) -> ctpop(H)+ctpop(L) 28479b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Lo), 28489b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Hi)); 2849edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getConstant(0, NVT); 2850edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner break; 2851edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 285239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTLZ: { 285339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // ctlz (HL) -> ctlz(H) != 32 ? ctlz(H) : (ctlz(L)+32) 28543becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 285539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 285639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 28577cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand TopNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), HLZ, BitsC, 28587cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 285939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LowPart = DAG.getNode(ISD::CTLZ, NVT, Lo); 286039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LowPart = DAG.getNode(ISD::ADD, NVT, LowPart, BitsC); 286139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 286239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, TopNotZero, HLZ, LowPart); 286339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 286439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 286539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 286639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 286739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTTZ: { 286839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // cttz (HL) -> cttz(L) != 32 ? cttz(L) : (cttz(H)+32) 28693becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 287039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 287139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LTZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 28727cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand BotNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), LTZ, BitsC, 28737cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 287439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HiPart = DAG.getNode(ISD::CTTZ, NVT, Hi); 287539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HiPart = DAG.getNode(ISD::ADD, NVT, HiPart, BitsC); 287639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 287739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, BotNotZero, LTZ, HiPart); 287839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 287939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 288039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 2881edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 28823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: { 28833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 28843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 28852d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Lo = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 28863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 28873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Increment the pointer to the other half. 288838d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner unsigned IncrementSize = MVT::getSizeInBits(Lo.getValueType())/8; 28893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 28903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 289100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen //Is this safe? declaring that the two parts of the split load 28922d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //are from the same instruction? 28932d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Hi = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 2894ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner 2895ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Build a factor node to remember that this load is independent of the 2896ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // other one. 2897ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 2898ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi.getValue(1)); 2899edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 29003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember that we legalized the chain. 2901ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner AddLegalizedOperand(Op.getValue(1), TF); 29023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 29033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 29043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 2906d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 29073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CALL: { 29083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 29093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Callee = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 29103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29113d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 29123d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 29133d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 29143d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 29153d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 29163d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 29173d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 29183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 29193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Can only expand a call once so far, not i64 -> i16!"); 29203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 29223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(3); 29233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 29243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 29253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(MVT::Other); 2926d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Chain, Callee, Ops, 2927d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 29283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = SDOperand(NC, 0); 29293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = SDOperand(NC, 1); 29303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Insert the new chain mapping. 2932e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner AddLegalizedOperand(Op.getValue(1), Hi.getValue(2)); 29333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 29353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 29363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 29373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: { // Simple logical operators -> two trivial pieces. 29383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LL, LH, RL, RH; 29393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LL, LH); 29403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RL, RH); 29413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(Node->getOpcode(), NVT, LL, RL); 29423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(Node->getOpcode(), NVT, LH, RH); 29433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 29453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SELECT: { 29463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand C, LL, LH, RL, RH; 294747e9223e06390897c3834f8c527001df392570ffChris Lattner 294847e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 294947e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 295047e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 295147e9223e06390897c3834f8c527001df392570ffChris Lattner C = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 295247e9223e06390897c3834f8c527001df392570ffChris Lattner break; 295347e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 295447e9223e06390897c3834f8c527001df392570ffChris Lattner C = PromoteOp(Node->getOperand(0)); // Promote the condition. 295547e9223e06390897c3834f8c527001df392570ffChris Lattner break; 295647e9223e06390897c3834f8c527001df392570ffChris Lattner } 29573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), LL, LH); 29583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(2), RL, RH); 29593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, C, LL, RL); 29603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, C, LH, RH); 29613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 29639373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: { 29649373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand TL, TH, FL, FH; 29659373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(2), TL, TH); 29669373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(3), FL, FH); 29679373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Lo = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 29689373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TL, FL, Node->getOperand(4)); 29699373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Hi = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 29709373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TH, FH, Node->getOperand(4)); 2971e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Lo = LegalizeOp(Lo); 2972e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Hi = LegalizeOp(Hi); 29739373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 29749373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 29753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: { 297606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 297706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 297806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 297906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 298006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 298106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 298206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate sign_extend_inreg to get the value we want. 298306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), In, 298415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 298506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 298606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 298706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 29883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a sign extension of the input (which degenerates to 29893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 299006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, In); 2991edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 29923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is obtained by SRA'ing all but one of the bits of the lo 29933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // part. 29942dad454af674cb41a14a85ad6ce5c85c43959acdChris Lattner unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 299527ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 299627ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner TLI.getShiftAmountTy())); 29973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 299906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case ISD::ZERO_EXTEND: { 300006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 300106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 300206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 300306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 300406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 300506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 300606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate zero_extend_inreg to get the value we want. 300723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner In = DAG.getZeroExtendInReg(In, Node->getOperand(0).getValueType()); 300806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 300906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 301006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 30113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a zero extension of the input (which degenerates to 30123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 3013dea29e25c32d2651e2efaff67bc30803ea24d991Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, In); 3014edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 30153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is just a zero. 30163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(0, NVT); 30173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 301806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 30194e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // These operators cannot be expanded directly, emit them as calls to 30204e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // library functions. 30214e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_SINT: 302280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_SINT, VT) == TargetLowering::Custom) { 3023f20d183c2268553c738fefb014959ea924dd0555Chris Lattner SDOperand Op; 3024f20d183c2268553c738fefb014959ea924dd0555Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 3025f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Expand: assert(0 && "cannot expand FP!"); 3026f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Legal: Op = LegalizeOp(Node->getOperand(0)); break; 3027f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Promote: Op = PromoteOp(Node->getOperand(0)); break; 3028f20d183c2268553c738fefb014959ea924dd0555Chris Lattner } 3029d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3030f20d183c2268553c738fefb014959ea924dd0555Chris Lattner Op = TLI.LowerOperation(DAG.getNode(ISD::FP_TO_SINT, VT, Op), DAG); 3031f20d183c2268553c738fefb014959ea924dd0555Chris Lattner 303280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 303380a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 3034f20d183c2268553c738fefb014959ea924dd0555Chris Lattner ExpandOp(Op, Lo, Hi); 303580a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner break; 303680a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3037d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 30384e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 303977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixsfdi", Node, Hi); 30404e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 304177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixdfdi", Node, Hi); 30424e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 3043d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 30444e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_UINT: 304580a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_UINT, VT) == TargetLowering::Custom) { 304680a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner SDOperand Op = DAG.getNode(ISD::FP_TO_UINT, VT, 304780a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner LegalizeOp(Node->getOperand(0))); 304880a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 304980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 305080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner ExpandOp(TLI.LowerOperation(Op, DAG), Lo, Hi); 305180a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner break; 305280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3053d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 30544e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 305577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunssfdi", Node, Hi); 30564e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 305777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunsdfdi", Node, Hi); 30584e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 30594e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner 3060e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SHL: 3061e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 306277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SHL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3063e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 30644759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 30654759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SHL_PARTS, use it. 30664759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner if (TLI.getOperationAction(ISD::SHL_PARTS, NVT) == TargetLowering::Legal) { 30675b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SHL_PARTS, Node->getOperand(0), Node->getOperand(1), 30685b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 30694759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 30704759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 30714759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3072e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 307377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashldi3", Node, Hi); 3074e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3075e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3076e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRA: 3077e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 307877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRA, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3079e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 30804759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 30814759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRA_PARTS, use it. 30824759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner if (TLI.getOperationAction(ISD::SRA_PARTS, NVT) == TargetLowering::Legal) { 30835b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRA_PARTS, Node->getOperand(0), Node->getOperand(1), 30845b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 30854759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 30864759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 30874759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3088e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 308977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashrdi3", Node, Hi); 3090e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3091e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRL: 3092e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 309377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3094e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 30954759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 30964759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRL_PARTS, use it. 30974759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner if (TLI.getOperationAction(ISD::SRL_PARTS, NVT) == TargetLowering::Legal) { 30985b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRL_PARTS, Node->getOperand(0), Node->getOperand(1), 30995b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 31004759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 31014759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 31024759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3103e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 310477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__lshrdi3", Node, Hi); 3105e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3106e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3107edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case ISD::ADD: 31084759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::ADD_PARTS, Node->getOperand(0), Node->getOperand(1), 31094759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 311084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 311184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::SUB: 31124759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::SUB_PARTS, Node->getOperand(0), Node->getOperand(1), 31134759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 311484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 3115c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MUL: { 3116c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman if (TLI.getOperationAction(ISD::MULHU, NVT) == TargetLowering::Legal) { 3117c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman SDOperand LL, LH, RL, RH; 3118c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3119c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 3120c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 3121c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 3122c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 3123c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 3124c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 3125c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 3126c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } else { 3127c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = ExpandLibCall("__muldi3" , Node, Hi); break; 3128c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 3129c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman break; 3130c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 313177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SDIV: Lo = ExpandLibCall("__divdi3" , Node, Hi); break; 313277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UDIV: Lo = ExpandLibCall("__udivdi3", Node, Hi); break; 313377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SREM: Lo = ExpandLibCall("__moddi3" , Node, Hi); break; 313477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UREM: Lo = ExpandLibCall("__umoddi3", Node, Hi); break; 31353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 31363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 31373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember in a map if the values will be reused later. 31383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!Node->hasOneUse()) { 31393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isNew = ExpandedNodes.insert(std::make_pair(Op, 31403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::make_pair(Lo, Hi))).second; 31413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isNew && "Value already expanded?!?"); 31423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 31433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 31443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 31453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 31463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 31473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 31489c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnervoid SelectionDAG::Legalize() { 31493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 31503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 31519c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(*this).Run(); 31523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 31533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3154