LegalizeDAG.cpp revision 08951a32fbc1de3ec3746e14109a74ca506ca251
13e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===-- LegalizeDAG.cpp - Implement SelectionDAG::Legalize ----------------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 33e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// The LLVM Compiler Infrastructure 43e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 53e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file was developed by the LLVM research group and is distributed under 63e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 83e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 93e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file implements the SelectionDAG::Legalize method. 113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/MachineFunction.h" 1645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 1702659d23637f69f90640bfa3e66919517103c57aJim Laskey#include "llvm/Support/MathExtras.h" 183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Target/TargetLowering.h" 19e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner#include "llvm/Target/TargetData.h" 200f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner#include "llvm/Target/TargetOptions.h" 21adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Constants.h" 233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include <iostream> 2482299e70977500209c951404e354510feffb8efaChris Lattner#include <set> 253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerusing namespace llvm; 263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// SelectionDAGLegalize - This takes an arbitrary SelectionDAG as input and 293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// hacks on it until the target machine can handle it. This involves 303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating value sizes the machine cannot handle (promoting small sizes to 313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// large sizes or splitting up large values into small values) as well as 323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating operations the machine cannot handle. 333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// This code also does a small amount of optimization and recognition of idioms 353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// as part of its processing. For example, if a target does not support a 363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 'setcc' instruction efficiently, but does support 'brcc' instruction, this 373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// will attempt merge setcc and brc instructions into brcc's. 383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnernamespace { 403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerclass SelectionDAGLegalize { 413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner TargetLowering &TLI; 423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SelectionDAG &DAG; 433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizeAction - This enum indicates what action we should take for each 453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type the can occur in the program. 463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner enum LegalizeAction { 473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Legal, // The target natively supports this value type. 483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Promote, // This should be promoted to the next larger type. 493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Expand, // This integer type should be broken into smaller pieces. 503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner }; 513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ValueTypeActions - This is a bitvector that contains two bits for each 533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type, where the two bits correspond to the LegalizeAction enum. 543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// This can be queried with "getTypeAction(VT)". 553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner unsigned ValueTypeActions; 563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// NeedsAnotherIteration - This is set when we expand a large integer 583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// operation into smaller integer operations, but the smaller operations are 593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// not set. This occurs only rarely in practice, for targets that don't have 603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 32-bit or larger integer registers. 613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool NeedsAnotherIteration; 623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizedNodes - For nodes that are of legal width, and that have more 643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates what regularized operand to use. This 653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// allows us to avoid legalizing the same thing more than once. 663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, SDOperand> LegalizedNodes; 673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6803c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// PromotedNodes - For nodes that are below legal width, and that have more 6903c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// than one use, this map indicates what promoted value to use. This allows 7003c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// us to avoid promoting the same thing more than once. 7103c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::map<SDOperand, SDOperand> PromotedNodes; 7203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ExpandedNodes - For nodes that need to be expanded, and which have more 743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates which which operands are the expanded 753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// version of the input. This allows us to avoid expanding the same node 763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// more than once. 773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> > ExpandedNodes; 783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 798afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner void AddLegalizedOperand(SDOperand From, SDOperand To) { 808afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner bool isNew = LegalizedNodes.insert(std::make_pair(From, To)).second; 818afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner assert(isNew && "Got into the map somehow?"); 828afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner } 8303c8546ec57523970874917854a2fb77b1ff598eChris Lattner void AddPromotedOperand(SDOperand From, SDOperand To) { 8403c8546ec57523970874917854a2fb77b1ff598eChris Lattner bool isNew = PromotedNodes.insert(std::make_pair(From, To)).second; 8503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isNew && "Got into the map somehow?"); 8603c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 878afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner 883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerpublic: 893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 909c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(SelectionDAG &DAG); 913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Run - While there is still lowering to do, perform a pass over the DAG. 933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Most regularization can be done in a single pass, but targets that require 943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// large values to be split into registers multiple times (e.g. i64 -> 4x 953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// i16) require iteration for these values (the first iteration will demote 963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// to i32, the second will demote to i16). 973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void Run() { 983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner do { 993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NeedsAnotherIteration = false; 1003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeDAG(); 1013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } while (NeedsAnotherIteration); 1023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// getTypeAction - Return how we should legalize values of this type, either 1053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// it is already legal or we need to expand it into multiple registers of 1063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// smaller integer type, or we need to promote it to a larger type. 1073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeAction getTypeAction(MVT::ValueType VT) const { 1083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return (LegalizeAction)((ValueTypeActions >> (2*VT)) & 3); 1093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// isTypeLegal - Return true if this type is legal on this target. 1123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 1133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isTypeLegal(MVT::ValueType VT) const { 1143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return getTypeAction(VT) == Legal; 1153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerprivate: 1183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void LegalizeDAG(); 1193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LegalizeOp(SDOperand O); 1213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void ExpandOp(SDOperand O, SDOperand &Lo, SDOperand &Hi); 12203c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand PromoteOp(SDOperand O); 1233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandLibCall(const char *Name, SDNode *Node, 12577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi); 12677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandIntToFP(bool isSigned, MVT::ValueType DestTy, 12777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Source); 128cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 1296269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand ExpandLegalINT_TO_FP(bool isSigned, 1306269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand LegalOp, 1316269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT); 1325a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman SDOperand PromoteLegalINT_TO_FP(SDOperand LegalOp, MVT::ValueType DestVT, 1335a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned); 1341618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner SDOperand PromoteLegalFP_TO_INT(SDOperand LegalOp, MVT::ValueType DestVT, 1351618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned); 13600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 137e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner bool ExpandShift(unsigned Opc, SDOperand Op, SDOperand Amt, 138e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi); 1395b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandShiftParts(unsigned NodeOp, SDOperand Op, SDOperand Amt, 1405b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi); 1415b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 1424759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi); 143e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 144b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner void SpliceCallInto(const SDOperand &CallResult, SDNode *OutChain); 145b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 1463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 1473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 1483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner}; 1503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris LattnerSelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag) 1549c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner : TLI(dag.getTargetLoweringInfo()), DAG(dag), 1559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner ValueTypeActions(TLI.getValueTypeActions()) { 1563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::LAST_VALUETYPE <= 16 && 1573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Too many value types for ValueTypeActions to hold!"); 1583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1606269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// ExpandLegalINT_TO_FP - This function is responsible for legalizing a 1616269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// INT_TO_FP operation of the specified operand when the target requests that 162cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we expand it. At this point, we know that the result and operand types are 163cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target. 1646269ed125fc492d81dc5e3f48482816fc9d47f49Jim LaskeySDOperand SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned, 1656269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0, 1666269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT) { 1676269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (Op0.getValueType() == MVT::i32) { 1686269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // simple 32-bit [signed|unsigned] integer to float/double expansion 1696269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey 1706269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get the stack frame index of a 8 byte buffer 1716269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MachineFunction &MF = DAG.getMachineFunction(); 1726269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey int SSFI = MF.getFrameInfo()->CreateStackObject(8, 8); 1736269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get address of 8 byte buffer 1746269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 1756269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // word offset constant for Hi/Lo address computation 1766269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy()); 1776269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // set up Hi and Lo (into buffer) address based on endian 1786269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Hi, Lo; 1796269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (TLI.isLittleEndian()) { 1806269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1816269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = StackSlot; 1826269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 1836269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = StackSlot; 1846269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1856269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 1866269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if signed map to unsigned space 1876269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0Mapped; 1886269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (isSigned) { 1896269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // constant used to invert sign bit (signed to unsigned mapping) 1906269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand SignBit = DAG.getConstant(0x80000000u, MVT::i32); 1916269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = DAG.getNode(ISD::XOR, MVT::i32, Op0, SignBit); 1926269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 1936269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = Op0; 1946269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 1956269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the lo of the constructed double - based on integer input 1966269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store1 = DAG.getNode(ISD::STORE, MVT::Other, DAG.getEntryNode(), 1976269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped, Lo, DAG.getSrcValue(NULL)); 1986269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // initial hi portion of constructed double 1996269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand InitialHi = DAG.getConstant(0x43300000u, MVT::i32); 2006269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the hi of the constructed double - biased exponent 2016269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store2 = DAG.getNode(ISD::STORE, MVT::Other, Store1, 2026269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey InitialHi, Hi, DAG.getSrcValue(NULL)); 2036269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // load the constructed double 2046269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Load = DAG.getLoad(MVT::f64, Store2, StackSlot, 2056269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey DAG.getSrcValue(NULL)); 2066269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // FP constant to bias correct the final result 20702659d23637f69f90640bfa3e66919517103c57aJim Laskey SDOperand Bias = DAG.getConstantFP(isSigned ? 20802659d23637f69f90640bfa3e66919517103c57aJim Laskey BitsToDouble(0x4330000080000000ULL) 20902659d23637f69f90640bfa3e66919517103c57aJim Laskey : BitsToDouble(0x4330000000000000ULL), 2106269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::f64); 2116269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // subtract the bias 2126269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Sub = DAG.getNode(ISD::SUB, MVT::f64, Load, Bias); 2136269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // final result 2146269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Result; 2156269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // handle final rounding 2166269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (DestVT == MVT::f64) { 2176269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // do nothing 2186269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = Sub; 2196269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 2206269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if f32 then cast to f32 2216269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = DAG.getNode(ISD::FP_ROUND, MVT::f32, Sub); 2226269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2236269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey NeedsAnotherIteration = true; 2246269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey return Result; 2256269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2266269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey assert(!isSigned && "Legalize cannot Expand SINT_TO_FP for i64 yet"); 227cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Tmp1 = DAG.getNode(ISD::SINT_TO_FP, DestVT, Op0); 22800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2297cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Op0, 2307cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Op0.getValueType()), 2317cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 232cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 233cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 234cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SignSet, Four, Zero); 23500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2366269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // If the sign bit of the integer is set, the large number will be treated 2376269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // as a negative number. To counteract this, the dynamic code adds an 2386269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // offset depending on the data type. 239f4d32726e622c740b4befc803e604903eb1349dfChris Lattner uint64_t FF; 240f4d32726e622c740b4befc803e604903eb1349dfChris Lattner switch (Op0.getValueType()) { 241f4d32726e622c740b4befc803e604903eb1349dfChris Lattner default: assert(0 && "Unsupported integer type!"); 242f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i8 : FF = 0x43800000ULL; break; // 2^8 (as a float) 243f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i16: FF = 0x47800000ULL; break; // 2^16 (as a float) 244f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i32: FF = 0x4F800000ULL; break; // 2^32 (as a float) 245f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i64: FF = 0x5F800000ULL; break; // 2^64 (as a float) 246f4d32726e622c740b4befc803e604903eb1349dfChris Lattner } 247cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 248cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 24900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2505839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 251cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 252cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand FudgeInReg; 253cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (DestVT == MVT::f32) 254cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 255cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL)); 256cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner else { 257cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(DestVT == MVT::f64 && "Unexpected conversion"); 258cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = LegalizeOp(DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, 259cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getEntryNode(), CPIdx, 260cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL), MVT::f32)); 261cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 26200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 263cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NeedsAnotherIteration = true; 264cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner return DAG.getNode(ISD::ADD, DestVT, Tmp1, FudgeInReg); 265cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 266cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 267149c58ce0b94e64faf3c4ccdbf894061cf7d66e1Chris Lattner/// PromoteLegalINT_TO_FP - This function is responsible for legalizing a 2681618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// *INT_TO_FP operation of the specified operand when the target requests that 269cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we promote it. At this point, we know that the result and operand types are 270cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target, and that there is a legal UINT_TO_FP or SINT_TO_FP 271cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// operation that takes a larger input. 2725a8441ea3fc145393d6274156bd05c4a006099eaNate BegemanSDOperand SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDOperand LegalOp, 2735a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman MVT::ValueType DestVT, 2745a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned) { 275cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // First step, figure out the appropriate *INT_TO_FP operation to use. 276cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner MVT::ValueType NewInTy = LegalOp.getValueType(); 27700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 278cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner unsigned OpToUse = 0; 27900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 280cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Scan for the appropriate larger type to use. 281cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner while (1) { 282cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NewInTy = (MVT::ValueType)(NewInTy+1); 283cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(MVT::isInteger(NewInTy) && "Ran out of possibilities!"); 28400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 285cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports SINT_TO_FP of this type, use it. 286cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, NewInTy)) { 287cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 288cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 289c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewInTy)) 290cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 291cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 292cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 293cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::SINT_TO_FP; 294cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 295cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 296cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 2975a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman if (isSigned) continue; 29800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 299cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports UINT_TO_FP of this type, use it. 300cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::UINT_TO_FP, NewInTy)) { 301cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 302cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 303c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewInTy)) 304cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 305cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 306cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 307cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::UINT_TO_FP; 308cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 309cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 310cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 31100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 312cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Otherwise, try a larger type. 313cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 314cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 315cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Make sure to legalize any nodes we create here in the next pass. 316cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NeedsAnotherIteration = true; 31700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 318cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Okay, we found the operation and type to use. Zero extend our input to the 319cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // desired type then run the operation on it. 320cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner return DAG.getNode(OpToUse, DestVT, 3215a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, 3225a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman NewInTy, LegalOp)); 323cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 324cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 3251618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// PromoteLegalFP_TO_INT - This function is responsible for legalizing a 3261618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// FP_TO_*INT operation of the specified operand when the target requests that 3271618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// we promote it. At this point, we know that the result and operand types are 3281618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// legal for the target, and that there is a legal FP_TO_UINT or FP_TO_SINT 3291618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// operation that returns a larger result. 3301618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris LattnerSDOperand SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDOperand LegalOp, 3311618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType DestVT, 3321618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned) { 3331618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // First step, figure out the appropriate FP_TO*INT operation to use. 3341618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType NewOutTy = DestVT; 335d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3361618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner unsigned OpToUse = 0; 337d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3381618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Scan for the appropriate larger type to use. 3391618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner while (1) { 3401618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NewOutTy = (MVT::ValueType)(NewOutTy+1); 3411618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner assert(MVT::isInteger(NewOutTy) && "Ran out of possibilities!"); 342d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3431618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_SINT returning this type, use it. 3441618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_SINT, NewOutTy)) { 3451618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3461618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 347c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewOutTy)) 3481618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3491618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3501618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3511618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_SINT; 3521618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3531618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3541618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 355d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3561618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_UINT of this type, use it. 3571618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_UINT, NewOutTy)) { 3581618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3591618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 360c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewOutTy)) 3611618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3621618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3631618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3641618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_UINT; 3651618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3661618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3671618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 368d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3691618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Otherwise, try a larger type. 3701618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 371d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3721618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Make sure to legalize any nodes we create here in the next pass. 3731618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NeedsAnotherIteration = true; 374d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3751618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Okay, we found the operation and type to use. Truncate the result of the 3761618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // extended FP_TO_*INT operation to the desired size. 3771618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return DAG.getNode(ISD::TRUNCATE, DestVT, 3781618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner DAG.getNode(OpToUse, NewOutTy, LegalOp)); 3791618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner} 3801618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 3811618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 3823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 3833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand OldRoot = DAG.getRoot(); 3843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand NewRoot = LegalizeOp(OldRoot); 3853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner DAG.setRoot(NewRoot); 3863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandedNodes.clear(); 3883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizedNodes.clear(); 38971c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner PromotedNodes.clear(); 3903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remove dead nodes now. 39262fd269c146d9023efe32644e44cd97b88631d4fChris Lattner DAG.RemoveDeadNodes(OldRoot.Val); 3933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 3943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris LattnerSDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { 396c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Op.getValueType()) && 397e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner "Caller should expand or promote operands that are not legal!"); 39845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner SDNode *Node = Op.Val; 399e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 4003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If this operation defines any values that cannot be represented in a 401e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner // register on this target, make sure to expand or promote them. 40245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Node->getNumValues() > 1) { 40345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 40445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner switch (getTypeAction(Node->getValueType(i))) { 4053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: break; // Nothing to do. 4063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 4073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand T1, T2; 4083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Op.getValue(i), T1, T2); 4093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(LegalizedNodes.count(Op) && 4103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Expansion didn't add legal operands!"); 4113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return LegalizedNodes[Op]; 4123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 41403c8546ec57523970874917854a2fb77b1ff598eChris Lattner PromoteOp(Op.getValue(i)); 41503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(LegalizedNodes.count(Op) && 41603c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Expansion didn't add legal operands!"); 41703c8546ec57523970874917854a2fb77b1ff598eChris Lattner return LegalizedNodes[Op]; 4183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 42145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 42245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 423e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::map<SDOperand, SDOperand>::iterator I = LegalizedNodes.find(Op); 424e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (I != LegalizedNodes.end()) return I->second; 4253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4269373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand Tmp1, Tmp2, Tmp3, Tmp4; 4273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Result = Op; 4293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 4313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 432d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getOpcode() >= ISD::BUILTIN_OP_END) { 433d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // If this is a target node, legalize it by legalizing the operands then 434d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // passing it through. 435d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<SDOperand> Ops; 436d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner bool Changed = false; 437d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 438d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 439d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Changed = Changed || Node->getOperand(i) != Ops.back(); 440d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 441d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Changed) 442d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getNumValues() == 1) 443d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Ops); 444d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner else { 445d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), 446d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Node->value_end()); 447d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 448d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 449d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner 450d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 451d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner AddLegalizedOperand(Op.getValue(i), Result.getValue(i)); 452d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner return Result.getValue(Op.ResNo); 453d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 454d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // Otherwise this is an unhandled builtin node. splat. 4553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 4563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to legalize this operator!"); 4573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 4583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EntryToken: 4593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::FrameIndex: 4603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::GlobalAddress: 46103c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::ExternalSymbol: 46269a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::ConstantPool: // Nothing to do. 463c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getValueType(0)) && "This must be legal!"); 4643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 46508951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertSext: 46608951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertZext: 46708951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 46808951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner if (Tmp1 != Node->getOperand(0)) 46908951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 47008951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Node->getOperand(1)); 47108951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner break; 47269a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::CopyFromReg: 47369a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 47469a52155d2eff066b49dbac385113002fd9dba14Chris Lattner if (Tmp1 != Node->getOperand(0)) 475d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getCopyFromReg(Tmp1, 476d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Node->getOperand(1))->getReg(), 477d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getValueType(0)); 47813c184de29c09294ed63b01ac43e1b46c049278eChris Lattner else 47913c184de29c09294ed63b01ac43e1b46c049278eChris Lattner Result = Op.getValue(0); 48013c184de29c09294ed63b01ac43e1b46c049278eChris Lattner 48113c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // Since CopyFromReg produces two values, make sure to remember that we 48213c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // legalized both of them. 48313c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 48413c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 48513c184de29c09294ed63b01ac43e1b46c049278eChris Lattner return Result.getValue(Op.ResNo); 48618c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner case ISD::ImplicitDef: 48718c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 48818c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner if (Tmp1 != Node->getOperand(0)) 489d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::ImplicitDef, MVT::Other, 490d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp1, Node->getOperand(1)); 49118c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner break; 492fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: { 493fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman MVT::ValueType VT = Op.getValueType(); 494fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman switch (TLI.getOperationAction(ISD::UNDEF, VT)) { 495ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman default: assert(0 && "This action is not supported yet!"); 496ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Expand: 497ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Promote: 498fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman if (MVT::isInteger(VT)) 499fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstant(0, VT); 500fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else if (MVT::isFloatingPoint(VT)) 501fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstantFP(0, VT); 502fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else 503fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman assert(0 && "Unknown value type!"); 504fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 505ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Legal: 506fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 507fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 508fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 509fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 5103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: 5113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // We know we don't need to expand constants here, constants only have one 5123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // value and we check that it is fine above. 5133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: Maybe we should handle things like targets that don't support full 5153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // 32-bit immediates? 5163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 5183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 5193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 5203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 5213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 5223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 5243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Check to see if this FP immediate is already legal. 5263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isLegal = false; 5273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 5283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner E = TLI.legal_fpimm_end(); I != E; ++I) 5293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (CFP->isExactlyValue(*I)) { 5303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner isLegal = true; 5313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!isLegal) { 5353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Otherwise we need to spill the constant to memory. 5363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool Extend = false; 5373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If a FP immediate is precise when represented as a float, we put it 5393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // into the constant pool as a float, even if it's is statically typed 5403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // as a double. 5413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = CFP->getValueType(0); 5423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isDouble = VT == MVT::f64; 5433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFP *LLVMC = ConstantFP::get(isDouble ? Type::DoubleTy : 5443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Type::FloatTy, CFP->getValue()); 54599939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner if (isDouble && CFP->isExactlyValue((float)CFP->getValue()) && 54699939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // Only do this if the target has a native EXTLOAD instruction from 54799939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // f32. 548c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::EXTLOAD, MVT::f32)) { 5493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LLVMC = cast<ConstantFP>(ConstantExpr::getCast(LLVMC, Type::FloatTy)); 5503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner VT = MVT::f32; 5513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Extend = true; 5523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 553edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 5545839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy()); 555f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner if (Extend) { 5565f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 5575f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 558f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } else { 55952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, 56052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 561f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } 5623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 565a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner case ISD::TokenFactor: { 566a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner std::vector<SDOperand> Ops; 567a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner bool Changed = false; 568a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 5691e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner SDOperand Op = Node->getOperand(i); 5701e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner // Fold single-use TokenFactor nodes into this token factor as we go. 571e131e5b81e5853f3c2a8c63651898ecd37eaf6f8Chris Lattner // FIXME: This is something that the DAGCombiner should do!! 5721e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner if (Op.getOpcode() == ISD::TokenFactor && Op.hasOneUse()) { 5731e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Changed = true; 5741e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner for (unsigned j = 0, e = Op.getNumOperands(); j != e; ++j) 5751e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Ops.push_back(LegalizeOp(Op.getOperand(j))); 5761e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner } else { 5771e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Ops.push_back(LegalizeOp(Op)); // Legalize the operands 5781e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Changed |= Ops[i] != Op; 5791e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner } 580a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 581a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner if (Changed) 582a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Ops); 583a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner break; 584a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 585a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner 58616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_START: 58716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 5883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 589128b52d3d75f4b74367de43e891cd98b5a9b5483Chris Lattner // Do not try to legalize the target-specific arguments (#1+) 59045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner Tmp2 = Node->getOperand(0); 59145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Tmp1 != Tmp2) { 59288de6e77bfadea8962b017f372658204ab71448cChris Lattner Node->setAdjCallChain(Tmp1); 59345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 59445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // If moving the operand from pointing to Tmp2 dropped its use count to 1, 59545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // this will cause the maps used to memoize results to get confused. 59645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Create and add a dummy use, just to increase its use count. This will 59745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // be removed at the end of legalize when dead nodes are removed. 59845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Tmp2.Val->hasOneUse()) 59945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp2, 60045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner DAG.getConstant(0, MVT::i32)); 60145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } 60216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // Note that we do not create new CALLSEQ_DOWN/UP nodes here. These 60388de6e77bfadea8962b017f372658204ab71448cChris Lattner // nodes are treated specially and are mutated in place. This makes the dag 60488de6e77bfadea8962b017f372658204ab71448cChris Lattner // legalization process more efficient and also makes libcall insertion 60588de6e77bfadea8962b017f372658204ab71448cChris Lattner // easier. 6063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 607fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner case ISD::DYNAMIC_STACKALLOC: 608fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 609fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 610fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 611fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 612adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Tmp3 != Node->getOperand(2)) { 613adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 614adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 615adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 616adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 617adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner } else 618513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner Result = Op.getValue(0); 619fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 620fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // Since this op produces two values, make sure to remember that we 621fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // legalized both of them. 622fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 623fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 624fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner return Result.getValue(Op.ResNo); 625fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 626d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 6273d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner case ISD::CALL: { 6283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 6303d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 6313d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 6323d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 6333d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 6343d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 6353d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 6363d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 6373d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 6383d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || Changed) { 6393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 6403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(Node->getNumValues()); 6413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 642ebda942efcb86634a6581aae76a0d0c92c4a232eChris Lattner RetTyVTs.push_back(Node->getValueType(i)); 643d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Result = SDOperand(DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 644d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL), 0); 64538d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner } else { 64638d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner Result = Result.getValue(0); 6473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 64838d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // Since calls produce multiple values, make sure to remember that we 64938d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // legalized all of them. 65038d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 65138d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 65238d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner return Result.getValue(Op.ResNo); 6533d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 654c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 655c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 656c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner if (Tmp1 != Node->getOperand(0)) 657c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); 658c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 659c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner 660c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 661c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 66347e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 66447e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 66547e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 66647e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 66747e9223e06390897c3834f8c527001df392570ffChris Lattner break; 66847e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 66947e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 67047e9223e06390897c3834f8c527001df392570ffChris Lattner break; 67147e9223e06390897c3834f8c527001df392570ffChris Lattner } 6727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 6737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 6747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 6757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 6767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 6777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 6787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 6797cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 6807cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 6817cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 6827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 683550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 684550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 685550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, MVT::i1); 686550b1e59c4eb5db020766012b1406fc56833251dChris Lattner 6877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 6887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 6897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 6907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 6917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 6927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 6937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 6947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Basic block destination (Op#2) is always legal. 6957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 6967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 6977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 6987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 6997cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7017cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 7027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 7037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 704c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 7057cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 7067cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 7077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 7087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 7097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 7107cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, Tmp3, Node->getOperand(4)); 7117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 7157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 7167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 7177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 7187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 7197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 7207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 7217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 7227cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 7237cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 7247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 7257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 7267cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7277cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 7287cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), 7297cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, DAG.getConstant(0, Tmp2.getValueType()), 7307cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 7317cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7327cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 733c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 734411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case ISD::BRCONDTWOWAY: 735411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 736411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 737411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 738411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Legal: 739411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 740411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 741411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Promote: 742411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 743411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 744411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 745411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR 746411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // pair. 747411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { 748411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Promote: 749411e888c1b4155190c8cffe388631ee20693b309Chris Lattner default: assert(0 && "This action is not supported yet!"); 750411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Legal: 751411e888c1b4155190c8cffe388631ee20693b309Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 752411e888c1b4155190c8cffe388631ee20693b309Chris Lattner std::vector<SDOperand> Ops; 753411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp1); 754411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp2); 755411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(2)); 756411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(3)); 757411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); 758411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 759411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 760411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Expand: 7617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If BRTWOWAY_CC is legal for this target, then simply expand this node 7627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // to that. Otherwise, skip BRTWOWAY_CC and expand directly to a 7637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // BRCOND/BR pair. 764c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::BRTWOWAY_CC, MVT::Other)) { 7657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 7667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 7677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 7687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 7697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 7717cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 7727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 7737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 776411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Node->getOperand(2)); 7777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(3)); 7787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 779411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 780411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 781411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 7827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BRTWOWAY_CC: 7837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 784c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 7857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 7867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 7877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 7887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 7897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Node->getOperand(1), Tmp2, Tmp3, 7907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 7917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 7957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 7967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 7977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 7987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If this target does not support BRTWOWAY_CC, lower it to a BRCOND/BR 7997cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // pair. 8007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other)) { 8017cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 8027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 8037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 8047cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 8057cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 8067cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 8077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 8087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 8097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8107cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 8117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 8137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 8147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 8157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 8187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 8197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 8207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(5)); 8217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8227cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8237cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: 8263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 8282d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 8293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 8303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 83152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(Node->getValueType(0), Tmp1, Tmp2, 83252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(2)); 8338afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner else 8348afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner Result = SDOperand(Node, 0); 835edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 8368afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // Since loads produce two values, make sure to remember that we legalized 8378afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // both of them. 8388afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 8398afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 8408afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner return Result.getValue(Op.ResNo); 8413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 8420f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::EXTLOAD: 8430f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::SEXTLOAD: 84401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case ISD::ZEXTLOAD: { 8450f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8460f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 8470f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 8485f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner MVT::ValueType SrcVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 84901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), SrcVT)) { 85001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner default: assert(0 && "This action is not supported yet!"); 8511c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner case TargetLowering::Promote: 8521c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); 8535f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 8545f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), MVT::i8); 8551c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // Since loads produce two values, make sure to remember that we legalized 8561c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // both of them. 8571c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 8581c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 8591c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner return Result.getValue(Op.ResNo); 860edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 86101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Legal: 86201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Tmp1 != Node->getOperand(0) || 86301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Tmp2 != Node->getOperand(1)) 8645f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 8655f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 86601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner else 86701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = SDOperand(Node, 0); 86801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner 86901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Since loads produce two values, make sure to remember that we legalized 87001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // both of them. 87101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 87201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 87301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(Op.ResNo); 87401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Expand: 8759d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth //f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 8769d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 8779d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth SDOperand Load = DAG.getLoad(SrcVT, Tmp1, Tmp2, Node->getOperand(2)); 87831559081a4285f4b7282e765aea4ec8a8e1d396cAndrew Lenharth Result = DAG.getNode(ISD::FP_EXTEND, Node->getValueType(0), Load); 8799d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (Op.ResNo) 8809d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Load.getValue(1); 8819d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Result; 8829d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 88301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(Node->getOpcode() != ISD::EXTLOAD && 88401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner "EXTLOAD should always be supported!"); 88501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 88601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // zero/sign extend inreg. 8875f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 8885f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 88923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner SDOperand ValRes; 89023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SEXTLOAD) 89123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 89215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, DAG.getValueType(SrcVT)); 89323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner else 89423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getZeroExtendInReg(Result, SrcVT); 89501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), ValRes); 89601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 89701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Op.ResNo) 89801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(1); 89901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return ValRes; 90001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 90101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(0 && "Unreachable"); 90201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 9033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EXTRACT_ELEMENT: 9043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Get both the low and high parts. 9053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 9063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) 9073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = Tmp2; // 1 -> Hi 9083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner else 9093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = Tmp1; // 0 -> Lo 9103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 9133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 914edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 915c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getOperand(2).getValueType()) && 916d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner "Register type must be legal!"); 917d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // Legalize the incoming value (must be legal). 918d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 919d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) 920d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::CopyToReg, MVT::Other, Tmp1, 921d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getOperand(1), Tmp2); 9223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 9253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 9273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 2: // ret val 9283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 9293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 9303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 9318afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 9323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 9333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 9353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 9363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 9373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Lo, Hi); 938edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 9393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 9418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 9428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 9438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 9443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 9473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 9483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); 9493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 9513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<SDOperand> NewValues; 9523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 9533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) 9543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(i).getValueType())) { 9553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 9564e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NewValues.push_back(LegalizeOp(Node->getOperand(i))); 9573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 9593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 9603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(i), Lo, Hi); 9613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Lo); 9623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Hi); 963edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 9643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 9668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Can't promote multiple return value yet!"); 9673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); 9693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::STORE: 9743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 9763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9775d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 97803c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ 9795d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner if (CFP->getValueType(0) == MVT::f32) { 98000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 981cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(FloatToBits(CFP->getValue()), 982cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i32), 983cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 98452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 9855d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } else { 9865d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); 98700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 988cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(DoubleToBits(CFP->getValue()), 989cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i64), 990cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 99152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 9925d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 99384734ce8ef1a21eb347d4deca0bf32d59001f751Chris Lattner Node = Result.Val; 9945d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 9955d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner 9963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 9973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: { 9983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Val = LegalizeOp(Node->getOperand(1)); 9993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Val != Node->getOperand(1) || Tmp1 != Node->getOperand(0) || 10003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(2)) 100152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, 100252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 10033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 100603c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Truncate the value and store the result. 100703c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(1)); 100803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp3, Tmp2, 10092d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 10109fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getValueType(Node->getOperand(1).getValueType())); 101103c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 101203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 10133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: 10143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 10153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 10163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 10173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 10183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 10193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1020edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Lo = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Lo, Tmp2, 1021edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1022ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner unsigned IncrementSize = MVT::getSizeInBits(Hi.getValueType())/8; 10233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::ADD, Tmp2.getValueType(), Tmp2, 10243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 10253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Tmp2.getValueType()) && 10263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Pointers must be legal!"); 10272d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Again, claiming both parts of the store came form the same Instr 1028edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Hi, Tmp2, 1029edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1030ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1031ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner break; 10323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 103495762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 103595762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10362c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 10372c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); 103895762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 10390f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::TRUNCSTORE: 10400f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10410f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 10420f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 10430f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 10440f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Legal: 10450f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 10460f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 10470f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 != Node->getOperand(2)) 104845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 10499fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner Node->getOperand(3), Node->getOperand(4)); 10500f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 10510f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Promote: 10520f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Expand: 10530f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(0 && "Cannot handle illegal TRUNCSTORE yet!"); 10540f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner } 10550f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 10562ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 105747e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 105847e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 105947e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 106047e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 106147e9223e06390897c3834f8c527001df392570ffChris Lattner break; 106247e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 106347e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 106447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 106547e9223e06390897c3834f8c527001df392570ffChris Lattner } 10663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 10672ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 106855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 1069b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { 107055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 10719373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 10729373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 10739373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1.getOperand(0), Tmp1.getOperand(1), 10749373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 10759373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 10769373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 1077550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 1078550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 1079550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, MVT::i1); 10809373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1, 10819373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 10829373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 10839373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 10849373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 108555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 108655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 108755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 != Node->getOperand(2)) 108855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), 108955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp1, Tmp2, Tmp3); 109055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 109155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 109255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner MVT::ValueType NVT = 109355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 109455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 109555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (MVT::isInteger(Tmp2.getValueType())) { 109613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner ExtOp = ISD::ANY_EXTEND; 109755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::TRUNCATE; 109855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 109955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::FP_EXTEND; 110055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::FP_ROUND; 110155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 110255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 110355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp2 = DAG.getNode(ExtOp, NVT, Tmp2); 110455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 = DAG.getNode(ExtOp, NVT, Tmp3); 110555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 110655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2,Tmp3); 110755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(TruncOp, Node->getValueType(0), Result); 110855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 110955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 111055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 11113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11129373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 11139373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 11149373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 11159373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 1116c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(0).getValueType())) { 111723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner // Everything is legal, see if we should expand this op or something. 111823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner switch (TLI.getOperationAction(ISD::SELECT_CC, 111923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0).getValueType())) { 112023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner default: assert(0 && "This action is not supported yet!"); 112123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Custom: { 112223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner SDOperand Tmp = 112323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner TLI.LowerOperation(DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), 112423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0), 112523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(1), Tmp3, Tmp4, 1126d7050a9c50211dd215cb3c2bc28b4fb6bfa4a116Chris Lattner Node->getOperand(4)), DAG); 112723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp.Val) { 112823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = LegalizeOp(Tmp); 112923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 113023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 113123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } // FALLTHROUGH if the target can't lower this operation after all. 113223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Legal: 113323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 113423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 113523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 113623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3)) { 113723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), Tmp1, Tmp2, 113823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3, Tmp4, Node->getOperand(4)); 113923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 114023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 11419373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 11429373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 11439373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 11449373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp1 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 11459373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(0), // LHS 11469373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), // RHS 11479373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4))); 11487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 11497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 11507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 11517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 11527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 11537cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, Tmp3.getValueType(), 11547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1.getOperand(0), Tmp1.getOperand(1), 11557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, Tmp1.getOperand(2)); 11567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 11577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getSelectCC(Tmp1, 11587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 11597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, ISD::SETNE); 11607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 11619373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 11629373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 11633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 11643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 11653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 11663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 11673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 11683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 11708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // LHS 11718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // RHS 11728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 11738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // If this is an FP compare, the operands have already been extended. 11748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(Node->getOperand(0).getValueType())) { 11758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner MVT::ValueType VT = Node->getOperand(0).getValueType(); 117671c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 11778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 11788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Otherwise, we have to insert explicit sign or zero extends. Note 11798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // that we could insert sign extends for ALL conditions, but zero extend 11808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // is cheaper on many machines (an AND instead of two shifts), so prefer 11818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // it. 11827cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 11838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner default: assert(0 && "Unknown integer comparison!"); 11848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETEQ: 11858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETNE: 11868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGE: 11878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGT: 11888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULE: 11898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULT: 11908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // ALL of these operations will work if we either sign or zero extend 11918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // the operands (including the unsigned comparisons!). Zero extend is 11928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // usually a simpler/cheaper operation, so prefer it. 119323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 119423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 11958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 11968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGE: 11978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGT: 11988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLT: 11998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLE: 120015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 120115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 120215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 120315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 12048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 12058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 12068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 12073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1208edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case Expand: 12093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 12103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LHSLo, LHSHi); 12113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RHSLo, RHSHi); 12127cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 12133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETEQ: 12143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETNE: 121508b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSLo == RHSHi) 121608b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 121708b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSCST->isAllOnesValue()) { 121808b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner // Comparison to -1. 121908b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Tmp1 = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 1220b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSLo; 1221edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 122208b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner } 122308b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner 12243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 12253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 12263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp2); 1227b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 12283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 12305b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 12315b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // X > -1, x < 0 12325b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Node->getOperand(1))) 12337cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner if ((cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETLT && 12345b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner CST->getValue() == 0) || // X < 0 12357cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner (cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETGT && 1236b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman (CST->isAllOnesValue()))) { // X > -1 1237b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp1 = LHSHi; 1238b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSHi; 1239b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1240b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 12415b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner 12423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: This generated code sucks. 12433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ISD::CondCode LowCC; 12447cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 12453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: assert(0 && "Unknown integer setcc!"); 12463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLT: 12473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 12483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGT: 12493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 12503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLE: 12513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 12523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGE: 12533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 12543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1255edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 12563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 12573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 12583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 12593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 12613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 12627cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp1 = DAG.getSetCC(Node->getValueType(0), LHSLo, RHSLo, LowCC); 12637cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getNode(ISD::SETCC, Node->getValueType(0), LHSHi, RHSHi, 12647cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 12657cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getSetCC(Node->getValueType(0), LHSHi, RHSHi, ISD::SETEQ); 1266b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1267b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result, Tmp1, Tmp2)); 1268b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman return Result; 12693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1271b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman 1272b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch(TLI.getOperationAction(ISD::SETCC, Node->getOperand(0).getValueType())) { 1273b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman default: 1274b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman assert(0 && "Cannot handle this action for SETCC yet!"); 1275b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 12765e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth case TargetLowering::Promote: 12775e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 12785e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Node->getOperand(2)); 12795e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth break; 1280b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Legal: 1281b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1282b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 1283b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1284b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1285b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Expand: 1286b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // Expand a setcc node into a select_cc of the same condition, lhs, and 1287b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // rhs that selects between const 1 (true) and const 0 (false). 1288b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman MVT::ValueType VT = Node->getValueType(0); 1289b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SELECT_CC, VT, Tmp1, Tmp2, 1290b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman DAG.getConstant(1, VT), DAG.getConstant(0, VT), 1291b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1292b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(Result); 1293b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1294b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 12953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1297e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMSET: 1298e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMCPY: 1299e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMMOVE: { 1300deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Chain 1301e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Pointer 1302e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner 1303e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { // memset = ubyte 1304e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner switch (getTypeAction(Node->getOperand(2).getValueType())) { 1305e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand a byte!"); 1306e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1307deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 1308e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1309e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1310deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); 1311e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1312e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1313e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } else { 1314edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Tmp3 = LegalizeOp(Node->getOperand(2)); // memcpy/move = pointer, 1315e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1316272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1317272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp4; 1318272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(3).getValueType())) { 13196814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner case Expand: { 13206814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner // Length is too big, just take the lo-part of the length. 13216814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner SDOperand HiPart; 13226814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner ExpandOp(Node->getOperand(3), HiPart, Tmp4); 13236814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner break; 13246814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner } 1325e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1326e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = LegalizeOp(Node->getOperand(3)); 1327e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1328e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1329e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = PromoteOp(Node->getOperand(3)); 1330272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1331272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner } 1332272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1333272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp5; 1334272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(4).getValueType())) { // uint 1335272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 1336272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Legal: 1337272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner Tmp5 = LegalizeOp(Node->getOperand(4)); 1338272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1339272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Promote: 1340e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp5 = PromoteOp(Node->getOperand(4)); 1341e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1342e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 134355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 134455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 134555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 134607dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 134707dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 134807dffd6af673c73352150583150b242a93694f00Chris Lattner TLI.LowerOperation(DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, 134907dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp2, Tmp3, Tmp4, Tmp5), DAG); 135007dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 135107dffd6af673c73352150583150b242a93694f00Chris Lattner Result = LegalizeOp(Tmp); 135207dffd6af673c73352150583150b242a93694f00Chris Lattner break; 135307dffd6af673c73352150583150b242a93694f00Chris Lattner } 135407dffd6af673c73352150583150b242a93694f00Chris Lattner // FALLTHROUGH if the target thinks it is legal. 135507dffd6af673c73352150583150b242a93694f00Chris Lattner } 135655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 1357e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 1358e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || 1359e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp5 != Node->getOperand(4)) { 1360e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<SDOperand> Ops; 1361e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 1362e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 1363e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 1364e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 136555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 136655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: { 1367e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Otherwise, the target does not support this operation. Lower the 1368e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // operation to an explicit libcall as appropriate. 1369e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 1370e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner const Type *IntPtrTy = TLI.getTargetData().getIntPtrType(); 1371e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1372e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 13733bfbf4ea990930d153e58e153f319408341a94feReid Spencer const char *FnName = 0; 1374e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { 1375e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1376e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Extend the ubyte argument to be an int value for the call. 1377e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Tmp3); 1378e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, Type::IntTy)); 1379e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1380e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 1381e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = "memset"; 1382e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else if (Node->getOpcode() == ISD::MEMCPY || 1383e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Node->getOpcode() == ISD::MEMMOVE) { 1384e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1385e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, IntPtrTy)); 1386e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1387e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = Node->getOpcode() == ISD::MEMMOVE ? "memmove" : "memcpy"; 1388e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else { 1389e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner assert(0 && "Unknown op!"); 1390e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 139145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 1392e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 1393adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(Tmp1, Type::VoidTy, false, CallingConv::C, false, 1394e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner DAG.getExternalSymbol(FnName, IntPtr), Args, DAG); 1395c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner Result = CallResult.second; 1396c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner NeedsAnotherIteration = true; 139755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 139855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 1399e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 1400e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner break; 1401e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 140252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 140352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::READPORT: 140452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 140552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 14066d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14073e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 14083e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 14093e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 14103e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 14113e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 14123e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 14133e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 141452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = SDOperand(Node, 0); 141552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // Since these produce two values, make sure to remember that we legalized 141652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // both of them. 141752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 141852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 141952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner return Result.getValue(Op.ResNo); 142052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::WRITEPORT: 142152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 142252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 142352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 142452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 142552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 != Node->getOperand(2)) 142652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 142752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner break; 142852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 14296d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::READIO: 14306d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 14316d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 14326d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14336d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 14346d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 14356d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 14366d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 14373e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 14383e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 14393e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 14403e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 14413e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 14423e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 14433e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 14446d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = SDOperand(Node, 0); 14456d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14466d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 14476d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a load from memory. 14486d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0), 14496d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), DAG.getSrcValue(NULL)); 14506d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 14516d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14526d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 14536d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14546d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Since these produce two values, make sure to remember that we legalized 14556d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // both of them. 14566d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 14576d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 14586d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner return Result.getValue(Op.ResNo); 14596d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14606d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::WRITEIO: 14616d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 14626d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 14636d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 14646d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14656d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 14666d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1).getValueType())) { 14676d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 14686d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 14696d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 14706d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 14716d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 != Node->getOperand(2)) 14726d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 14736d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14746d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 14756d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a store to memory. 14766d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0), 14776d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), Node->getOperand(2), 14786d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getSrcValue(NULL)); 14796d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 14806d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14816d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 14826d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14836d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 148484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::ADD_PARTS: 14855b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SUB_PARTS: 14865b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 14875b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 14885b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 148984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 149084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 149184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 149284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 149384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 149484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 1495e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (Changed) { 1496e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 1497e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 1498e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 14992c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 15002c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 15012c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 15022c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 15032c8086f4b9916b2d02842be5e375276023225fbaChris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 15042c8086f4b9916b2d02842be5e375276023225fbaChris Lattner return Result.getValue(Op.ResNo); 150584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 15062c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 15072c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 15083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 15093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 15103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 1511c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 1512c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 15133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 15143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 15153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 15163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 15173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 151803c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 151903c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 152003c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 15213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1522f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth switch (getTypeAction(Node->getOperand(1).getValueType())) { 1523f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Expand: assert(0 && "Not possible"); 1524f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Legal: 1525f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 1526f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1527f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Promote: 1528f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the RHS. 1529f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1530f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth } 15313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 15323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 15333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 15343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1535edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1536c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 1537c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 1538c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1539c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 1540c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1541c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Legal: 1542c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman if (Tmp1 != Node->getOperand(0) || 1543c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 != Node->getOperand(1)) 1544edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 1545c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2); 1546c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1547c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Promote: 1548c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Custom: 1549c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman assert(0 && "Cannot promote/custom handle this yet!"); 15504c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner case TargetLowering::Expand: 15514c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner if (MVT::isInteger(Node->getValueType(0))) { 15524c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner MVT::ValueType VT = Node->getValueType(0); 15534c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner unsigned Opc = (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 15544c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(Opc, VT, Tmp1, Tmp2); 15554c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::MUL, VT, Result, Tmp2); 15564c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::SUB, VT, Tmp1, Result); 15574c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner } else { 15584c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner // Floating point mod -> fmod libcall. 15594c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner const char *FnName = Node->getValueType(0) == MVT::f32 ? "fmodf":"fmod"; 15604c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner SDOperand Dummy; 15614c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = ExpandLibCall(FnName, Node, Dummy); 1562c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1563c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1564c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1565c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 15662c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 1567691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1568691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1569691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1570691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 1571691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1572691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 1573691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth if (Tmp1 != Node->getOperand(0)) 1574691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1575691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1576691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 1577691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType OVT = Tmp1.getValueType(); 1578691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 1579edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 1580edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 1581691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 1582691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 1583691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1584691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch(Node->getOpcode()) 1585691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth { 1586691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1587691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 1588691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1589691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1590691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 15917cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 15927cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), 15937cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ); 159400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 1595691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(OVT),NVT), Tmp1); 1596691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1597691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1598691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 159900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 160000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 1601691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getSizeInBits(OVT), NVT)); 1602691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1603691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1604691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1605691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1606691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Custom: 1607691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth assert(0 && "Cannot custom handle this yet!"); 1608691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 1609ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth switch(Node->getOpcode()) 1610ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth { 1611ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth case ISD::CTPOP: { 1612e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner static const uint64_t mask[6] = { 1613e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 1614e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 1615e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 1616e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner }; 1617ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth MVT::ValueType VT = Tmp1.getValueType(); 1618e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner MVT::ValueType ShVT = TLI.getShiftAmountTy(); 1619e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner unsigned len = getSizeInBits(VT); 1620e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 1621ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 1622e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp2 = DAG.getConstant(mask[i], VT); 1623e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp3 = DAG.getConstant(1ULL << i, ShVT); 162400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::ADD, VT, 1625ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, Tmp1, Tmp2), 1626ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, 1627ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3), 1628ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp2)); 1629ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1630ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Result = Tmp1; 1631ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1632ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 163357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTLZ: { 163457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina /* for now, we do this: 16355c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 1); 16365c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 2); 16375c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner ... 16385c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>16); 163900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen x = x | (x >>32); // for 64-bit input 16405c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner return popcount(~x); 164100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 16425c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner but see also: http://www.hackersdelight.org/HDcode/nlz.cc */ 16435c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 164457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina MVT::ValueType ShVT = TLI.getShiftAmountTy(); 164557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina unsigned len = getSizeInBits(VT); 164657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 164757ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getConstant(1ULL << i, ShVT); 164800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::OR, VT, Tmp1, 164957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3)); 165057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 165157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getNode(ISD::XOR, VT, Tmp1, DAG.getConstant(~0ULL, VT)); 16525c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 165318aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 165457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 165557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTTZ: { 165600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen // for now, we use: { return popcount(~x & (x - 1)); } 1657d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // unless the target has ctlz but not ctpop, in which case we use: 1658d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // { return 32 - nlz(~x & (x-1)); } 1659d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // see also http://www.hackersdelight.org/HDcode/ntz.cc 16605c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 16615c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp2 = DAG.getConstant(~0ULL, VT); 166200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp3 = DAG.getNode(ISD::AND, VT, 16635c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::XOR, VT, Tmp1, Tmp2), 16645c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::SUB, VT, Tmp1, 16655c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getConstant(1, VT))); 1666d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // If ISD::CTLZ is legal and CTPOP isn't, then do that instead 1667c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::CTPOP, VT) && 1668c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::CTLZ, VT)) { 166900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = LegalizeOp(DAG.getNode(ISD::SUB, VT, 1670d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getConstant(getSizeInBits(VT), VT), 1671d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getNode(ISD::CTLZ, VT, Tmp3))); 1672d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } else { 1673d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 1674d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } 167518aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 167657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 1677ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth default: 1678ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth assert(0 && "Cannot expand this yet!"); 1679ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1680ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1681691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1682691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1683691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 168400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 16852c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 16862c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 16872c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 1688da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 1689da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 1690da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 16912c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 16922c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 16932c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 16942c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 16952c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 16962c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 16972c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Promote: 16982c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Custom: 16992c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Cannot promote/custom handle this yet!"); 17002c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 1701f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1702f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FNEG: { 17032c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 17042c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 17052c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = LegalizeOp(DAG.getNode(ISD::SUB, Node->getValueType(0), 17062c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2, Tmp1)); 1707f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1708f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1709f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 17104af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 17114af6e0d7836126630f579b0a34f054321187f00bChris Lattner MVT::ValueType VT = Node->getValueType(0); 17124af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 17137cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, Tmp2, ISD::SETUGT); 17144af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp3 = DAG.getNode(ISD::FNEG, VT, Tmp1); 17154af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = DAG.getNode(ISD::SELECT, VT, Tmp2, Tmp1, Tmp3); 17164af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = LegalizeOp(Result); 1717f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1718f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1719f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: 1720f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: 1721f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: { 1722f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner MVT::ValueType VT = Node->getValueType(0); 1723f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner const char *FnName = 0; 1724f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1725f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: FnName = VT == MVT::f32 ? "sqrtf" : "sqrt"; break; 1726f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: FnName = VT == MVT::f32 ? "sinf" : "sin"; break; 1727f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: FnName = VT == MVT::f32 ? "cosf" : "cos"; break; 1728f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 1729f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 17302ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman SDOperand Dummy; 17312ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman Result = ExpandLibCall(FnName, Node, Dummy); 1732f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1733f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1734f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: 17354af6e0d7836126630f579b0a34f054321187f00bChris Lattner assert(0 && "Unreachable!"); 17362c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 17372c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 17382c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 17392c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 17402c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 17412c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 1742fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::SINT_TO_FP: 1743fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::UINT_TO_FP: { 1744fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP; 1745fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1746fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1747d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen switch (TLI.getOperationAction(Node->getOpcode(), 1748fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType())) { 1749fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner default: assert(0 && "Unknown operation action!"); 1750fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Expand: 17516269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = ExpandLegalINT_TO_FP(isSigned, 17526269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey LegalizeOp(Node->getOperand(0)), 17536269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Node->getValueType(0)); 1754fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 1755fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 1756fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Promote: 1757fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteLegalINT_TO_FP(LegalizeOp(Node->getOperand(0)), 1758fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), 1759fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner isSigned); 1760fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 1761fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 1762fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Legal: 1763fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1764fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1765fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 1766fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1767fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1768fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1769fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1770fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1771fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, 1772fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), Node->getOperand(0)); 1773fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1774fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1775fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (isSigned) { 1776fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1777fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 1778fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result, DAG.getValueType(Node->getOperand(0).getValueType())); 1779fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SINT_TO_FP, Op.getValueType(), Result); 1780fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } else { 1781fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1782fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getZeroExtendInReg(Result, 1783fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType()); 1784fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::UINT_TO_FP, Op.getValueType(), Result); 1785fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1786fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1787fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1788fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1789fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1790fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::TRUNCATE: 1791fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1792fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1793fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1794fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1795fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1796fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1797fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1798fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 1799fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 1800fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // Since the result is legal, we should just be able to truncate the low 1801fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // part of the source. 1802fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Tmp1); 1803fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1804fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1805fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1806fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Op.getValueType(), Result); 1807fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1808fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1809fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1810d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 1811fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_SINT: 1812fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_UINT: 1813fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1814fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1815f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1816f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner 18171618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))){ 18181618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: assert(0 && "Unknown operation action!"); 18191618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Expand: 1820d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT) { 1821d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman SDOperand True, False; 1822d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType VT = Node->getOperand(0).getValueType(); 1823d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType NVT = Node->getValueType(0); 1824d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman unsigned ShiftAmt = MVT::getSizeInBits(Node->getValueType(0))-1; 1825d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getConstantFP((double)(1ULL << ShiftAmt), VT); 1826d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp3 = DAG.getSetCC(TLI.getSetCCResultTy(), 1827d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Node->getOperand(0), Tmp2, ISD::SETLT); 1828d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman True = DAG.getNode(ISD::FP_TO_SINT, NVT, Node->getOperand(0)); 1829d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::FP_TO_SINT, NVT, 1830d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getNode(ISD::SUB, VT, Node->getOperand(0), 1831d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2)); 1832d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::XOR, NVT, False, 1833d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getConstant(1ULL << ShiftAmt, NVT)); 1834d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, NVT, Tmp3, True, False)); 18352d56e72f09337a1cab3ba199a9467c159296f3faNate Begeman return Result; 1836d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 1837d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman assert(0 && "Do not know how to expand FP_TO_SINT yet!"); 1838d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 1839d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman break; 18401618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Promote: 1841f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = PromoteLegalFP_TO_INT(Tmp1, Node->getValueType(0), 18421618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner Node->getOpcode() == ISD::FP_TO_SINT); 18431618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner AddLegalizedOperand(Op, Result); 18441618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return Result; 184507dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 184607dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 184707dffd6af673c73352150583150b242a93694f00Chris Lattner DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 184807dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp = TLI.LowerOperation(Tmp, DAG); 184907dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 185007dffd6af673c73352150583150b242a93694f00Chris Lattner AddLegalizedOperand(Op, Tmp); 185107dffd6af673c73352150583150b242a93694f00Chris Lattner NeedsAnotherIteration = true; 1852507f752f6ed28aa9f0ae680e95bfc93df4e9e2dcChris Lattner return Tmp; 185307dffd6af673c73352150583150b242a93694f00Chris Lattner } else { 185407dffd6af673c73352150583150b242a93694f00Chris Lattner // The target thinks this is legal afterall. 185507dffd6af673c73352150583150b242a93694f00Chris Lattner break; 185607dffd6af673c73352150583150b242a93694f00Chris Lattner } 185707dffd6af673c73352150583150b242a93694f00Chris Lattner } 18581618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 18591618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 18601618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 1861d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 1862fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1863fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1864fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1865fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1866fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 1867fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1868fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1869fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 1870fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1871fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1872fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1873d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 187413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 18753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 18763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 187703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_EXTEND: 187803c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_ROUND: 18793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 18803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 18813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 18823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 18833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 18843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1885b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner case Expand: 18862c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 1887b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner 188803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Promote: 188903c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 189013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 189113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = PromoteOp(Node->getOperand(0)); 189213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 189313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 18941713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner case ISD::ZERO_EXTEND: 18951713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 189613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 189723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 189823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 189903c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 190003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SIGN_EXTEND: 19011713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 190213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 19031713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 190415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 190515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 19061713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 190703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_EXTEND: 19081713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 19091713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner if (Result.getValueType() != Op.getValueType()) 19101713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner // Dynamically dead while we have only 2 FP types. 19111713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::FP_EXTEND, Op.getValueType(), Result); 19121713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 191303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_ROUND: 1914f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 1915f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 1916f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 191703c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 19183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 19193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 19200f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 192123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 19220f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 192315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 192445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 192545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 192645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 192755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 192855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 192955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 193055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0)) 193155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 19325f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner DAG.getValueType(ExtraVT)); 193355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 193455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 193545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 193623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 193745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 193845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 193945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned BitsDiff = MVT::getSizeInBits(Node->getValueType(0)) - 194045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::getSizeInBits(ExtraVT); 194127ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner SDOperand ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 194245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SHL, Node->getValueType(0), 194345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 194445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SRA, Node->getValueType(0), 194545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 194645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 194745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // The only way we can lower this is to turn it into a STORETRUNC, 194845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 194945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 195045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 195145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 195245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 195345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner const Type *Ty = MVT::getTypeForValueType(ExtraVT); 195445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned TySize = (unsigned)TLI.getTargetData().getTypeSize(Ty); 195545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 195645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 1957edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman int SSFI = 195845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 195945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 196045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, DAG.getEntryNode(), 196152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(0), StackSlot, 19629fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getSrcValue(NULL), DAG.getValueType(ExtraVT)); 19635f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 19645f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result, StackSlot, DAG.getSrcValue(NULL), 19655f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner ExtraVT); 196645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 196745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 196845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 196945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = LegalizeOp(Result); 197055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 197145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 19720f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 19733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 197445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 19753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 197645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 197745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 197845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 19793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 19803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 19813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 19828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// PromoteOp - Given an operation that produces a value in an invalid type, 19838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// promote it to compute the value into a larger type. The produced value will 19848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// have the correct bits for the low portion of the register, but no guarantee 19858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// is made about the top bits: it may be zero, sign-extended, or garbage. 198603c8546ec57523970874917854a2fb77b1ff598eChris LattnerSDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) { 198703c8546ec57523970874917854a2fb77b1ff598eChris Lattner MVT::ValueType VT = Op.getValueType(); 198871c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 198903c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(getTypeAction(VT) == Promote && 199003c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Caller should expand or legalize operands that are not promotable!"); 199103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(NVT > VT && MVT::isInteger(NVT) == MVT::isInteger(VT) && 199203c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Cannot promote to smaller type!"); 199303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 199403c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Tmp1, Tmp2, Tmp3; 199503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 199603c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Result; 199703c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDNode *Node = Op.Val; 199803c8546ec57523970874917854a2fb77b1ff598eChris Lattner 199945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (!Node->hasOneUse()) { 200045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner std::map<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op); 200145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (I != PromotedNodes.end()) return I->second; 200245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } else { 200345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner assert(!PromotedNodes.count(Op) && "Repromoted this node??"); 200445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } 200545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 20060f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // Promotion needs an optimization step to clean up after it, and is not 20070f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // careful to avoid operations the target does not support. Make sure that 20080f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // all generated operations are legalized in the next iteration. 20090f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner NeedsAnotherIteration = true; 20100f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 201103c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 2012d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2013d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 201403c8546ec57523970874917854a2fb77b1ff598eChris Lattner default: 201503c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 201603c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(0 && "Do not know how to promote this operator!"); 201703c8546ec57523970874917854a2fb77b1ff598eChris Lattner abort(); 2018fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2019fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getNode(ISD::UNDEF, NVT); 2020fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 202103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::Constant: 2022ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner if (VT != MVT::i1) 2023ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND, NVT, Op); 2024ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner else 2025ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, NVT, Op); 202603c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantSDNode>(Result) && "Didn't constant fold zext?"); 202703c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 202803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::ConstantFP: 202903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::FP_EXTEND, NVT, Op); 203003c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantFPSDNode>(Result) && "Didn't constant fold fp_extend?"); 203103c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2032ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner 203382fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner case ISD::SETCC: 2034c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(TLI.getSetCCResultTy()) && "SetCC type is not legal??"); 20357cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(),Node->getOperand(0), 20367cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(1), Node->getOperand(2)); 203782fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = LegalizeOp(Result); 203882fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner break; 203903c8546ec57523970874917854a2fb77b1ff598eChris Lattner 204003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 204103c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 204203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Legal: 204303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 204403c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.getValueType() >= NVT && 204503c8546ec57523970874917854a2fb77b1ff598eChris Lattner "This truncation doesn't make sense!"); 204603c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (Result.getValueType() > NVT) // Truncate to NVT instead of VT 204703c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Result); 204803c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2049e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner case Promote: 2050e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // The truncation is not required, because we don't guarantee anything 2051e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // about high bits anyway. 2052e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner Result = PromoteOp(Node->getOperand(0)); 2053e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner break; 205403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Expand: 205579e46acd35df36477029e9f534ab1a366a98df56Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 205679e46acd35df36477029e9f534ab1a366a98df56Nate Begeman // Truncate the low part of the expanded value to the result type 2057e21c305ed85b2be4a27784ba52471f6b68fdd255Chris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Tmp1); 205803c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 205903c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 20608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SIGN_EXTEND: 20618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::ZERO_EXTEND: 206213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 20638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 20648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Smaller reg should have been promoted!"); 20658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 20668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Just do extend all the way to the larger type. 20678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 20688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 20698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 20718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Promote the reg if it's smaller. 20728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 20738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The high bits are not guaranteed to be anything. Insert an extend. 20748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND) 2075595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 207615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 207713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner else if (Node->getOpcode() == ISD::ZERO_EXTEND) 207823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 207923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 20808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 20828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 20848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_EXTEND: 20858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Case not implemented. Dynamically dead with 2 FP types!"); 20868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_ROUND: 20878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 20888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Cannot expand FP regs!"); 20898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: assert(0 && "Unreachable with 2 FP types!"); 20908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 20918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Do an FP_ROUND_INREG. 20928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 209315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 209415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 20958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 20978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 20998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SINT_TO_FP: 21008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UINT_TO_FP: 21018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 21028b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 21038b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 210477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 210577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 21068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 21088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 21098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 21108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP) 21118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 211215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 211315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 21148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 211523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 211623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 211777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 211877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 21198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 212177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, NVT, 212277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOperand(0)); 212377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // Round if we cannot tolerate excess precision. 212477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (NoExcessFPPrecision) 212515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 212615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 212777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 21288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 21298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 21318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_SINT: 21328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_UINT: 21338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 21348b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 21358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 21368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 21388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input result is prerounded, so we don't have to do anything 21398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // special. 21408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 21438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "not implemented"); 21448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 2145d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // If we're promoting a UINT to a larger size, check to see if the new node 2146d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 2147d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // we can use that instead. This allows us to generate better code for 2148d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 2149d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // legal, such as PowerPC. 2150d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT && 2151c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) && 2152c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::FP_TO_SINT, NVT)) { 2153d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(ISD::FP_TO_SINT, NVT, Tmp1); 2154d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2155d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2156d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 21578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 21592c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 21602c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 21612c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21622c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(Tmp1.getValueType() == NVT); 21632c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 21642c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NOTE: we do not have to do any extra rounding here for 21652c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NoExcessFPPrecision, because we know the input will have the appropriate 21662c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // precision, and these operations don't modify precision at all. 21672c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 21682c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 2169da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2170da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2171da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 2172da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 2173da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner assert(Tmp1.getValueType() == NVT); 2174da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2175da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner if(NoExcessFPPrecision) 217615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 217715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 2178da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner break; 2179da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner 218003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::AND: 218103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::OR: 218203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::XOR: 21830f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::ADD: 21848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SUB: 21850f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::MUL: 21860f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // The input may have strange things in the top bits of the registers, but 21870f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // these operations don't care. They may have wierd bits going out, but 21880f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // that too is okay if they are integer operations. 21890f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21900f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 21910f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 21920f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 21930f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 21940f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // However, if this is a floating point operation, they will give excess 21950f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // precision that we may not be able to tolerate. If we DO allow excess 21960f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // precision, just leave it, otherwise excise it. 21978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // FIXME: Why would we need to round FP ops more than integer ones? 21988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Is Round(Add(Add(A,B),C)) != Round(Add(Round(Add(A,B)), C)) 21990f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 220015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 220115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 22020f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 22030f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 22048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SDIV: 22058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SREM: 22068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be sign extended. 22078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 22088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 22098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(NVT)) { 221015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 221115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 221215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 221315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 22148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 22158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 22168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 22188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 221915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 222015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 22218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UDIV: 22248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UREM: 22258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be zero extended. 22268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 22278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 22288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(MVT::isInteger(NVT) && "Operators don't apply to FP!"); 222923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 223023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 22318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 22328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22348b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SHL: 22358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 22368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 22378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SHL, NVT, Tmp1, Tmp2); 22388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRA: 22408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly sign extended. 22418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 224215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 224315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 22448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 22458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRA, NVT, Tmp1, Tmp2); 22468b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22478b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRL: 22488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly zero extended. 22498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 225023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 22518b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 22528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRL, NVT, Tmp1, Tmp2); 22538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 225403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::LOAD: 225503c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 225603c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2257232ee95a09a583b7d66b90ee7ddf7fdb9c194a04Chris Lattner // FIXME: When the DAG combiner exists, change this to use EXTLOAD! 22586841dec8c1c071b5a417fb4172633c68301be36cChris Lattner if (MVT::isInteger(NVT)) 22595f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Tmp1, Tmp2, 22605f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Node->getOperand(2), VT); 22616841dec8c1c071b5a417fb4172633c68301be36cChris Lattner else 22625f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, NVT, Tmp1, Tmp2, 22635f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Node->getOperand(2), VT); 226403c8546ec57523970874917854a2fb77b1ff598eChris Lattner 226503c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Remember that we legalized the chain. 226603c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 226703c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 226803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SELECT: 226947e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 227047e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 227147e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 227247e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0));// Legalize the condition. 227347e9223e06390897c3834f8c527001df392570ffChris Lattner break; 227447e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 227547e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 227647e9223e06390897c3834f8c527001df392570ffChris Lattner break; 227747e9223e06390897c3834f8c527001df392570ffChris Lattner } 227803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Legalize the op0 227903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); // Legalize the op1 228003c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2, Tmp3); 228103c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 22829373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 22839373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2 = PromoteOp(Node->getOperand(2)); // True 22849373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = PromoteOp(Node->getOperand(3)); // False 22859373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 22869373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), Tmp2, Tmp3, 22879373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4)); 22889373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 2289d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 22908ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner case ISD::CALL: { 22918ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 22928ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 22938ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 22943d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 22953d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) 22963d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 22973d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 22988ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 22998ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner "Can only promote single result calls"); 23008ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner std::vector<MVT::ValueType> RetTyVTs; 23018ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.reserve(2); 23028ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(NVT); 23038ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(MVT::Other); 2304d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 2305d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 23068ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Result = SDOperand(NC, 0); 23078ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 23088ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner // Insert the new chain mapping. 23098ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 23108ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner break; 2311edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 2312fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2313fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2314fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2315fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = Node->getOperand(0); 2316fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Zero extend the argument 2317fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2318fecf095292991bdf9396fec474011446107f9813Andrew Lenharth // Perform the larger operation, then subtract if needed. 2319fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2320fecf095292991bdf9396fec474011446107f9813Andrew Lenharth switch(Node->getOpcode()) 2321fecf095292991bdf9396fec474011446107f9813Andrew Lenharth { 2322fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2323fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = Tmp1; 2324fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2325fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2326fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 2327d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 23287cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), ISD::SETEQ); 232900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 2330fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(VT),NVT), Tmp1); 2331fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2332fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2333fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 233400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 233500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 2336fecf095292991bdf9396fec474011446107f9813Andrew Lenharth getSizeInBits(VT), NVT)); 2337fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2338fecf095292991bdf9396fec474011446107f9813Andrew Lenharth } 2339fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 234003c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 234103c8546ec57523970874917854a2fb77b1ff598eChris Lattner 234203c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.Val && "Didn't set a result!"); 234303c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddPromotedOperand(Op, Result); 234403c8546ec57523970874917854a2fb77b1ff598eChris Lattner return Result; 234503c8546ec57523970874917854a2fb77b1ff598eChris Lattner} 23463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 234784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// ExpandAddSub - Find a clever way to expand this add operation into 234884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// subcomponents. 23494759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattnervoid SelectionDAGLegalize:: 23504759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris LattnerExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 23514759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi) { 235284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner // Expand the subcomponents. 235384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 235484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(LHS, LHSL, LHSH); 235584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(RHS, RHSL, RHSH); 235684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 2357bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner // FIXME: this should be moved to the dag combiner someday. 2358e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner assert(NodeOp == ISD::ADD_PARTS || NodeOp == ISD::SUB_PARTS); 2359e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (LHSL.getValueType() == MVT::i32) { 2360e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner SDOperand LowEl; 2361e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(LHSL)) 2362e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (C->getValue() == 0) 2363e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner LowEl = RHSL; 2364e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHSL)) 2365e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (C->getValue() == 0) 2366e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner LowEl = LHSL; 2367e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (LowEl.Val) { 2368e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner // Turn this into an add/sub of the high part only. 2369e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner SDOperand HiEl = 2370e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner DAG.getNode(NodeOp == ISD::ADD_PARTS ? ISD::ADD : ISD::SUB, 2371e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner LowEl.getValueType(), LHSH, RHSH); 2372e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = LowEl; 2373e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Hi = HiEl; 2374e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner return; 2375bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner } 2376e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 2377bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner 237884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 237984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSL); 238084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSH); 238184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSL); 238284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSH); 2383e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner 2384e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2385e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 238684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Hi = Lo.getValue(1); 238784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner} 238884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 23895b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattnervoid SelectionDAGLegalize::ExpandShiftParts(unsigned NodeOp, 23905b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand Op, SDOperand Amt, 23915b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi) { 23925b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner // Expand the subcomponents. 23935b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand LHSL, LHSH; 23945b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandOp(Op, LHSL, LHSH); 23955b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 23965b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner std::vector<SDOperand> Ops; 23975b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSL); 23985b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSH); 23995b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(Amt); 2400cc0675a4be9a5133abd48ee272ff999ae48feabfChris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2401e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 24025b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Hi = Lo.getValue(1); 24035b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner} 24045b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 24055b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 2406e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// ExpandShift - Try to find a clever way to expand this shift operation out to 2407e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// smaller elements. If we can't find a way that is more efficient than a 2408e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// libcall on this target, return false. Otherwise, return true with the 2409e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// low-parts expanded into Lo and Hi. 2410e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattnerbool SelectionDAGLegalize::ExpandShift(unsigned Opc, SDOperand Op,SDOperand Amt, 2411e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi) { 2412e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner assert((Opc == ISD::SHL || Opc == ISD::SRA || Opc == ISD::SRL) && 2413e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner "This is not a shift!"); 2414f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2415e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(Op.getValueType()); 2416f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand ShAmt = LegalizeOp(Amt); 2417f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman MVT::ValueType ShTy = ShAmt.getValueType(); 2418f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned VTBits = MVT::getSizeInBits(Op.getValueType()); 2419f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned NVTBits = MVT::getSizeInBits(NVT); 2420f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2421f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Handle the case when Amt is an immediate. Other cases are currently broken 2422f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and are disabled. 2423f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Amt.Val)) { 2424f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned Cst = CN->getValue(); 2425f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Expand the incoming operand to be shifted, so that we have its parts 2426f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand InL, InH; 2427f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman ExpandOp(Op, InL, InH); 2428f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman switch(Opc) { 2429f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SHL: 2430f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2431f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2432f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2433f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2434f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2435f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst-NVTBits,ShTy)); 2436ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2437ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = DAG.getConstant(0, NVT); 2438ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = InL; 2439f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2440f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst, ShTy)); 2441f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::OR, NVT, 2442f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(Cst, ShTy)), 2443f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(NVTBits-Cst, ShTy))); 2444f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2445f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2446f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRL: 2447f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2448f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2449f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2450f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2451f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst-NVTBits,ShTy)); 2452f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2453ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2454ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2455ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = DAG.getConstant(0, NVT); 2456f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2457f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2458f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2459f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2460f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst, ShTy)); 2461f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2462f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2463f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRA: 2464f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2465edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 2466f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2467f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2468edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Lo = DAG.getNode(ISD::SRA, NVT, InH, 2469f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(Cst-NVTBits, ShTy)); 2470edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2471f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2472ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2473ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2474edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2475ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2476f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2477f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2478f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2479f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2480f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Cst, ShTy)); 2481f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2482f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2483f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2484f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2485f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // FIXME: The following code for expanding shifts using ISD::SELECT is buggy, 2486f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // so disable it for now. Currently targets are handling this via SHL_PARTS 2487f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and friends. 2488f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return false; 2489e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2490e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we have an efficient select operation (or if the selects will all fold 2491e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // away), lower to some complex code, otherwise just emit the libcall. 2492c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::SELECT, NVT) && !isa<ConstantSDNode>(Amt)) 2493e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return false; 2494e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2495e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand InL, InH; 2496e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ExpandOp(Op, InL, InH); 2497e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand NAmt = DAG.getNode(ISD::SUB, ShTy, // NAmt = 32-ShAmt 2498e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits, ShTy), ShAmt); 2499e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2500e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner // Compare the unmasked shift amount against 32. 25017cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand Cond = DAG.getSetCC(TLI.getSetCCResultTy(), ShAmt, 25027cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(NVTBits, ShTy), ISD::SETGE); 2503e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner 2504e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getShiftAmountFlavor() != TargetLowering::Mask) { 2505e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ShAmt = DAG.getNode(ISD::AND, ShTy, ShAmt, // ShAmt &= 31 2506e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2507e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner NAmt = DAG.getNode(ISD::AND, ShTy, NAmt, // NAmt &= 31 2508e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2509e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2510e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2511e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (Opc == ISD::SHL) { 2512e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << Amt) | (Lo >> NAmt) 2513e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, ShAmt), 2514e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, NAmt)); 2515e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(ISD::SHL, NVT, InL, ShAmt); // T2 = Lo << Amt&31 2516edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2517e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2518e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, DAG.getConstant(0, NVT), T2); 2519e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } else { 252077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand HiLoPart = DAG.getNode(ISD::SELECT, NVT, 25217cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getSetCC(TLI.getSetCCResultTy(), NAmt, 25227cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(32, ShTy), 25237cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ), 252477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(0, NVT), 252577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, NAmt)); 2526e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << NAmt) | (Lo >> Amt) 252777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiLoPart, 2528e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, ShAmt)); 2529e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(Opc, NVT, InH, ShAmt); // T2 = InH >> ShAmt&31 2530e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2531e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand HiPart; 253277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Opc == ISD::SRA) 253377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiPart = DAG.getNode(ISD::SRA, NVT, InH, 253477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2535e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner else 2536e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner HiPart = DAG.getConstant(0, NVT); 2537e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2538e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, HiPart, T2); 2539e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2540e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return true; 2541e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner} 254277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 25439530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindLatestCallSeqStart - Scan up the dag to find the latest (highest 25449530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqStart operation and occurs later than 25459c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// Found. 25469530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic void FindLatestCallSeqStart(SDNode *Node, SDNode *&Found) { 25479c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->getNodeDepth() <= Found->getNodeDepth()) return; 25482f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner 254916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_START, we already know this node occurs later 25509c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 255116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) { 25529c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 25539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 25549c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 25559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25569c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 25579c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(Node->getNumOperands() != 0 && 25589c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner "All leaves should have depth equal to the entry node!"); 25599c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = Node->getNumOperands()-1; i != e; ++i) 25609530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(i).Val, Found); 25619c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 25639530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(Node->getNumOperands()-1).Val, 25649c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found); 25659c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 25669c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25679c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25689530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindEarliestCallSeqEnd - Scan down the dag to find the earliest (lowest 25699530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqEnd operation and occurs more recent 25709c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// than Found. 257182299e70977500209c951404e354510feffb8efaChris Lattnerstatic void FindEarliestCallSeqEnd(SDNode *Node, SDNode *&Found, 257282299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> &Visited) { 257382299e70977500209c951404e354510feffb8efaChris Lattner if ((Found && Node->getNodeDepth() >= Found->getNodeDepth()) || 257482299e70977500209c951404e354510feffb8efaChris Lattner !Visited.insert(Node).second) return; 25759c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 257616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_END, we already know this node occurs earlier 25779c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 257816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) { 25799c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 25809c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 25819c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 25829c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25839c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 25849c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end(); 25859c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (UI == E) return; 25869c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (--E; UI != E; ++UI) 258782299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 25889c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25899c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 259082299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 25919c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 25929c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25939530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqEnd - Given a chained node that is part of a call sequence, 259416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_END node that terminates the call sequence. 25959530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqEnd(SDNode *Node) { 259616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 25979c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return Node; 2598f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (Node->use_empty()) 25999530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return 0; // No CallSeqEnd 26009c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26019c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->hasOneUse()) // Simple case, only has one user to check. 26029530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqEnd(*Node->use_begin()); 2603edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 26049c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand TheChain(Node, Node->getNumValues()-1); 26052789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner if (TheChain.getValueType() != MVT::Other) 26062789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner TheChain = SDOperand(Node, 0); 26079c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(TheChain.getValueType() == MVT::Other && "Is not a token chain!"); 2608edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2609edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman for (SDNode::use_iterator UI = Node->use_begin(), 26102f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner E = Node->use_end(); UI != E; ++UI) { 2611edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 26129c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Make sure to only follow users of our token chain. 26139c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *User = *UI; 26149c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 26159c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (User->getOperand(i) == TheChain) 2616eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner if (SDNode *Result = FindCallSeqEnd(User)) 2617eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner return Result; 26189c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 26192f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner return 0; 26209c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 26219c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26229530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqStart - Given a chained node that is part of a call sequence, 262316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_START node that initiates the call sequence. 26249530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqStart(SDNode *Node) { 26259530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(Node && "Didn't find callseq_start for a call??"); 262616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 26270d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26280d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 26290d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner "Node doesn't have a token chain argument!"); 26309530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqStart(Node->getOperand(0).Val); 26310d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 26320d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26330d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26349c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// FindInputOutputChains - If we are replacing an operation with a call we need 26359c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// to find the call that occurs before and the call that occurs after it to 26360d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// properly serialize the calls in the block. The returned operand is the 26370d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// input chain value for the new call (e.g. the entry node or the previous 26380d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// call), and OutChain is set to be the chain node to update to point to the 26390d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// end of the call chain. 26409c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnerstatic SDOperand FindInputOutputChains(SDNode *OpNode, SDNode *&OutChain, 26419c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand Entry) { 26429530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqStart = Entry.Val; 26439530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqEnd = 0; 26449530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(OpNode, LatestCallSeqStart); 26459530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner //std::cerr<<"Found node: "; LatestCallSeqStart->dump(); std::cerr <<"\n"; 2646edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 264716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // It is possible that no ISD::CALLSEQ_START was found because there is no 2648c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman // previous call in the function. LatestCallStackDown may in that case be 264916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // the entry node itself. Do not attempt to find a matching CALLSEQ_END 265016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // unless LatestCallStackDown is an CALLSEQ_START. 26519530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner if (LatestCallSeqStart->getOpcode() == ISD::CALLSEQ_START) 26529530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = FindCallSeqEnd(LatestCallSeqStart); 2653c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman else 26549530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = Entry.Val; 26559530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(LatestCallSeqEnd && "NULL return from FindCallSeqEnd"); 2656edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 26570d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Finally, find the first call that this must come before, first we find the 26589530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // CallSeqEnd that ends the call. 26590d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain = 0; 266082299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> Visited; 266182299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(OpNode, OutChain, Visited); 26629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26639530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // If we found one, translate from the adj up to the callseq_start. 26640d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain) 26659530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner OutChain = FindCallSeqStart(OutChain); 26669c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26679530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return SDOperand(LatestCallSeqEnd, 0); 26689c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 26699c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 267000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen/// SpliceCallInto - Given the result chain of a libcall (CallResult), and a 2671b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattnervoid SelectionDAGLegalize::SpliceCallInto(const SDOperand &CallResult, 2672b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SDNode *OutChain) { 26730d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Nothing to splice it into? 26740d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain == 0) return; 26750d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26760d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(OutChain->getOperand(0).getValueType() == MVT::Other); 26770d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner //OutChain->dump(); 26780d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26790d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Form a token factor node merging the old inval and the new inval. 26800d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InToken = DAG.getNode(ISD::TokenFactor, MVT::Other, CallResult, 26810d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->getOperand(0)); 26820d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Change the node to refer to the new token. 26830d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->setAdjCallChain(InToken); 26840d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 26859c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26869c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 268777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 268877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 268977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 269077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 269177e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize::ExpandLibCall(const char *Name, SDNode *Node, 269277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi) { 26939c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *OutChain; 26949c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand InChain = FindInputOutputChains(Node, OutChain, 26959c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner DAG.getEntryNode()); 2696f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (InChain.Val == 0) 2697f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner InChain = DAG.getEntryNode(); 26989c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 269977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 270077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 270177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner MVT::ValueType ArgVT = Node->getOperand(i).getValueType(); 270277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(ArgVT); 270377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Node->getOperand(i), ArgTy)); 270477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 270577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(Name, TLI.getPointerTy()); 2706edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 27070d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 270877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(Node->getValueType(0)); 27090d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallInfo = 2710adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, false, 2711adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 2712b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallInfo.second, OutChain); 2713b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 2714b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner NeedsAnotherIteration = true; 27150d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 27160d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner switch (getTypeAction(CallInfo.first.getValueType())) { 271777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner default: assert(0 && "Unknown thing"); 271877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Legal: 27190d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallInfo.first; 272077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Promote: 272177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(0 && "Cannot promote this yet!"); 272277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Expand: 272377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Lo; 27240d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner ExpandOp(CallInfo.first, Lo, Hi); 272577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner return Lo; 272677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 272777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 272877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 27299c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 273077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// ExpandIntToFP - Expand a [US]INT_TO_FP operation, assuming that the 273177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// destination type is legal. 273277e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize:: 273377e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) { 2734c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(DestTy) && "Destination type is not legal!"); 273577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(Source.getValueType()) == Expand && 273677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner "This is not an expansion!"); 273777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(Source.getValueType() == MVT::i64 && "Only handle expand from i64!"); 273877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 27390d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (!isSigned) { 2740e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(Source.getValueType() == MVT::i64 && 2741e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner "This only works for 64-bit -> FP"); 2742e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 2743e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // incoming integer is set. To handle this, we dynamically test to see if 2744e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // it is set, and, if so, add a fudge factor. 2745e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Lo, Hi; 2746e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner ExpandOp(Source, Lo, Hi); 2747e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 274866de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 274966de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // signed, then adjust the result if the sign bit is set. 275066de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner SDOperand SignedConv = ExpandIntToFP(true, DestTy, 275166de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), Lo, Hi)); 275266de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 27537cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Hi, 27547cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Hi.getValueType()), 27557cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 2756e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 2757e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 2758e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SignSet, Four, Zero); 2759383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner uint64_t FF = 0x5f800000ULL; 2760383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 2761383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 2762e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 27635839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 2764e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 2765e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand FudgeInReg; 2766e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner if (DestTy == MVT::f32) 276752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 276852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 2769e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner else { 2770e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(DestTy == MVT::f64 && "Unexpected conversion"); 27715f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 27725f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 2773e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 2774e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner return DAG.getNode(ISD::ADD, DestTy, SignedConv, FudgeInReg); 277577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 27760d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 2777a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 2778a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, Source.getValueType())) { 2779a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 2780a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Legal: 2781a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Expand: 2782a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner break; // This case is handled below. 278307dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 278407dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand NV = TLI.LowerOperation(DAG.getNode(ISD::SINT_TO_FP, DestTy, 278507dffd6af673c73352150583150b242a93694f00Chris Lattner Source), DAG); 278607dffd6af673c73352150583150b242a93694f00Chris Lattner if (NV.Val) 278707dffd6af673c73352150583150b242a93694f00Chris Lattner return LegalizeOp(NV); 278807dffd6af673c73352150583150b242a93694f00Chris Lattner break; // The target decided this was legal after all 278907dffd6af673c73352150583150b242a93694f00Chris Lattner } 2790a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 2791a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 279213689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // Expand the source, then glue it back together for the call. We must expand 279313689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // the source in case it is shared (this pass of legalize must traverse it). 279413689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner SDOperand SrcLo, SrcHi; 279513689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner ExpandOp(Source, SrcLo, SrcHi); 279613689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner Source = DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), SrcLo, SrcHi); 279713689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 27980d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDNode *OutChain = 0; 27990d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InChain = FindInputOutputChains(Source.Val, OutChain, 28000d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner DAG.getEntryNode()); 28010d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner const char *FnName = 0; 28020d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (DestTy == MVT::f32) 28030d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdisf"; 28040d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner else { 28050d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(DestTy == MVT::f64 && "Unknown fp value type!"); 28060d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdidf"; 28070d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 28080d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 280977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(FnName, TLI.getPointerTy()); 281077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 281177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 281277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(Source.getValueType()); 281344d105b7faf5672a2af61a3f0fdfed0d437d5777Chris Lattner 281477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Source, ArgTy)); 281577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 281677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // We don't care about token chains for libcalls. We just use the entry 281777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // node as our input and ignore the output chain. This allows us to place 281877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // calls wherever we need them to satisfy data dependences. 281977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(DestTy); 28200d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 28210d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 2822adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, true, 2823adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 28240d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 2825b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallResult.second, OutChain); 28260d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallResult.first; 282777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 2828edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2829e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2830e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 28313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandOp - Expand the specified SDOperand into its two component pieces 28323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo&Hi. Note that the Op MUST be an expanded type. As a result of this, the 28333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// LegalizeNodes map is filled in for any results that are not expanded, the 28343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandedNodes map is filled in for any results that are expanded, and the 28353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo/Hi values are returned. 28363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){ 28373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = Op.getValueType(); 283871c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 28393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDNode *Node = Op.Val; 28403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(VT) == Expand && "Not an expanded type!"); 28413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::isInteger(VT) && "Cannot expand FP values!"); 28423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::isInteger(NVT) && NVT < VT && 28433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand to FP value or to larger int value!"); 28443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 28453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If there is more than one use of this, see if we already expanded it. 28463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // There is no use remembering values that only have a single use, as the map 28473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // entries will never be reused. 28483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!Node->hasOneUse()) { 28493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I 28503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner = ExpandedNodes.find(Op); 28513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (I != ExpandedNodes.end()) { 28523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = I->second.first; 28533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = I->second.second; 28543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return; 28553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 285645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } else { 285745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner assert(!ExpandedNodes.count(Op) && "Re-expanding a node!"); 28583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 28593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 28604e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // Expanding to multiple registers needs to perform an optimization step, and 28614e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // is not careful to avoid operations the target does not support. Make sure 28624e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // that all generated operations are legalized in the next iteration. 28634e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NeedsAnotherIteration = true; 28643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 28653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 2866d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2867d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 2868d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner default: 28693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 28703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to expand this operator!"); 28713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 2872fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2873fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Lo = DAG.getNode(ISD::UNDEF, NVT); 2874fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Hi = DAG.getNode(ISD::UNDEF, NVT); 2875fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 28763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: { 28773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner uint64_t Cst = cast<ConstantSDNode>(Node)->getValue(); 28783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getConstant(Cst, NVT); 28793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT); 28803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 28813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 28823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2883d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner case ISD::BUILD_PAIR: 2884d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // Legalize both operands. FIXME: in the future we should handle the case 2885d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // where the two elements are not legal. 2886d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 2887d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Lo = LegalizeOp(Node->getOperand(0)); 2888d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Hi = LegalizeOp(Node->getOperand(1)); 2889d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner break; 2890d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner 2891edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner case ISD::CTPOP: 2892edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 28939b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner Lo = DAG.getNode(ISD::ADD, NVT, // ctpop(HL) -> ctpop(H)+ctpop(L) 28949b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Lo), 28959b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Hi)); 2896edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getConstant(0, NVT); 2897edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner break; 2898edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 289939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTLZ: { 290039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // ctlz (HL) -> ctlz(H) != 32 ? ctlz(H) : (ctlz(L)+32) 29013becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 290239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 290339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 29047cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand TopNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), HLZ, BitsC, 29057cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 290639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LowPart = DAG.getNode(ISD::CTLZ, NVT, Lo); 290739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LowPart = DAG.getNode(ISD::ADD, NVT, LowPart, BitsC); 290839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 290939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, TopNotZero, HLZ, LowPart); 291039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 291139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 291239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 291339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 291439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTTZ: { 291539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // cttz (HL) -> cttz(L) != 32 ? cttz(L) : (cttz(H)+32) 29163becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 291739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 291839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LTZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 29197cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand BotNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), LTZ, BitsC, 29207cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 292139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HiPart = DAG.getNode(ISD::CTTZ, NVT, Hi); 292239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HiPart = DAG.getNode(ISD::ADD, NVT, HiPart, BitsC); 292339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 292439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, BotNotZero, LTZ, HiPart); 292539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 292639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 292739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 2928edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 29293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: { 29303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 29313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 29322d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Lo = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 29333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Increment the pointer to the other half. 293538d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner unsigned IncrementSize = MVT::getSizeInBits(Lo.getValueType())/8; 29363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 29373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 293800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen //Is this safe? declaring that the two parts of the split load 29392d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //are from the same instruction? 29402d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Hi = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 2941ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner 2942ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Build a factor node to remember that this load is independent of the 2943ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // other one. 2944ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 2945ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi.getValue(1)); 2946edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 29473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember that we legalized the chain. 2948ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner AddLegalizedOperand(Op.getValue(1), TF); 29493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 29503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 29513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 2953d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 29543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CALL: { 29553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 29563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Callee = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 29573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29583d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 29593d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 29603d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 29613d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 29623d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 29633d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 29643d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 29653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 29663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Can only expand a call once so far, not i64 -> i16!"); 29673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 29693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(3); 29703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 29713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 29723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(MVT::Other); 2973d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Chain, Callee, Ops, 2974d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 29753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = SDOperand(NC, 0); 29763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = SDOperand(NC, 1); 29773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Insert the new chain mapping. 2979e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner AddLegalizedOperand(Op.getValue(1), Hi.getValue(2)); 29803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 29823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 29833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 29843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: { // Simple logical operators -> two trivial pieces. 29853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LL, LH, RL, RH; 29863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LL, LH); 29873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RL, RH); 29883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(Node->getOpcode(), NVT, LL, RL); 29893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(Node->getOpcode(), NVT, LH, RH); 29903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 29923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SELECT: { 29933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand C, LL, LH, RL, RH; 299447e9223e06390897c3834f8c527001df392570ffChris Lattner 299547e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 299647e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 299747e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 299847e9223e06390897c3834f8c527001df392570ffChris Lattner C = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 299947e9223e06390897c3834f8c527001df392570ffChris Lattner break; 300047e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 300147e9223e06390897c3834f8c527001df392570ffChris Lattner C = PromoteOp(Node->getOperand(0)); // Promote the condition. 300247e9223e06390897c3834f8c527001df392570ffChris Lattner break; 300347e9223e06390897c3834f8c527001df392570ffChris Lattner } 30043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), LL, LH); 30053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(2), RL, RH); 30063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, C, LL, RL); 30073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, C, LH, RH); 30083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 30093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 30109373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: { 30119373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand TL, TH, FL, FH; 30129373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(2), TL, TH); 30139373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(3), FL, FH); 30149373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Lo = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 30159373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TL, FL, Node->getOperand(4)); 30169373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Hi = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 30179373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TH, FH, Node->getOperand(4)); 3018e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Lo = LegalizeOp(Lo); 3019e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Hi = LegalizeOp(Hi); 30209373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 30219373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 302213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: { 302313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner SDOperand In; 302413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 302513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 302613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 302713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Promote: 302813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner In = PromoteOp(Node->getOperand(0)); 302913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 303013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 303113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner 303213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The low part is any extension of the input (which degenerates to a copy). 303313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Lo = DAG.getNode(ISD::ANY_EXTEND, NVT, In); 303413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The high part is undefined. 303513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); 303613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 303713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 30383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: { 303906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 304006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 304106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 304206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 304306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 304406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 304506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate sign_extend_inreg to get the value we want. 304606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), In, 304715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 304806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 304906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 305006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 30513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a sign extension of the input (which degenerates to 30523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 305306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, In); 3054edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 30553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is obtained by SRA'ing all but one of the bits of the lo 30563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // part. 30572dad454af674cb41a14a85ad6ce5c85c43959acdChris Lattner unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 305827ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 305927ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner TLI.getShiftAmountTy())); 30603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 30613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 306206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case ISD::ZERO_EXTEND: { 306306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 306406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 306506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 306606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 306706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 306806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 306906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate zero_extend_inreg to get the value we want. 307023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner In = DAG.getZeroExtendInReg(In, Node->getOperand(0).getValueType()); 307106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 307206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 307306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 30743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a zero extension of the input (which degenerates to 30753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 3076dea29e25c32d2651e2efaff67bc30803ea24d991Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, In); 3077edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 30783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is just a zero. 30793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(0, NVT); 30803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 308106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 30824e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // These operators cannot be expanded directly, emit them as calls to 30834e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // library functions. 30844e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_SINT: 308580a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_SINT, VT) == TargetLowering::Custom) { 3086f20d183c2268553c738fefb014959ea924dd0555Chris Lattner SDOperand Op; 3087f20d183c2268553c738fefb014959ea924dd0555Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 3088f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Expand: assert(0 && "cannot expand FP!"); 3089f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Legal: Op = LegalizeOp(Node->getOperand(0)); break; 3090f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Promote: Op = PromoteOp(Node->getOperand(0)); break; 3091f20d183c2268553c738fefb014959ea924dd0555Chris Lattner } 3092d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3093f20d183c2268553c738fefb014959ea924dd0555Chris Lattner Op = TLI.LowerOperation(DAG.getNode(ISD::FP_TO_SINT, VT, Op), DAG); 3094f20d183c2268553c738fefb014959ea924dd0555Chris Lattner 309580a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 309680a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 309707dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 309807dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 309907dffd6af673c73352150583150b242a93694f00Chris Lattner break; 310007dffd6af673c73352150583150b242a93694f00Chris Lattner } 310180a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3102d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 31034e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 310477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixsfdi", Node, Hi); 31054e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 310677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixdfdi", Node, Hi); 31074e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 3108d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 31094e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_UINT: 311080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_UINT, VT) == TargetLowering::Custom) { 311180a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner SDOperand Op = DAG.getNode(ISD::FP_TO_UINT, VT, 311280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner LegalizeOp(Node->getOperand(0))); 311380a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 311480a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 311507dffd6af673c73352150583150b242a93694f00Chris Lattner Op = TLI.LowerOperation(Op, DAG); 311607dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 311707dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 311807dffd6af673c73352150583150b242a93694f00Chris Lattner break; 311907dffd6af673c73352150583150b242a93694f00Chris Lattner } 312080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3121d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 31224e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 312377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunssfdi", Node, Hi); 31244e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 312577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunsdfdi", Node, Hi); 31264e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 31274e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner 3128e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SHL: 312950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 313050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SHL, VT) == TargetLowering::Custom) { 313150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SHL, VT, Node->getOperand(0), 313250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 313350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 313450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 313550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 313650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 313750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 313850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 313950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 314050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 314150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3142e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 314377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SHL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3144e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 31454759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 31464759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SHL_PARTS, use it. 3147c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SHL_PARTS, NVT)) { 31485b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SHL_PARTS, Node->getOperand(0), Node->getOperand(1), 31495b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 31504759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 31514759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 31524759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3153e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 315477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashldi3", Node, Hi); 3155e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3156e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3157e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRA: 315850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 315950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRA, VT) == TargetLowering::Custom) { 316050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRA, VT, Node->getOperand(0), 316150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 316250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 316350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 316450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 316550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 316650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 316750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 316850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 316950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 317050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3171e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 317277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRA, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3173e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 31744759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 31754759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRA_PARTS, use it. 3176c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRA_PARTS, NVT)) { 31775b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRA_PARTS, Node->getOperand(0), Node->getOperand(1), 31785b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 31794759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 31804759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 31814759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3182e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 318377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashrdi3", Node, Hi); 3184e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3185e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRL: 318650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 318750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRL, VT) == TargetLowering::Custom) { 318850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRL, VT, Node->getOperand(0), 318950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 319050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 319150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 319250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 319350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 319450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 319550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 319650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 319750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 319850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3199e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 320077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3201e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 32024759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 32034759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRL_PARTS, use it. 3204c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRL_PARTS, NVT)) { 32055b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRL_PARTS, Node->getOperand(0), Node->getOperand(1), 32065b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 32074759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 32084759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 32094759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3210e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 321177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__lshrdi3", Node, Hi); 3212e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3213e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3214edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case ISD::ADD: 32154759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::ADD_PARTS, Node->getOperand(0), Node->getOperand(1), 32164759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 321784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 321884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::SUB: 32194759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::SUB_PARTS, Node->getOperand(0), Node->getOperand(1), 32204759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 322184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 3222c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MUL: { 3223c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::MULHU, NVT)) { 3224c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman SDOperand LL, LH, RL, RH; 3225c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3226c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 322756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman unsigned SH = MVT::getSizeInBits(RH.getValueType())-1; 322856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // MULHS implicitly sign extends its inputs. Check to see if ExpandOp 322956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // extended the sign bit of the low half through the upper half, and if so 323056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // emit a MULHS instead of the alternate sequence that is valid for any 323156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // i64 x i64 multiply. 323256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman if (TLI.isOperationLegal(ISD::MULHS, NVT) && 323356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is RH an extension of the sign bit of RL? 323456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOpcode() == ISD::SRA && RH.getOperand(0) == RL && 323556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOperand(1).getOpcode() == ISD::Constant && 323656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(RH.getOperand(1))->getValue() == SH && 323756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is LH an extension of the sign bit of LL? 323856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOpcode() == ISD::SRA && LH.getOperand(0) == LL && 323956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOperand(1).getOpcode() == ISD::Constant && 324056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(LH.getOperand(1))->getValue() == SH) { 324156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHS, NVT, LL, RL); 324256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } else { 324356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 324456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 324556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 324656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 324756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 324856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } 3249c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 3250c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } else { 3251c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = ExpandLibCall("__muldi3" , Node, Hi); break; 3252c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 3253c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman break; 3254c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 325577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SDIV: Lo = ExpandLibCall("__divdi3" , Node, Hi); break; 325677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UDIV: Lo = ExpandLibCall("__udivdi3", Node, Hi); break; 325777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SREM: Lo = ExpandLibCall("__moddi3" , Node, Hi); break; 325877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UREM: Lo = ExpandLibCall("__umoddi3", Node, Hi); break; 32593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 32603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember in a map if the values will be reused later. 32623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!Node->hasOneUse()) { 32633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isNew = ExpandedNodes.insert(std::make_pair(Op, 32643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::make_pair(Lo, Hi))).second; 32653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isNew && "Value already expanded?!?"); 32663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 32673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 32683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 32713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 32729c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnervoid SelectionDAG::Legalize() { 32733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 32743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 32759c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(*this).Run(); 32763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 32773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3278