LegalizeDAG.cpp revision de202b3cda00f17ba2c047be7270b51f9585a413
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 21201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Sub = DAG.getNode(ISD::FSUB, 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; 264473a99073cc29f59809a0d5dfee11f5e9e6ad2b7Chris Lattner return DAG.getNode(ISD::FADD, 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 38132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner/// ComputeTopDownOrdering - Add the specified node to the Order list if it has 38232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner/// not been visited yet and if all of its operands have already been visited. 38332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattnerstatic void ComputeTopDownOrdering(SDNode *N, std::vector<SDNode*> &Order, 38432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::map<SDNode*, unsigned> &Visited) { 38532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner if (++Visited[N] != N->getNumOperands()) 38632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner return; // Haven't visited all operands yet 38732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 38832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner Order.push_back(N); 38932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 39032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner if (N->hasOneUse()) { // Tail recurse in common case. 39132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ComputeTopDownOrdering(*N->use_begin(), Order, Visited); 39232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner return; 39332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 39432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 39532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Now that we have N in, add anything that uses it if all of their operands 39632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // are now done. 39732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (SDNode::use_iterator UI = N->use_begin(), E = N->use_end(); UI != E;++UI) 39832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ComputeTopDownOrdering(*UI, Order, Visited); 39932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner} 40032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 4011618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 4023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 403ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // The legalize process is inherently a bottom-up recursive process (users 404ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // legalize their uses before themselves). Given infinite stack space, we 405ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // could just start legalizing on the root and traverse the whole graph. In 406ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // practice however, this causes us to run out of stack space on large basic 40732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // blocks. To avoid this problem, compute an ordering of the nodes where each 40832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // node is only legalized after all of its operands are legalized. 40932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::map<SDNode*, unsigned> Visited; 41032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::vector<SDNode*> Order; 411ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 41232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Compute ordering from all of the leaves in the graphs, those (like the 41332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // entry node) that have no operands. 41432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (SelectionDAG::allnodes_iterator I = DAG.allnodes_begin(), 41532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner E = DAG.allnodes_end(); I != E; ++I) { 416de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner if (I->getNumOperands() == 0) { 417de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner Visited[I] = 0 - 1U; 418de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner ComputeTopDownOrdering(I, Order, Visited); 419ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner } 420ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner } 421ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 422de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner assert(Order.size() == Visited.size() && 423de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner Order.size() == 424de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner (unsigned)std::distance(DAG.allnodes_begin(), DAG.allnodes_end()) && 42532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner "Error: DAG is cyclic!"); 42632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner Visited.clear(); 427ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 42832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (unsigned i = 0, e = Order.size(); i != e; ++i) { 42932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner SDNode *N = Order[i]; 43032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner switch (getTypeAction(N->getValueType(0))) { 43132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner default: assert(0 && "Bad type action!"); 43232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Legal: 43332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner LegalizeOp(SDOperand(N, 0)); 43432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 43532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Promote: 43632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner PromoteOp(SDOperand(N, 0)); 43732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 43832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Expand: { 43932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner SDOperand X, Y; 44032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ExpandOp(SDOperand(N, 0), X, Y); 44132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 44232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 44332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 44432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 44532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 44632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Finally, it's possible the root changed. Get the new root. 4473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand OldRoot = DAG.getRoot(); 44832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner assert(LegalizedNodes.count(OldRoot) && "Root didn't get legalized?"); 44932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner DAG.setRoot(LegalizedNodes[OldRoot]); 4503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandedNodes.clear(); 4523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizedNodes.clear(); 45371c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner PromotedNodes.clear(); 4543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remove dead nodes now. 45662fd269c146d9023efe32644e44cd97b88631d4fChris Lattner DAG.RemoveDeadNodes(OldRoot.Val); 4573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 4583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris LattnerSDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { 460c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Op.getValueType()) && 461e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner "Caller should expand or promote operands that are not legal!"); 46245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner SDNode *Node = Op.Val; 463e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 4643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If this operation defines any values that cannot be represented in a 465e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner // register on this target, make sure to expand or promote them. 46645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Node->getNumValues() > 1) { 46745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 46845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner switch (getTypeAction(Node->getValueType(i))) { 4693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: break; // Nothing to do. 4703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 4713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand T1, T2; 4723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Op.getValue(i), T1, T2); 4733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(LegalizedNodes.count(Op) && 4743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Expansion didn't add legal operands!"); 4753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return LegalizedNodes[Op]; 4763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 47803c8546ec57523970874917854a2fb77b1ff598eChris Lattner PromoteOp(Op.getValue(i)); 47903c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(LegalizedNodes.count(Op) && 48003c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Expansion didn't add legal operands!"); 48103c8546ec57523970874917854a2fb77b1ff598eChris Lattner return LegalizedNodes[Op]; 4823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 48545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 48645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 487e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::map<SDOperand, SDOperand>::iterator I = LegalizedNodes.find(Op); 488e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (I != LegalizedNodes.end()) return I->second; 4893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4909373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand Tmp1, Tmp2, Tmp3, Tmp4; 4913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Result = Op; 4933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 4953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 496d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getOpcode() >= ISD::BUILTIN_OP_END) { 497d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // If this is a target node, legalize it by legalizing the operands then 498d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // passing it through. 499d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<SDOperand> Ops; 500d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner bool Changed = false; 501d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 502d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 503d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Changed = Changed || Node->getOperand(i) != Ops.back(); 504d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 505d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Changed) 506d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getNumValues() == 1) 507d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Ops); 508d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner else { 509d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), 510d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Node->value_end()); 511d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 512d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 513d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner 514d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 515d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner AddLegalizedOperand(Op.getValue(i), Result.getValue(i)); 516d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner return Result.getValue(Op.ResNo); 517d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 518d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // Otherwise this is an unhandled builtin node. splat. 5193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 5203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to legalize this operator!"); 5213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 5223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EntryToken: 5233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::FrameIndex: 52432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::TargetFrameIndex: 52532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::Register: 52632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::TargetConstant: 5273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::GlobalAddress: 52803c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::ExternalSymbol: 52969a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::ConstantPool: // Nothing to do. 53032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::BasicBlock: 53132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::CONDCODE: 53232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::VALUETYPE: 53332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::SRCVALUE: 534c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getValueType(0)) && "This must be legal!"); 5353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 53608951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertSext: 53708951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertZext: 53808951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 53908951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner if (Tmp1 != Node->getOperand(0)) 54008951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 54108951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Node->getOperand(1)); 54208951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner break; 54369a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::CopyFromReg: 54469a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 54569a52155d2eff066b49dbac385113002fd9dba14Chris Lattner if (Tmp1 != Node->getOperand(0)) 546d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getCopyFromReg(Tmp1, 547d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Node->getOperand(1))->getReg(), 548d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getValueType(0)); 54913c184de29c09294ed63b01ac43e1b46c049278eChris Lattner else 55013c184de29c09294ed63b01ac43e1b46c049278eChris Lattner Result = Op.getValue(0); 55113c184de29c09294ed63b01ac43e1b46c049278eChris Lattner 55213c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // Since CopyFromReg produces two values, make sure to remember that we 55313c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // legalized both of them. 55413c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 55513c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 55613c184de29c09294ed63b01ac43e1b46c049278eChris Lattner return Result.getValue(Op.ResNo); 55718c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner case ISD::ImplicitDef: 55818c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 55918c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner if (Tmp1 != Node->getOperand(0)) 560d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::ImplicitDef, MVT::Other, 561d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp1, Node->getOperand(1)); 56218c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner break; 563fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: { 564fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman MVT::ValueType VT = Op.getValueType(); 565fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman switch (TLI.getOperationAction(ISD::UNDEF, VT)) { 566ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman default: assert(0 && "This action is not supported yet!"); 567ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Expand: 568ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Promote: 569fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman if (MVT::isInteger(VT)) 570fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstant(0, VT); 571fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else if (MVT::isFloatingPoint(VT)) 572fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstantFP(0, VT); 573fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else 574fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman assert(0 && "Unknown value type!"); 575fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 576ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Legal: 577fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 578fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 579fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 580fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 5813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: 5823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // We know we don't need to expand constants here, constants only have one 5833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // value and we check that it is fine above. 5843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: Maybe we should handle things like targets that don't support full 5863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // 32-bit immediates? 5873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 5893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 5903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 5913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 5923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 5933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 5953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Check to see if this FP immediate is already legal. 5973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isLegal = false; 5983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 5993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner E = TLI.legal_fpimm_end(); I != E; ++I) 6003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (CFP->isExactlyValue(*I)) { 6013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner isLegal = true; 6023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!isLegal) { 6063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Otherwise we need to spill the constant to memory. 6073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool Extend = false; 6083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If a FP immediate is precise when represented as a float, we put it 6103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // into the constant pool as a float, even if it's is statically typed 6113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // as a double. 6123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = CFP->getValueType(0); 6133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isDouble = VT == MVT::f64; 6143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFP *LLVMC = ConstantFP::get(isDouble ? Type::DoubleTy : 6153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Type::FloatTy, CFP->getValue()); 61699939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner if (isDouble && CFP->isExactlyValue((float)CFP->getValue()) && 61799939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // Only do this if the target has a native EXTLOAD instruction from 61899939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // f32. 619c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::EXTLOAD, MVT::f32)) { 6203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LLVMC = cast<ConstantFP>(ConstantExpr::getCast(LLVMC, Type::FloatTy)); 6213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner VT = MVT::f32; 6223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Extend = true; 6233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 624edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 6255839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy()); 626f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner if (Extend) { 6275f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 6285f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 629f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } else { 63052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, 63152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 632f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } 6333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 6343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 6353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 636040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner case ISD::TokenFactor: 637040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Node->getNumOperands() == 2) { 638040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner bool Changed = false; 639040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op0 = LegalizeOp(Node->getOperand(0)); 640040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op1 = LegalizeOp(Node->getOperand(1)); 641040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Op0 != Node->getOperand(0) || Op1 != Node->getOperand(1)) 642040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 643040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } else { 644040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner std::vector<SDOperand> Ops; 645040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner bool Changed = false; 646040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner // Legalize the operands. 647040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 648040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op = Node->getOperand(i); 649040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Ops.push_back(LegalizeOp(Op)); 650040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Changed |= Ops[i] != Op; 651040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } 652040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Changed) 653040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Ops); 654a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 655a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner break; 656a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner 65716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_START: 65816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 6593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 660128b52d3d75f4b74367de43e891cd98b5a9b5483Chris Lattner // Do not try to legalize the target-specific arguments (#1+) 66145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner Tmp2 = Node->getOperand(0); 6621aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (Tmp1 != Tmp2) 66388de6e77bfadea8962b017f372658204ab71448cChris Lattner Node->setAdjCallChain(Tmp1); 66427d404ccd1e86b7fffaf8037bf6b6dfb0b9d683bNate Begeman 66516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // Note that we do not create new CALLSEQ_DOWN/UP nodes here. These 66688de6e77bfadea8962b017f372658204ab71448cChris Lattner // nodes are treated specially and are mutated in place. This makes the dag 66788de6e77bfadea8962b017f372658204ab71448cChris Lattner // legalization process more efficient and also makes libcall insertion 66888de6e77bfadea8962b017f372658204ab71448cChris Lattner // easier. 6693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 670fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner case ISD::DYNAMIC_STACKALLOC: 671fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 672fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 673fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 674fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 675adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Tmp3 != Node->getOperand(2)) { 676adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 677adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 678adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 679adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 680adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner } else 681513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner Result = Op.getValue(0); 682fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 683fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // Since this op produces two values, make sure to remember that we 684fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // legalized both of them. 685fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 686fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 687fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner return Result.getValue(Op.ResNo); 688fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 689d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 6903d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner case ISD::CALL: { 6913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 6933d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 6943d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 6953d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 6963d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 6973d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 6983d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 6993d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 7003d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 7013d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || Changed) { 7023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 7033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(Node->getNumValues()); 7043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 705ebda942efcb86634a6581aae76a0d0c92c4a232eChris Lattner RetTyVTs.push_back(Node->getValueType(i)); 706d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Result = SDOperand(DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 707d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL), 0); 70838d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner } else { 70938d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner Result = Result.getValue(0); 7103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 71138d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // Since calls produce multiple values, make sure to remember that we 71238d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // legalized all of them. 71338d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 71438d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 71538d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner return Result.getValue(Op.ResNo); 7163d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 717c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 718c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 719c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner if (Tmp1 != Node->getOperand(0)) 720c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); 721c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 722c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner 723c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 724c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 7257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 72647e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 72747e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 72847e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 72947e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 73047e9223e06390897c3834f8c527001df392570ffChris Lattner break; 73147e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 73247e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 73347e9223e06390897c3834f8c527001df392570ffChris Lattner break; 73447e9223e06390897c3834f8c527001df392570ffChris Lattner } 7357cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 7367cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 7377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 7387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 7397cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 7407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 7417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 7427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 7437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 7447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 7457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 746550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 747550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 748550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, MVT::i1); 749550b1e59c4eb5db020766012b1406fc56833251dChris Lattner 7507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 7517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 7527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 7537cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 7547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 7577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Basic block destination (Op#2) is always legal. 7587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 7597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 7607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 7617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 7657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 7667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 767c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 7687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 7697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 7707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 7717cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 7727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 7737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, Tmp3, Node->getOperand(4)); 7747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 7787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 7797cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 7807cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 7817cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 7827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 7837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 7847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 7857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 7867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 7877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 7887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 7897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 7917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), 7927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, DAG.getConstant(0, Tmp2.getValueType()), 7937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 7947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 796c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 797411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case ISD::BRCONDTWOWAY: 798411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 799411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 800411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 801411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Legal: 802411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 803411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 804411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Promote: 805411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 806411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 807411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 808411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR 809411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // pair. 810411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { 811411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Promote: 812411e888c1b4155190c8cffe388631ee20693b309Chris Lattner default: assert(0 && "This action is not supported yet!"); 813411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Legal: 814411e888c1b4155190c8cffe388631ee20693b309Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 815411e888c1b4155190c8cffe388631ee20693b309Chris Lattner std::vector<SDOperand> Ops; 816411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp1); 817411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp2); 818411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(2)); 819411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(3)); 820411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); 821411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 822411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 823411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Expand: 8247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If BRTWOWAY_CC is legal for this target, then simply expand this node 8257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // to that. Otherwise, skip BRTWOWAY_CC and expand directly to a 8267cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // BRCOND/BR pair. 827c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::BRTWOWAY_CC, MVT::Other)) { 8287cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 8297cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 8307cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8317cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 8327cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 8347cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 8357cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 8367cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 839411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Node->getOperand(2)); 8407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(3)); 8417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 842411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 843411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 844411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 8457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BRTWOWAY_CC: 8467cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 847c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 8487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 8497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 8507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 8517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 8527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Node->getOperand(1), Tmp2, Tmp3, 8537cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 8547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 8587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 8597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 8607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 8617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If this target does not support BRTWOWAY_CC, lower it to a BRCOND/BR 8627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // pair. 8637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other)) { 8647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 8657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 8667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 8677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 8687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 8697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 8707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 8717cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 8727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 8747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 8767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 8777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 8787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8797cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8807cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 8817cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 8827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 8837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(5)); 8847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: 8893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 8912d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 8923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 8933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 89452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(Node->getValueType(0), Tmp1, Tmp2, 89552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(2)); 8968afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner else 8978afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner Result = SDOperand(Node, 0); 898edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 8998afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // Since loads produce two values, make sure to remember that we legalized 9008afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // both of them. 9018afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 9028afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 9038afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner return Result.getValue(Op.ResNo); 9043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9050f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::EXTLOAD: 9060f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::SEXTLOAD: 90701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case ISD::ZEXTLOAD: { 9080f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9090f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 9100f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 9115f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner MVT::ValueType SrcVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 91201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), SrcVT)) { 91301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner default: assert(0 && "This action is not supported yet!"); 9141c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner case TargetLowering::Promote: 9151c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); 9165f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 9175f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), MVT::i8); 9181c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // Since loads produce two values, make sure to remember that we legalized 9191c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // both of them. 9201c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 9211c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 9221c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner return Result.getValue(Op.ResNo); 923edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 92401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Legal: 92501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Tmp1 != Node->getOperand(0) || 92601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Tmp2 != Node->getOperand(1)) 9275f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 9285f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 92901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner else 93001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = SDOperand(Node, 0); 93101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner 93201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Since loads produce two values, make sure to remember that we legalized 93301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // both of them. 93401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 93501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 93601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(Op.ResNo); 93701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Expand: 9389d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth //f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 9399d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 9409d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth SDOperand Load = DAG.getLoad(SrcVT, Tmp1, Tmp2, Node->getOperand(2)); 94131559081a4285f4b7282e765aea4ec8a8e1d396cAndrew Lenharth Result = DAG.getNode(ISD::FP_EXTEND, Node->getValueType(0), Load); 9429d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (Op.ResNo) 9439d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Load.getValue(1); 9449d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Result; 9459d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 94601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(Node->getOpcode() != ISD::EXTLOAD && 94701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner "EXTLOAD should always be supported!"); 94801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 94901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // zero/sign extend inreg. 9505f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 9515f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 95223993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner SDOperand ValRes; 95323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SEXTLOAD) 95423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 95515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, DAG.getValueType(SrcVT)); 95623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner else 95723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getZeroExtendInReg(Result, SrcVT); 95801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), ValRes); 95901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 96001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Op.ResNo) 96101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(1); 96201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return ValRes; 96301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 96401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(0 && "Unreachable"); 96501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 9665dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case ISD::EXTRACT_ELEMENT: { 9675dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman MVT::ValueType OpTy = Node->getOperand(0).getValueType(); 9685dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman switch (getTypeAction(OpTy)) { 9695dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman default: 9705dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman assert(0 && "EXTRACT_ELEMENT action for type unimplemented!"); 9715dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 9725dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Legal: 9735dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) { 9745dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 1 -> Hi 9755dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::SRL, OpTy, Node->getOperand(0), 9765dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman DAG.getConstant(MVT::getSizeInBits(OpTy)/2, 9775dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman TLI.getShiftAmountTy())); 9785dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Result); 9795dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } else { 9805dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 0 -> Lo 9815dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), 9825dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Node->getOperand(0)); 9835dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 9845dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = LegalizeOp(Result); 9855dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 9865dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Expand: 9875dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // Get both the low and high parts. 9885dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 9895dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) 9905dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp2; // 1 -> Hi 9915dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman else 9925dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp1; // 0 -> Lo 9935dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 9945dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 9953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9965dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 9973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 9993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1000edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1001c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getOperand(2).getValueType()) && 1002d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner "Register type must be legal!"); 1003d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // Legalize the incoming value (must be legal). 1004d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 1005d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) 1006d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::CopyToReg, MVT::Other, Tmp1, 1007d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getOperand(1), Tmp2); 10083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 10103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 10113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 10133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 2: // ret val 10143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 10153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 10163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 10178afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 10183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 10193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 10213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 10223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 10233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Lo, Hi); 1024edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 10253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 10278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 10288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 10298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 10303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 10333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 10343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); 10353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 10373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<SDOperand> NewValues; 10383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 10393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) 10403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(i).getValueType())) { 10413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 10424e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NewValues.push_back(LegalizeOp(Node->getOperand(i))); 10433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 10453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 10463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(i), Lo, Hi); 10473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Lo); 10483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Hi); 1049edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 10503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 10528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Can't promote multiple return value yet!"); 10533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); 10553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::STORE: 10603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 10623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 10635d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 106403c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ 10655d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner if (CFP->getValueType(0) == MVT::f32) { 106600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1067cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(FloatToBits(CFP->getValue()), 1068cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i32), 1069cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 107052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 10715d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } else { 10725d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); 107300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1074cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(DoubleToBits(CFP->getValue()), 1075cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i64), 1076cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 107752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 10785d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 107984734ce8ef1a21eb347d4deca0bf32d59001f751Chris Lattner Node = Result.Val; 10805d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 10815d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner 10823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 10833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: { 10843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Val = LegalizeOp(Node->getOperand(1)); 10853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Val != Node->getOperand(1) || Tmp1 != Node->getOperand(0) || 10863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(2)) 108752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, 108852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 10893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 10903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 109203c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Truncate the value and store the result. 109303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(1)); 109403c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp3, Tmp2, 10952d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 10969fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getValueType(Node->getOperand(1).getValueType())); 109703c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 109803c8546ec57523970874917854a2fb77b1ff598eChris Lattner 10993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: 11003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 11013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 11023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 11033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 11043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 11053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1106edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Lo = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Lo, Tmp2, 1107edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1108ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner unsigned IncrementSize = MVT::getSizeInBits(Hi.getValueType())/8; 11093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::ADD, Tmp2.getValueType(), Tmp2, 11103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 11113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Tmp2.getValueType()) && 11123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Pointers must be legal!"); 11132d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Again, claiming both parts of the store came form the same Instr 1114edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Hi, Tmp2, 1115edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1116ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1117ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner break; 11183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 11193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 112095762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 112195762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 11222c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 11232c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); 112495762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 11250f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::TRUNCSTORE: 11260f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 11270f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 11280f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 11290f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 11300f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Legal: 11310f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 113213d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 113313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // The only promote case we handle is TRUNCSTORE:i1 X into 113413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // -> TRUNCSTORE:i8 (and X, 1) 113513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner if (cast<VTSDNode>(Node->getOperand(4))->getVT() == MVT::i1 && 113613d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TLI.getOperationAction(ISD::TRUNCSTORE, MVT::i1) == 113713d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TargetLowering::Promote) { 113813d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // Promote the bool to a mask then store. 113913d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp2 = DAG.getNode(ISD::AND, Tmp2.getValueType(), Tmp2, 114013d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner DAG.getConstant(1, Tmp2.getValueType())); 114113d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 114213d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Node->getOperand(3), DAG.getValueType(MVT::i8)); 114313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 114413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } else if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 114513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp3 != Node->getOperand(2)) { 114645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 11479fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner Node->getOperand(3), Node->getOperand(4)); 114813d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } 11490f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 11500f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Promote: 11510f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Expand: 11520f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(0 && "Cannot handle illegal TRUNCSTORE yet!"); 11530f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner } 11540f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 11552ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 115647e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 115747e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 115847e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 115947e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 116047e9223e06390897c3834f8c527001df392570ffChris Lattner break; 116147e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 116247e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 116347e9223e06390897c3834f8c527001df392570ffChris Lattner break; 116447e9223e06390897c3834f8c527001df392570ffChris Lattner } 11653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 11662ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 116755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 1168b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { 116955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 11709373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 11719373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 11729373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1.getOperand(0), Tmp1.getOperand(1), 11739373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 11749373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 11759373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 1176550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 1177550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 1178550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, MVT::i1); 11799373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1, 11809373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 11819373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 11829373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 11839373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 118455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 118555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 118655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 != Node->getOperand(2)) 118755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), 118855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp1, Tmp2, Tmp3); 118955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 119055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 119155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner MVT::ValueType NVT = 119255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 119355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 119455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (MVT::isInteger(Tmp2.getValueType())) { 119513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner ExtOp = ISD::ANY_EXTEND; 119655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::TRUNCATE; 119755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 119855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::FP_EXTEND; 119955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::FP_ROUND; 120055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 120155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 120255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp2 = DAG.getNode(ExtOp, NVT, Tmp2); 120355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 = DAG.getNode(ExtOp, NVT, Tmp3); 120455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 120555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2,Tmp3); 120655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(TruncOp, Node->getValueType(0), Result); 120755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 120855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 120955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 12103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12119373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 12129373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 12139373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 12149373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 1215c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(0).getValueType())) { 121623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner // Everything is legal, see if we should expand this op or something. 121723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner switch (TLI.getOperationAction(ISD::SELECT_CC, 121823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0).getValueType())) { 121923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner default: assert(0 && "This action is not supported yet!"); 122023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Custom: { 122123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner SDOperand Tmp = 122223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner TLI.LowerOperation(DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), 122323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0), 122423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(1), Tmp3, Tmp4, 1225d7050a9c50211dd215cb3c2bc28b4fb6bfa4a116Chris Lattner Node->getOperand(4)), DAG); 122623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp.Val) { 122723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = LegalizeOp(Tmp); 122823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 122923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 123023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } // FALLTHROUGH if the target can't lower this operation after all. 123123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Legal: 123223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 123323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 123423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 123523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3)) { 123623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), Tmp1, Tmp2, 123723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3, Tmp4, Node->getOperand(4)); 123823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 123923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 12409373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 12419373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 12429373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 12439373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp1 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 12449373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(0), // LHS 12459373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), // RHS 12469373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4))); 12477cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 12487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 12497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 12507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 12517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 12527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, Tmp3.getValueType(), 12537cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1.getOperand(0), Tmp1.getOperand(1), 12547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, Tmp1.getOperand(2)); 12557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 12567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getSelectCC(Tmp1, 12577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 12587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, ISD::SETNE); 12597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 12609373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 12619373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 12623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 12633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 12643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 12653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 12663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 12673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 12698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // LHS 12708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // RHS 12718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 12728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // If this is an FP compare, the operands have already been extended. 12738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(Node->getOperand(0).getValueType())) { 12748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner MVT::ValueType VT = Node->getOperand(0).getValueType(); 127571c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 12768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 12778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Otherwise, we have to insert explicit sign or zero extends. Note 12788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // that we could insert sign extends for ALL conditions, but zero extend 12798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // is cheaper on many machines (an AND instead of two shifts), so prefer 12808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // it. 12817cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 12828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner default: assert(0 && "Unknown integer comparison!"); 12838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETEQ: 12848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETNE: 12858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGE: 12868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGT: 12878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULE: 12888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULT: 12898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // ALL of these operations will work if we either sign or zero extend 12908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // the operands (including the unsigned comparisons!). Zero extend is 12918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // usually a simpler/cheaper operation, so prefer it. 129223993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 129323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 12948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 12958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGE: 12968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGT: 12978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLT: 12988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLE: 129915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 130015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 130115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 130215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 13038b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 13048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 13058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 13063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1307edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case Expand: 13083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 13093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LHSLo, LHSHi); 13103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RHSLo, RHSHi); 13117cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 13123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETEQ: 13133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETNE: 131408b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSLo == RHSHi) 131508b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 131608b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSCST->isAllOnesValue()) { 131708b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner // Comparison to -1. 131808b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Tmp1 = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 1319b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSLo; 1320edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 132108b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner } 132208b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner 13233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 13243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 13253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp2); 1326b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 13273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 13295b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 13305b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // X > -1, x < 0 13315b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Node->getOperand(1))) 13327cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner if ((cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETLT && 13335b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner CST->getValue() == 0) || // X < 0 13347cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner (cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETGT && 1335b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman (CST->isAllOnesValue()))) { // X > -1 1336b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp1 = LHSHi; 1337b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSHi; 1338b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1339b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 13405b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner 13413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: This generated code sucks. 13423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ISD::CondCode LowCC; 13437cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 13443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: assert(0 && "Unknown integer setcc!"); 13453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLT: 13463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 13473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGT: 13483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 13493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLE: 13503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 13513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGE: 13523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 13533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1354edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 13553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 13563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 13573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 13583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 13593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 13603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 13617cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp1 = DAG.getSetCC(Node->getValueType(0), LHSLo, RHSLo, LowCC); 13627cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getNode(ISD::SETCC, Node->getValueType(0), LHSHi, RHSHi, 13637cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 13647cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getSetCC(Node->getValueType(0), LHSHi, RHSHi, ISD::SETEQ); 1365b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1366b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result, Tmp1, Tmp2)); 1367b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman return Result; 13683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1370b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman 1371b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch(TLI.getOperationAction(ISD::SETCC, Node->getOperand(0).getValueType())) { 1372b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman default: 1373b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman assert(0 && "Cannot handle this action for SETCC yet!"); 1374b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 13755e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth case TargetLowering::Promote: 13765e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 13775e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Node->getOperand(2)); 13785e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth break; 1379b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Legal: 1380b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1381b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 1382b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1383b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1384b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Expand: 1385b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // Expand a setcc node into a select_cc of the same condition, lhs, and 1386b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // rhs that selects between const 1 (true) and const 0 (false). 1387b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman MVT::ValueType VT = Node->getValueType(0); 1388b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SELECT_CC, VT, Tmp1, Tmp2, 1389b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman DAG.getConstant(1, VT), DAG.getConstant(0, VT), 1390b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1391b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(Result); 1392b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1393b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 13943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1396e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMSET: 1397e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMCPY: 1398e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMMOVE: { 1399deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Chain 1400e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Pointer 1401e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner 1402e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { // memset = ubyte 1403e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner switch (getTypeAction(Node->getOperand(2).getValueType())) { 1404e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand a byte!"); 1405e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1406deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 1407e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1408e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1409deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); 1410e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1411e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1412e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } else { 1413edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Tmp3 = LegalizeOp(Node->getOperand(2)); // memcpy/move = pointer, 1414e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1415272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1416272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp4; 1417272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(3).getValueType())) { 14186814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner case Expand: { 14196814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner // Length is too big, just take the lo-part of the length. 14206814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner SDOperand HiPart; 14216814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner ExpandOp(Node->getOperand(3), HiPart, Tmp4); 14226814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner break; 14236814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner } 1424e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1425e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = LegalizeOp(Node->getOperand(3)); 1426e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1427e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1428e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = PromoteOp(Node->getOperand(3)); 1429272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1430272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner } 1431272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1432272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp5; 1433272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(4).getValueType())) { // uint 1434272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 1435272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Legal: 1436272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner Tmp5 = LegalizeOp(Node->getOperand(4)); 1437272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1438272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Promote: 1439e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp5 = PromoteOp(Node->getOperand(4)); 1440e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1441e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 144255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 144355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 144455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 144507dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 144607dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 144707dffd6af673c73352150583150b242a93694f00Chris Lattner TLI.LowerOperation(DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, 144807dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp2, Tmp3, Tmp4, Tmp5), DAG); 144907dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 145007dffd6af673c73352150583150b242a93694f00Chris Lattner Result = LegalizeOp(Tmp); 145107dffd6af673c73352150583150b242a93694f00Chris Lattner break; 145207dffd6af673c73352150583150b242a93694f00Chris Lattner } 145307dffd6af673c73352150583150b242a93694f00Chris Lattner // FALLTHROUGH if the target thinks it is legal. 145407dffd6af673c73352150583150b242a93694f00Chris Lattner } 145555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 1456e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 1457e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || 1458e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp5 != Node->getOperand(4)) { 1459e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<SDOperand> Ops; 1460e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 1461e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 1462e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 1463e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 146455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 146555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: { 1466e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Otherwise, the target does not support this operation. Lower the 1467e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // operation to an explicit libcall as appropriate. 1468e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 1469e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner const Type *IntPtrTy = TLI.getTargetData().getIntPtrType(); 1470e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1471e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 14723bfbf4ea990930d153e58e153f319408341a94feReid Spencer const char *FnName = 0; 1473e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { 1474e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1475e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Extend the ubyte argument to be an int value for the call. 1476e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Tmp3); 1477e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, Type::IntTy)); 1478e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1479e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 1480e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = "memset"; 1481e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else if (Node->getOpcode() == ISD::MEMCPY || 1482e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Node->getOpcode() == ISD::MEMMOVE) { 1483e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1484e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, IntPtrTy)); 1485e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1486e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = Node->getOpcode() == ISD::MEMMOVE ? "memmove" : "memcpy"; 1487e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else { 1488e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner assert(0 && "Unknown op!"); 1489e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 149045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 1491e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 1492adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(Tmp1, Type::VoidTy, false, CallingConv::C, false, 1493e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner DAG.getExternalSymbol(FnName, IntPtr), Args, DAG); 1494c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner Result = CallResult.second; 1495c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner NeedsAnotherIteration = true; 149655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 149755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 1498e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 1499e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner break; 1500e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 150152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 150252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::READPORT: 150352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 150452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 15056d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 15063e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 15073e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 15083e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 15093e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 15103e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 15113e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 15123e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 151352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = SDOperand(Node, 0); 151452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // Since these produce two values, make sure to remember that we legalized 151552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // both of them. 151652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 151752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 151852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner return Result.getValue(Op.ResNo); 151952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::WRITEPORT: 152052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 152152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 152252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 152352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 152452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 != Node->getOperand(2)) 152552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 152652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner break; 152752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 15286d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::READIO: 15296d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 15306d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 15316d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 15326d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 15336d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 15346d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 15356d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 15363e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 15373e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 15383e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 15393e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 15403e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 15413e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 15423e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 15436d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = SDOperand(Node, 0); 15446d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 15456d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 15466d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a load from memory. 15476d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0), 15486d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), DAG.getSrcValue(NULL)); 15496d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 15506d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 15516d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 15526d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 15536d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Since these produce two values, make sure to remember that we legalized 15546d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // both of them. 15556d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 15566d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 15576d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner return Result.getValue(Op.ResNo); 15586d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 15596d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::WRITEIO: 15606d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 15616d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 15626d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 15636d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 15646d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 15656d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1).getValueType())) { 15666d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 15676d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 15686d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 15696d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 15706d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 != Node->getOperand(2)) 15716d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 15726d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 15736d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 15746d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a store to memory. 15756d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0), 15766d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), Node->getOperand(2), 15776d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getSrcValue(NULL)); 15786d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 15796d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 15806d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 15816d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 15826d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 158384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::ADD_PARTS: 15845b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SUB_PARTS: 15855b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 15865b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 15875b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 158884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 158984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 159084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 159184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 159284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 159384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 1594e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (Changed) { 1595e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 1596e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 1597e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 15982c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 15992c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 16002c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 16012c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 16022c8086f4b9916b2d02842be5e375276023225fbaChris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 16032c8086f4b9916b2d02842be5e375276023225fbaChris Lattner return Result.getValue(Op.ResNo); 160484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 16052c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 16062c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 16073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 16083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 16093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 1610c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 1611c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 16123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 16133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 16143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 16153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 16163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 161703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 161803c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 161903c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 162001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 162101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 162201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 162301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 16243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1625f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth switch (getTypeAction(Node->getOperand(1).getValueType())) { 1626f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Expand: assert(0 && "Not possible"); 1627f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Legal: 1628f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 1629f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1630f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Promote: 1631f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the RHS. 1632f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1633f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth } 16343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 16353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 16363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 16373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1638edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1639419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case ISD::BUILD_PAIR: { 1640419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman MVT::ValueType PairTy = Node->getValueType(0); 1641419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman // TODO: handle the case where the Lo and Hi operands are not of legal type 1642419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Lo 1643419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Hi 1644419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman switch (TLI.getOperationAction(ISD::BUILD_PAIR, PairTy)) { 1645419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Legal: 1646419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1647419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = DAG.getNode(ISD::BUILD_PAIR, PairTy, Tmp1, Tmp2); 1648419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1649419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Promote: 1650419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Custom: 1651419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman assert(0 && "Cannot promote/custom this yet!"); 1652419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Expand: 1653419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, PairTy, Tmp1); 1654419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::ANY_EXTEND, PairTy, Tmp2); 1655419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::SHL, PairTy, Tmp2, 1656419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman DAG.getConstant(MVT::getSizeInBits(PairTy)/2, 1657419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman TLI.getShiftAmountTy())); 1658419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::OR, PairTy, Tmp1, Tmp2)); 1659419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1660419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 1661419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 1662419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 1663419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman 1664c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 1665c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 166601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 1667c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1668c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 1669c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1670c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Legal: 1671c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman if (Tmp1 != Node->getOperand(0) || 1672c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 != Node->getOperand(1)) 1673edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 1674c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2); 1675c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1676c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Promote: 1677c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Custom: 1678c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman assert(0 && "Cannot promote/custom handle this yet!"); 16794c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner case TargetLowering::Expand: 16804c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner if (MVT::isInteger(Node->getValueType(0))) { 16814c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner MVT::ValueType VT = Node->getValueType(0); 16824c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner unsigned Opc = (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 16834c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(Opc, VT, Tmp1, Tmp2); 16844c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::MUL, VT, Result, Tmp2); 16854c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::SUB, VT, Tmp1, Result); 16864c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner } else { 16874c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner // Floating point mod -> fmod libcall. 16884c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner const char *FnName = Node->getValueType(0) == MVT::f32 ? "fmodf":"fmod"; 16894c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner SDOperand Dummy; 16904c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = ExpandLibCall(FnName, Node, Dummy); 1691c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1692c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1693c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1694c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 16952c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 1696691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1697691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1698691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1699691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 1700691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1701691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 1702691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth if (Tmp1 != Node->getOperand(0)) 1703691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1704691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1705691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 1706691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType OVT = Tmp1.getValueType(); 1707691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 1708edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 1709edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 1710691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 1711691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 1712691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1713691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch(Node->getOpcode()) 1714691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth { 1715691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1716691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 1717691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1718691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1719691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 17207cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 17217cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), 17227cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ); 172300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 1724691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(OVT),NVT), Tmp1); 1725691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1726691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1727691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 172800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 172900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 1730691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getSizeInBits(OVT), NVT)); 1731691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1732691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1733691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1734691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1735691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Custom: 1736691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth assert(0 && "Cannot custom handle this yet!"); 1737691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 1738ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth switch(Node->getOpcode()) 1739ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth { 1740ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth case ISD::CTPOP: { 1741e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner static const uint64_t mask[6] = { 1742e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 1743e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 1744e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 1745e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner }; 1746ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth MVT::ValueType VT = Tmp1.getValueType(); 1747e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner MVT::ValueType ShVT = TLI.getShiftAmountTy(); 1748e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner unsigned len = getSizeInBits(VT); 1749e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 1750ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 1751e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp2 = DAG.getConstant(mask[i], VT); 1752e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp3 = DAG.getConstant(1ULL << i, ShVT); 175300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::ADD, VT, 1754ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, Tmp1, Tmp2), 1755ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, 1756ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3), 1757ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp2)); 1758ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1759ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Result = Tmp1; 1760ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1761ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 176257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTLZ: { 176357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina /* for now, we do this: 17645c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 1); 17655c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 2); 17665c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner ... 17675c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>16); 176800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen x = x | (x >>32); // for 64-bit input 17695c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner return popcount(~x); 177000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 17715c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner but see also: http://www.hackersdelight.org/HDcode/nlz.cc */ 17725c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 177357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina MVT::ValueType ShVT = TLI.getShiftAmountTy(); 177457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina unsigned len = getSizeInBits(VT); 177557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 177657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getConstant(1ULL << i, ShVT); 177700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::OR, VT, Tmp1, 177857ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3)); 177957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 178057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getNode(ISD::XOR, VT, Tmp1, DAG.getConstant(~0ULL, VT)); 17815c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 178218aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 178357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 178457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTTZ: { 178500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen // for now, we use: { return popcount(~x & (x - 1)); } 1786d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // unless the target has ctlz but not ctpop, in which case we use: 1787d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // { return 32 - nlz(~x & (x-1)); } 1788d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // see also http://www.hackersdelight.org/HDcode/ntz.cc 17895c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 17905c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp2 = DAG.getConstant(~0ULL, VT); 179100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp3 = DAG.getNode(ISD::AND, VT, 17925c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::XOR, VT, Tmp1, Tmp2), 17935c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::SUB, VT, Tmp1, 17945c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getConstant(1, VT))); 1795d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // If ISD::CTLZ is legal and CTPOP isn't, then do that instead 1796c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::CTPOP, VT) && 1797c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::CTLZ, VT)) { 179800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = LegalizeOp(DAG.getNode(ISD::SUB, VT, 1799d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getConstant(getSizeInBits(VT), VT), 1800d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getNode(ISD::CTLZ, VT, Tmp3))); 1801d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } else { 1802d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 1803d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } 180418aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 180557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 1806ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth default: 1807ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth assert(0 && "Cannot expand this yet!"); 1808ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1809ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1810691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1811691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1812691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 181300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 18142c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 18152c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 18162c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 1817da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 1818da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 1819da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 18202c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 18212c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 18222c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 18232c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 18242c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 18252c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 18262c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Promote: 18272c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Custom: 18282c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Cannot promote/custom handle this yet!"); 18292c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 1830f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1831f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FNEG: { 18322c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 18332c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 183401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = LegalizeOp(DAG.getNode(ISD::FSUB, Node->getValueType(0), 18352c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2, Tmp1)); 1836f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1837f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1838f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 18394af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 18404af6e0d7836126630f579b0a34f054321187f00bChris Lattner MVT::ValueType VT = Node->getValueType(0); 18414af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 18427cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, Tmp2, ISD::SETUGT); 18434af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp3 = DAG.getNode(ISD::FNEG, VT, Tmp1); 18444af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = DAG.getNode(ISD::SELECT, VT, Tmp2, Tmp1, Tmp3); 18454af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = LegalizeOp(Result); 1846f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1847f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1848f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: 1849f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: 1850f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: { 1851f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner MVT::ValueType VT = Node->getValueType(0); 1852f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner const char *FnName = 0; 1853f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1854f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: FnName = VT == MVT::f32 ? "sqrtf" : "sqrt"; break; 1855f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: FnName = VT == MVT::f32 ? "sinf" : "sin"; break; 1856f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: FnName = VT == MVT::f32 ? "cosf" : "cos"; break; 1857f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 1858f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 18592ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman SDOperand Dummy; 18602ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman Result = ExpandLibCall(FnName, Node, Dummy); 1861f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1862f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1863f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: 18644af6e0d7836126630f579b0a34f054321187f00bChris Lattner assert(0 && "Unreachable!"); 18652c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 18662c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 18672c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 18682c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 18692c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 18702c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 1871fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::SINT_TO_FP: 1872fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::UINT_TO_FP: { 1873fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP; 1874fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1875fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1876d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen switch (TLI.getOperationAction(Node->getOpcode(), 1877fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType())) { 1878fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner default: assert(0 && "Unknown operation action!"); 1879fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Expand: 18806269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = ExpandLegalINT_TO_FP(isSigned, 18816269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey LegalizeOp(Node->getOperand(0)), 18826269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Node->getValueType(0)); 1883fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 1884fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 1885fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Promote: 1886fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteLegalINT_TO_FP(LegalizeOp(Node->getOperand(0)), 1887fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), 1888fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner isSigned); 1889fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 1890fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 1891fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Legal: 1892fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1893fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1894fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 1895fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1896fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1897fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1898fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1899fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1900fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, 1901fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), Node->getOperand(0)); 1902fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1903fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1904fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (isSigned) { 1905fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1906fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 1907fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result, DAG.getValueType(Node->getOperand(0).getValueType())); 1908fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SINT_TO_FP, Op.getValueType(), Result); 1909fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } else { 1910fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1911fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getZeroExtendInReg(Result, 1912fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType()); 1913fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::UINT_TO_FP, Op.getValueType(), Result); 1914fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1915fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1916fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1917fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1918fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1919fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::TRUNCATE: 1920fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1921fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1922fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1923fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1924fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1925fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1926fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1927fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 1928fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 1929fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // Since the result is legal, we should just be able to truncate the low 1930fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // part of the source. 1931fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Tmp1); 1932fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1933fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1934fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1935fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Op.getValueType(), Result); 1936fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1937fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1938fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1939d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 1940fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_SINT: 1941fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_UINT: 1942fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1943fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1944f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1945f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner 19461618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))){ 19471618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: assert(0 && "Unknown operation action!"); 19481618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Expand: 1949d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT) { 1950d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman SDOperand True, False; 1951d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType VT = Node->getOperand(0).getValueType(); 1952d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType NVT = Node->getValueType(0); 1953d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman unsigned ShiftAmt = MVT::getSizeInBits(Node->getValueType(0))-1; 1954d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getConstantFP((double)(1ULL << ShiftAmt), VT); 1955d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp3 = DAG.getSetCC(TLI.getSetCCResultTy(), 1956d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Node->getOperand(0), Tmp2, ISD::SETLT); 1957d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman True = DAG.getNode(ISD::FP_TO_SINT, NVT, Node->getOperand(0)); 1958d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::FP_TO_SINT, NVT, 195901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getNode(ISD::FSUB, VT, Node->getOperand(0), 1960d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2)); 1961d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::XOR, NVT, False, 1962d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getConstant(1ULL << ShiftAmt, NVT)); 1963d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, NVT, Tmp3, True, False)); 19642d56e72f09337a1cab3ba199a9467c159296f3faNate Begeman return Result; 1965d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 1966d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman assert(0 && "Do not know how to expand FP_TO_SINT yet!"); 1967d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 1968d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman break; 19691618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Promote: 1970f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = PromoteLegalFP_TO_INT(Tmp1, Node->getValueType(0), 19711618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner Node->getOpcode() == ISD::FP_TO_SINT); 19721618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner AddLegalizedOperand(Op, Result); 19731618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return Result; 197407dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 197507dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 197607dffd6af673c73352150583150b242a93694f00Chris Lattner DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 197707dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp = TLI.LowerOperation(Tmp, DAG); 197807dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 197907dffd6af673c73352150583150b242a93694f00Chris Lattner AddLegalizedOperand(Op, Tmp); 198007dffd6af673c73352150583150b242a93694f00Chris Lattner NeedsAnotherIteration = true; 1981507f752f6ed28aa9f0ae680e95bfc93df4e9e2dcChris Lattner return Tmp; 198207dffd6af673c73352150583150b242a93694f00Chris Lattner } else { 198307dffd6af673c73352150583150b242a93694f00Chris Lattner // The target thinks this is legal afterall. 198407dffd6af673c73352150583150b242a93694f00Chris Lattner break; 198507dffd6af673c73352150583150b242a93694f00Chris Lattner } 198607dffd6af673c73352150583150b242a93694f00Chris Lattner } 19871618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 19881618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 19891618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 1990d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 1991fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1992fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1993fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1994fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1995fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 1996fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1997fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1998fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 1999fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2000fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2001fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2002d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 200313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 20043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 20053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 200603c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_EXTEND: 200703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_ROUND: 20083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 20093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 20103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 20113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 20123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 20133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2014b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner case Expand: 20152c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2016b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner 201703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Promote: 201803c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 201913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 202013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = PromoteOp(Node->getOperand(0)); 202113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 202213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 20231713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner case ISD::ZERO_EXTEND: 20241713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 202513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 202623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 202723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 202803c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 202903c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SIGN_EXTEND: 20301713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 203113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 20321713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 203315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 203415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 20351713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 203603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_EXTEND: 20371713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 20381713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner if (Result.getValueType() != Op.getValueType()) 20391713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner // Dynamically dead while we have only 2 FP types. 20401713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::FP_EXTEND, Op.getValueType(), Result); 20411713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 204203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_ROUND: 2043f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 2044f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2045f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 204603c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 20473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 20483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 20490f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 205023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 20510f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 205215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 205345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 205445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 205545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 205655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 205755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 205855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 205955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0)) 206055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 20615f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner DAG.getValueType(ExtraVT)); 206255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 206355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 206445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 206523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 206645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 206745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 206845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned BitsDiff = MVT::getSizeInBits(Node->getValueType(0)) - 206945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::getSizeInBits(ExtraVT); 207027ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner SDOperand ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 207145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SHL, Node->getValueType(0), 207245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 207345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SRA, Node->getValueType(0), 207445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 207545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 207645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // The only way we can lower this is to turn it into a STORETRUNC, 207745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 207845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 207945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 208045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 208145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 208245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner const Type *Ty = MVT::getTypeForValueType(ExtraVT); 208345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned TySize = (unsigned)TLI.getTargetData().getTypeSize(Ty); 208445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 208545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 2086edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman int SSFI = 208745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 208845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 208945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, DAG.getEntryNode(), 209052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(0), StackSlot, 20919fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getSrcValue(NULL), DAG.getValueType(ExtraVT)); 20925f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 20935f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result, StackSlot, DAG.getSrcValue(NULL), 20945f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner ExtraVT); 209545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 209645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 209745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 209845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = LegalizeOp(Result); 209955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 210045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 21010f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 21023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 210345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 21043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 210545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 210645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 210745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 21083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 21093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 21103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 21118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// PromoteOp - Given an operation that produces a value in an invalid type, 21128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// promote it to compute the value into a larger type. The produced value will 21138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// have the correct bits for the low portion of the register, but no guarantee 21148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// is made about the top bits: it may be zero, sign-extended, or garbage. 211503c8546ec57523970874917854a2fb77b1ff598eChris LattnerSDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) { 211603c8546ec57523970874917854a2fb77b1ff598eChris Lattner MVT::ValueType VT = Op.getValueType(); 211771c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 211803c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(getTypeAction(VT) == Promote && 211903c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Caller should expand or legalize operands that are not promotable!"); 212003c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(NVT > VT && MVT::isInteger(NVT) == MVT::isInteger(VT) && 212103c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Cannot promote to smaller type!"); 212203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 212303c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Tmp1, Tmp2, Tmp3; 212403c8546ec57523970874917854a2fb77b1ff598eChris Lattner 212503c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Result; 212603c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDNode *Node = Op.Val; 212703c8546ec57523970874917854a2fb77b1ff598eChris Lattner 21286fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op); 21296fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != PromotedNodes.end()) return I->second; 213045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 21310f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // Promotion needs an optimization step to clean up after it, and is not 21320f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // careful to avoid operations the target does not support. Make sure that 21330f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // all generated operations are legalized in the next iteration. 21340f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner NeedsAnotherIteration = true; 21350f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 213603c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 2137d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2138d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 213903c8546ec57523970874917854a2fb77b1ff598eChris Lattner default: 214003c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 214103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(0 && "Do not know how to promote this operator!"); 214203c8546ec57523970874917854a2fb77b1ff598eChris Lattner abort(); 2143fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2144fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getNode(ISD::UNDEF, NVT); 2145fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 214603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::Constant: 2147ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner if (VT != MVT::i1) 2148ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND, NVT, Op); 2149ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner else 2150ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, NVT, Op); 215103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantSDNode>(Result) && "Didn't constant fold zext?"); 215203c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 215303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::ConstantFP: 215403c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::FP_EXTEND, NVT, Op); 215503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantFPSDNode>(Result) && "Didn't constant fold fp_extend?"); 215603c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2157ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner 215882fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner case ISD::SETCC: 2159c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(TLI.getSetCCResultTy()) && "SetCC type is not legal??"); 21607cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(),Node->getOperand(0), 21617cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(1), Node->getOperand(2)); 216282fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = LegalizeOp(Result); 216382fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner break; 216403c8546ec57523970874917854a2fb77b1ff598eChris Lattner 216503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 216603c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 216703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Legal: 216803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 216903c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.getValueType() >= NVT && 217003c8546ec57523970874917854a2fb77b1ff598eChris Lattner "This truncation doesn't make sense!"); 217103c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (Result.getValueType() > NVT) // Truncate to NVT instead of VT 217203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Result); 217303c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2174e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner case Promote: 2175e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // The truncation is not required, because we don't guarantee anything 2176e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // about high bits anyway. 2177e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner Result = PromoteOp(Node->getOperand(0)); 2178e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner break; 217903c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Expand: 218079e46acd35df36477029e9f534ab1a366a98df56Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 218179e46acd35df36477029e9f534ab1a366a98df56Nate Begeman // Truncate the low part of the expanded value to the result type 2182e21c305ed85b2be4a27784ba52471f6b68fdd255Chris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Tmp1); 218303c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 218403c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 21858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SIGN_EXTEND: 21868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::ZERO_EXTEND: 218713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 21888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 21898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Smaller reg should have been promoted!"); 21908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 21918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Just do extend all the way to the larger type. 21928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 21938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 21948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 21968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Promote the reg if it's smaller. 21978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 21988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The high bits are not guaranteed to be anything. Insert an extend. 21998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND) 2200595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 220115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 220213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner else if (Node->getOpcode() == ISD::ZERO_EXTEND) 220323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 220423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 22058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 22078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_EXTEND: 22108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Case not implemented. Dynamically dead with 2 FP types!"); 22118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_ROUND: 22128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 22138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Cannot expand FP regs!"); 22148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: assert(0 && "Unreachable with 2 FP types!"); 22158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 22168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Do an FP_ROUND_INREG. 22178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 221815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 221915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 22208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 22228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SINT_TO_FP: 22258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UINT_TO_FP: 22268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 22278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 22288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 222977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 223077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 22318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 22348b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 22358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP) 22368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 223715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 223815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 22398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 224023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 224123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 224277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 224377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 22448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 224677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, NVT, 224777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOperand(0)); 224877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // Round if we cannot tolerate excess precision. 224977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (NoExcessFPPrecision) 225015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 225115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 225277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 22538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 22548b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_SINT: 22578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_UINT: 22588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 22598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 22608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 22618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 22638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input result is prerounded, so we don't have to do anything 22648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // special. 22658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 22668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 22688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "not implemented"); 22698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 2270d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // If we're promoting a UINT to a larger size, check to see if the new node 2271d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 2272d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // we can use that instead. This allows us to generate better code for 2273d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 2274d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // legal, such as PowerPC. 2275d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT && 2276c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) && 2277b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman (TLI.isOperationLegal(ISD::FP_TO_SINT, NVT) || 2278b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman TLI.getOperationAction(ISD::FP_TO_SINT, NVT)==TargetLowering::Custom)){ 2279d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(ISD::FP_TO_SINT, NVT, Tmp1); 2280d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2281d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2282d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 22838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22852c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 22862c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 22872c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 22882c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(Tmp1.getValueType() == NVT); 22892c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 22902c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NOTE: we do not have to do any extra rounding here for 22912c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NoExcessFPPrecision, because we know the input will have the appropriate 22922c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // precision, and these operations don't modify precision at all. 22932c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 22942c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 2295da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2296da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2297da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 2298da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 2299da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner assert(Tmp1.getValueType() == NVT); 2300da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2301da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner if(NoExcessFPPrecision) 230215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 230315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 2304da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner break; 2305da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner 230603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::AND: 230703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::OR: 230803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::XOR: 23090f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::ADD: 23108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SUB: 23110f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::MUL: 23120f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // The input may have strange things in the top bits of the registers, but 231301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. They may have weird bits going out, but 23140f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // that too is okay if they are integer operations. 23150f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 23160f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 23170f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 23180f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 231901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 232001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 232101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 232201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 232301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // The input may have strange things in the top bits of the registers, but 232401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. 232501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 232601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 232701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 232801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 232901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 233001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Floating point operations will give excess precision that we may not be 233101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // able to tolerate. If we DO allow excess precision, just leave it, 233201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // otherwise excise it. 23338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // FIXME: Why would we need to round FP ops more than integer ones? 23348b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Is Round(Add(Add(A,B),C)) != Round(Add(Round(Add(A,B)), C)) 233501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 233615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 233715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 23380f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 23390f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 23408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SDIV: 23418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SREM: 23428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be sign extended. 23438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 23448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 23458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(NVT)) { 234615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 234715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 234815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 234915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 23508b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 23518b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 23528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 23538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 23548b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 235515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 235615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 23578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 235801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 235901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 236001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // These operators require that their input be fp extended. 236101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 236201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 236301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 236401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 236501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 236601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 236701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 236801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getValueType(VT)); 236901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 23708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 23718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UDIV: 23728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UREM: 23738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be zero extended. 23748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 23758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 23768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(MVT::isInteger(NVT) && "Operators don't apply to FP!"); 237723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 237823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 23798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 23808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 23828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SHL: 23838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 23848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 23858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SHL, NVT, Tmp1, Tmp2); 23868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRA: 23888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly sign extended. 23898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 239015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 239115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 23928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 23938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRA, NVT, Tmp1, Tmp2); 23948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 23958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRL: 23968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly zero extended. 23978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 239823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 23998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 24008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRL, NVT, Tmp1, Tmp2); 24018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 240203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::LOAD: 240303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 240403c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2405ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Result = DAG.getExtLoad(ISD::EXTLOAD, NVT, Tmp1, Tmp2, 2406ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Node->getOperand(2), VT); 240703c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Remember that we legalized the chain. 240803c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 240903c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 24104c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::SEXTLOAD: 24114c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::ZEXTLOAD: 24124c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::EXTLOAD: 24134c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 24144c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 24158136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), NVT, Tmp1, Tmp2, 24168136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Node->getOperand(2), 24178136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner cast<VTSDNode>(Node->getOperand(3))->getVT()); 24184c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner // Remember that we legalized the chain. 24194c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 24204c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner break; 242103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SELECT: 242247e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 242347e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 242447e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 242547e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0));// Legalize the condition. 242647e9223e06390897c3834f8c527001df392570ffChris Lattner break; 242747e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 242847e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 242947e9223e06390897c3834f8c527001df392570ffChris Lattner break; 243047e9223e06390897c3834f8c527001df392570ffChris Lattner } 243103c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Legalize the op0 243203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); // Legalize the op1 243303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2, Tmp3); 243403c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 24359373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 24369373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2 = PromoteOp(Node->getOperand(2)); // True 24379373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = PromoteOp(Node->getOperand(3)); // False 24389373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 24399373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), Tmp2, Tmp3, 24409373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4)); 24419373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 2442d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 24438ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner case ISD::CALL: { 24448ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 24458ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 24468ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 24473d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 24483d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) 24493d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 24503d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 24518ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 24528ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner "Can only promote single result calls"); 24538ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner std::vector<MVT::ValueType> RetTyVTs; 24548ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.reserve(2); 24558ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(NVT); 24568ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(MVT::Other); 2457d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 2458d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 24598ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Result = SDOperand(NC, 0); 24608ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 24618ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner // Insert the new chain mapping. 24628ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 24638ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner break; 2464edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 2465fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2466fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2467fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2468fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = Node->getOperand(0); 2469fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Zero extend the argument 2470fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2471fecf095292991bdf9396fec474011446107f9813Andrew Lenharth // Perform the larger operation, then subtract if needed. 2472fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2473fecf095292991bdf9396fec474011446107f9813Andrew Lenharth switch(Node->getOpcode()) 2474fecf095292991bdf9396fec474011446107f9813Andrew Lenharth { 2475fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2476fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = Tmp1; 2477fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2478fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2479fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 2480d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 24817cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), ISD::SETEQ); 248200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 2483fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(VT),NVT), Tmp1); 2484fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2485fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2486fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 248700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 248800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 2489fecf095292991bdf9396fec474011446107f9813Andrew Lenharth getSizeInBits(VT), NVT)); 2490fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2491fecf095292991bdf9396fec474011446107f9813Andrew Lenharth } 2492fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 249303c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 249403c8546ec57523970874917854a2fb77b1ff598eChris Lattner 249503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.Val && "Didn't set a result!"); 249603c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddPromotedOperand(Op, Result); 249703c8546ec57523970874917854a2fb77b1ff598eChris Lattner return Result; 249803c8546ec57523970874917854a2fb77b1ff598eChris Lattner} 24993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 250084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// ExpandAddSub - Find a clever way to expand this add operation into 250184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// subcomponents. 25024759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattnervoid SelectionDAGLegalize:: 25034759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris LattnerExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 25044759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi) { 250584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner // Expand the subcomponents. 250684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 250784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(LHS, LHSL, LHSH); 250884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(RHS, RHSL, RHSH); 250984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 251084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 251184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSL); 251284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSH); 251384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSL); 251484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSH); 2515e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2516e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 251784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Hi = Lo.getValue(1); 251884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner} 251984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 25205b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattnervoid SelectionDAGLegalize::ExpandShiftParts(unsigned NodeOp, 25215b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand Op, SDOperand Amt, 25225b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi) { 25235b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner // Expand the subcomponents. 25245b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand LHSL, LHSH; 25255b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandOp(Op, LHSL, LHSH); 25265b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 25275b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner std::vector<SDOperand> Ops; 25285b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSL); 25295b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSH); 25305b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(Amt); 2531cc0675a4be9a5133abd48ee272ff999ae48feabfChris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2532e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 25335b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Hi = Lo.getValue(1); 25345b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner} 25355b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 25365b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 2537e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// ExpandShift - Try to find a clever way to expand this shift operation out to 2538e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// smaller elements. If we can't find a way that is more efficient than a 2539e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// libcall on this target, return false. Otherwise, return true with the 2540e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// low-parts expanded into Lo and Hi. 2541e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattnerbool SelectionDAGLegalize::ExpandShift(unsigned Opc, SDOperand Op,SDOperand Amt, 2542e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi) { 2543e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner assert((Opc == ISD::SHL || Opc == ISD::SRA || Opc == ISD::SRL) && 2544e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner "This is not a shift!"); 2545f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2546e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(Op.getValueType()); 2547f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand ShAmt = LegalizeOp(Amt); 2548f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman MVT::ValueType ShTy = ShAmt.getValueType(); 2549f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned VTBits = MVT::getSizeInBits(Op.getValueType()); 2550f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned NVTBits = MVT::getSizeInBits(NVT); 2551f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2552f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Handle the case when Amt is an immediate. Other cases are currently broken 2553f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and are disabled. 2554f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Amt.Val)) { 2555f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned Cst = CN->getValue(); 2556f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Expand the incoming operand to be shifted, so that we have its parts 2557f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand InL, InH; 2558f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman ExpandOp(Op, InL, InH); 2559f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman switch(Opc) { 2560f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SHL: 2561f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2562f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2563f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2564f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2565f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2566f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst-NVTBits,ShTy)); 2567ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2568ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = DAG.getConstant(0, NVT); 2569ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = InL; 2570f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2571f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst, ShTy)); 2572f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::OR, NVT, 2573f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(Cst, ShTy)), 2574f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(NVTBits-Cst, ShTy))); 2575f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2576f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2577f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRL: 2578f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2579f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2580f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2581f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2582f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst-NVTBits,ShTy)); 2583f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2584ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2585ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2586ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = DAG.getConstant(0, NVT); 2587f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2588f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2589f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2590f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2591f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst, ShTy)); 2592f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2593f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2594f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRA: 2595f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2596edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 2597f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2598f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2599edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Lo = DAG.getNode(ISD::SRA, NVT, InH, 2600f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(Cst-NVTBits, ShTy)); 2601edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2602f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2603ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2604ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2605edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2606ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2607f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2608f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2609f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2610f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2611f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Cst, ShTy)); 2612f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2613f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2614f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2615f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2616f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // FIXME: The following code for expanding shifts using ISD::SELECT is buggy, 2617f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // so disable it for now. Currently targets are handling this via SHL_PARTS 2618f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and friends. 2619f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return false; 2620e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2621e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we have an efficient select operation (or if the selects will all fold 2622e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // away), lower to some complex code, otherwise just emit the libcall. 2623c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::SELECT, NVT) && !isa<ConstantSDNode>(Amt)) 2624e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return false; 2625e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2626e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand InL, InH; 2627e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ExpandOp(Op, InL, InH); 2628e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand NAmt = DAG.getNode(ISD::SUB, ShTy, // NAmt = 32-ShAmt 2629e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits, ShTy), ShAmt); 2630e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2631e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner // Compare the unmasked shift amount against 32. 26327cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand Cond = DAG.getSetCC(TLI.getSetCCResultTy(), ShAmt, 26337cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(NVTBits, ShTy), ISD::SETGE); 2634e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner 2635e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getShiftAmountFlavor() != TargetLowering::Mask) { 2636e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ShAmt = DAG.getNode(ISD::AND, ShTy, ShAmt, // ShAmt &= 31 2637e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2638e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner NAmt = DAG.getNode(ISD::AND, ShTy, NAmt, // NAmt &= 31 2639e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2640e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2641e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2642e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (Opc == ISD::SHL) { 2643e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << Amt) | (Lo >> NAmt) 2644e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, ShAmt), 2645e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, NAmt)); 2646e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(ISD::SHL, NVT, InL, ShAmt); // T2 = Lo << Amt&31 2647edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2648e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2649e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, DAG.getConstant(0, NVT), T2); 2650e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } else { 265177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand HiLoPart = DAG.getNode(ISD::SELECT, NVT, 26527cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getSetCC(TLI.getSetCCResultTy(), NAmt, 26537cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(32, ShTy), 26547cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ), 265577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(0, NVT), 265677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, NAmt)); 2657e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << NAmt) | (Lo >> Amt) 265877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiLoPart, 2659e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, ShAmt)); 2660e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(Opc, NVT, InH, ShAmt); // T2 = InH >> ShAmt&31 2661e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2662e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand HiPart; 266377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Opc == ISD::SRA) 266477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiPart = DAG.getNode(ISD::SRA, NVT, InH, 266577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2666e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner else 2667e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner HiPart = DAG.getConstant(0, NVT); 2668e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2669e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, HiPart, T2); 2670e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2671e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return true; 2672e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner} 267377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 26749530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindLatestCallSeqStart - Scan up the dag to find the latest (highest 26759530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqStart operation and occurs later than 26769c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// Found. 26779530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic void FindLatestCallSeqStart(SDNode *Node, SDNode *&Found) { 26789c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->getNodeDepth() <= Found->getNodeDepth()) return; 26792f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner 268016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_START, we already know this node occurs later 26819c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 268216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) { 26839c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 26849c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 26859c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 26869c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26879c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 26889c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(Node->getNumOperands() != 0 && 26899c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner "All leaves should have depth equal to the entry node!"); 2690829cb818065673a50101435f3c25e50ca82a02bfNate Begeman for (unsigned i = 0, e = Node->getNumOperands()-1; i != e; ++i) 26919530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(i).Val, Found); 26929c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26939c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 26949530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(Node->getNumOperands()-1).Val, 26959c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found); 26969c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 26979c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26989c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26999530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindEarliestCallSeqEnd - Scan down the dag to find the earliest (lowest 27009530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqEnd operation and occurs more recent 27019c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// than Found. 270282299e70977500209c951404e354510feffb8efaChris Lattnerstatic void FindEarliestCallSeqEnd(SDNode *Node, SDNode *&Found, 270382299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> &Visited) { 270482299e70977500209c951404e354510feffb8efaChris Lattner if ((Found && Node->getNodeDepth() >= Found->getNodeDepth()) || 270582299e70977500209c951404e354510feffb8efaChris Lattner !Visited.insert(Node).second) return; 27069c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 270716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_END, we already know this node occurs earlier 27089c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 270916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) { 27109c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 27119c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 27129c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 27139c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 27149c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 27159c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end(); 27169c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (UI == E) return; 27179c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (--E; UI != E; ++UI) 271882299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 27199c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 27209c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 272182299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 27229c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 27239c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 27249530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqEnd - Given a chained node that is part of a call sequence, 272516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_END node that terminates the call sequence. 27269530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqEnd(SDNode *Node) { 272716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 27289c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return Node; 2729f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (Node->use_empty()) 27309530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return 0; // No CallSeqEnd 27319c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 27329c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand TheChain(Node, Node->getNumValues()-1); 27332789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner if (TheChain.getValueType() != MVT::Other) 27342789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner TheChain = SDOperand(Node, 0); 27351aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (TheChain.getValueType() != MVT::Other) 27361aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman return 0; 2737edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2738edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman for (SDNode::use_iterator UI = Node->use_begin(), 27392f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner E = Node->use_end(); UI != E; ++UI) { 2740edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 27419c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Make sure to only follow users of our token chain. 27429c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *User = *UI; 27439c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 27449c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (User->getOperand(i) == TheChain) 2745eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner if (SDNode *Result = FindCallSeqEnd(User)) 2746eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner return Result; 27479c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 27482f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner return 0; 27499c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 27509c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 27519530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqStart - Given a chained node that is part of a call sequence, 275216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_START node that initiates the call sequence. 27539530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqStart(SDNode *Node) { 27549530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(Node && "Didn't find callseq_start for a call??"); 275516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 27560d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 27570d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 27580d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner "Node doesn't have a token chain argument!"); 27599530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqStart(Node->getOperand(0).Val); 27600d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 27610d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 27620d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 27639c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// FindInputOutputChains - If we are replacing an operation with a call we need 27649c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// to find the call that occurs before and the call that occurs after it to 27650d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// properly serialize the calls in the block. The returned operand is the 27660d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// input chain value for the new call (e.g. the entry node or the previous 27670d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// call), and OutChain is set to be the chain node to update to point to the 27680d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// end of the call chain. 27699c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnerstatic SDOperand FindInputOutputChains(SDNode *OpNode, SDNode *&OutChain, 27709c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand Entry) { 27719530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqStart = Entry.Val; 27729530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqEnd = 0; 27739530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(OpNode, LatestCallSeqStart); 27749530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner //std::cerr<<"Found node: "; LatestCallSeqStart->dump(); std::cerr <<"\n"; 2775edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 277616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // It is possible that no ISD::CALLSEQ_START was found because there is no 2777c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman // previous call in the function. LatestCallStackDown may in that case be 277816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // the entry node itself. Do not attempt to find a matching CALLSEQ_END 277916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // unless LatestCallStackDown is an CALLSEQ_START. 27801aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (LatestCallSeqStart->getOpcode() == ISD::CALLSEQ_START) { 27819530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = FindCallSeqEnd(LatestCallSeqStart); 27821aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman //std::cerr<<"Found end node: "; LatestCallSeqEnd->dump(); std::cerr <<"\n"; 27831aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } else { 27849530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = Entry.Val; 27851aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } 27869530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(LatestCallSeqEnd && "NULL return from FindCallSeqEnd"); 2787edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 27880d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Finally, find the first call that this must come before, first we find the 27899530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // CallSeqEnd that ends the call. 27900d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain = 0; 279182299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> Visited; 279282299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(OpNode, OutChain, Visited); 27939c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 27949530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // If we found one, translate from the adj up to the callseq_start. 27950d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain) 27969530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner OutChain = FindCallSeqStart(OutChain); 27979c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 27989530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return SDOperand(LatestCallSeqEnd, 0); 27999c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 28009c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 280100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen/// SpliceCallInto - Given the result chain of a libcall (CallResult), and a 2802b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattnervoid SelectionDAGLegalize::SpliceCallInto(const SDOperand &CallResult, 2803b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SDNode *OutChain) { 28040d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Nothing to splice it into? 28050d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain == 0) return; 28060d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 28070d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(OutChain->getOperand(0).getValueType() == MVT::Other); 28080d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner //OutChain->dump(); 28090d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 28100d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Form a token factor node merging the old inval and the new inval. 28110d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InToken = DAG.getNode(ISD::TokenFactor, MVT::Other, CallResult, 28120d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->getOperand(0)); 28130d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Change the node to refer to the new token. 28140d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->setAdjCallChain(InToken); 28150d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 28169c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 28179c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 281877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 281977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 282077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 282177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 282277e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize::ExpandLibCall(const char *Name, SDNode *Node, 282377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi) { 28249c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *OutChain; 28259c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand InChain = FindInputOutputChains(Node, OutChain, 28269c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner DAG.getEntryNode()); 2827f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (InChain.Val == 0) 2828f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner InChain = DAG.getEntryNode(); 28299c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 283077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 283177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 283277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner MVT::ValueType ArgVT = Node->getOperand(i).getValueType(); 283377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(ArgVT); 283477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Node->getOperand(i), ArgTy)); 283577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 283677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(Name, TLI.getPointerTy()); 2837edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 28380d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 283977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(Node->getValueType(0)); 28400d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallInfo = 2841adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, false, 2842adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 28430d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 284499c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SDOperand Result; 28450d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner switch (getTypeAction(CallInfo.first.getValueType())) { 284677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner default: assert(0 && "Unknown thing"); 284777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Legal: 284899c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner Result = CallInfo.first; 284999c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 285077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Promote: 285177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(0 && "Cannot promote this yet!"); 285277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Expand: 285399c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner ExpandOp(CallInfo.first, Result, Hi); 285499c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner CallInfo.second = LegalizeOp(CallInfo.second); 285599c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 285677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 285799c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner 285899c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SpliceCallInto(CallInfo.second, OutChain); 285999c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner NeedsAnotherIteration = true; 286099c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner return Result; 286177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 286277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 28639c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 286477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// ExpandIntToFP - Expand a [US]INT_TO_FP operation, assuming that the 286577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// destination type is legal. 286677e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize:: 286777e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) { 2868c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(DestTy) && "Destination type is not legal!"); 286977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(Source.getValueType()) == Expand && 287077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner "This is not an expansion!"); 287177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(Source.getValueType() == MVT::i64 && "Only handle expand from i64!"); 287277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 28730d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (!isSigned) { 2874e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(Source.getValueType() == MVT::i64 && 2875e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner "This only works for 64-bit -> FP"); 2876e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 2877e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // incoming integer is set. To handle this, we dynamically test to see if 2878e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // it is set, and, if so, add a fudge factor. 2879e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Lo, Hi; 2880e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner ExpandOp(Source, Lo, Hi); 2881e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 288266de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 288366de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // signed, then adjust the result if the sign bit is set. 288466de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner SDOperand SignedConv = ExpandIntToFP(true, DestTy, 288566de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), Lo, Hi)); 288666de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 28877cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Hi, 28887cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Hi.getValueType()), 28897cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 2890e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 2891e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 2892e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SignSet, Four, Zero); 2893383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner uint64_t FF = 0x5f800000ULL; 2894383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 2895383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 2896e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 28975839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 2898e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 2899e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand FudgeInReg; 2900e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner if (DestTy == MVT::f32) 290152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 290252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 2903e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner else { 2904e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(DestTy == MVT::f64 && "Unexpected conversion"); 29055f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 29065f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 2907e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 2908473a99073cc29f59809a0d5dfee11f5e9e6ad2b7Chris Lattner return DAG.getNode(ISD::FADD, DestTy, SignedConv, FudgeInReg); 290977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 29100d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 2911a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 2912a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, Source.getValueType())) { 2913a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 2914a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Legal: 2915a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Expand: 2916a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner break; // This case is handled below. 291707dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 291807dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand NV = TLI.LowerOperation(DAG.getNode(ISD::SINT_TO_FP, DestTy, 291907dffd6af673c73352150583150b242a93694f00Chris Lattner Source), DAG); 292007dffd6af673c73352150583150b242a93694f00Chris Lattner if (NV.Val) 292107dffd6af673c73352150583150b242a93694f00Chris Lattner return LegalizeOp(NV); 292207dffd6af673c73352150583150b242a93694f00Chris Lattner break; // The target decided this was legal after all 292307dffd6af673c73352150583150b242a93694f00Chris Lattner } 2924a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 2925a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 292613689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // Expand the source, then glue it back together for the call. We must expand 292713689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // the source in case it is shared (this pass of legalize must traverse it). 292813689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner SDOperand SrcLo, SrcHi; 292913689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner ExpandOp(Source, SrcLo, SrcHi); 293013689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner Source = DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), SrcLo, SrcHi); 293113689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 29320d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDNode *OutChain = 0; 29330d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InChain = FindInputOutputChains(Source.Val, OutChain, 29340d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner DAG.getEntryNode()); 29350d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner const char *FnName = 0; 29360d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (DestTy == MVT::f32) 29370d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdisf"; 29380d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner else { 29390d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(DestTy == MVT::f64 && "Unknown fp value type!"); 29400d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdidf"; 29410d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 29420d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 294377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(FnName, TLI.getPointerTy()); 294477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 294577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 294677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(Source.getValueType()); 294744d105b7faf5672a2af61a3f0fdfed0d437d5777Chris Lattner 294877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Source, ArgTy)); 294977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 295077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // We don't care about token chains for libcalls. We just use the entry 295177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // node as our input and ignore the output chain. This allows us to place 295277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // calls wherever we need them to satisfy data dependences. 295377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(DestTy); 29540d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 29550d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 2956adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, true, 2957adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 29580d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 2959b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallResult.second, OutChain); 29600d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallResult.first; 296177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 2962edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2963e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2964e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 29653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandOp - Expand the specified SDOperand into its two component pieces 29663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo&Hi. Note that the Op MUST be an expanded type. As a result of this, the 29673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// LegalizeNodes map is filled in for any results that are not expanded, the 29683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandedNodes map is filled in for any results that are expanded, and the 29693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo/Hi values are returned. 29703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){ 29713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = Op.getValueType(); 297271c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 29733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDNode *Node = Op.Val; 29743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(VT) == Expand && "Not an expanded type!"); 29753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::isInteger(VT) && "Cannot expand FP values!"); 29763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::isInteger(NVT) && NVT < VT && 29773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand to FP value or to larger int value!"); 29783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29796fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner // See if we already expanded it. 29806fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I 29816fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner = ExpandedNodes.find(Op); 29826fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != ExpandedNodes.end()) { 29836fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Lo = I->second.first; 29846fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Hi = I->second.second; 29856fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner return; 29863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 29873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29884e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // Expanding to multiple registers needs to perform an optimization step, and 29894e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // is not careful to avoid operations the target does not support. Make sure 29904e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // that all generated operations are legalized in the next iteration. 29914e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NeedsAnotherIteration = true; 29923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 2994d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2995d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 2996d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner default: 29973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 29983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to expand this operator!"); 29993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 3000fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 3001fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Lo = DAG.getNode(ISD::UNDEF, NVT); 3002fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Hi = DAG.getNode(ISD::UNDEF, NVT); 3003fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 30043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: { 30053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner uint64_t Cst = cast<ConstantSDNode>(Node)->getValue(); 30063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getConstant(Cst, NVT); 30073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT); 30083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 30093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 30103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3011d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner case ISD::BUILD_PAIR: 3012d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // Legalize both operands. FIXME: in the future we should handle the case 3013d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // where the two elements are not legal. 3014d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 3015d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Lo = LegalizeOp(Node->getOperand(0)); 3016d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Hi = LegalizeOp(Node->getOperand(1)); 3017d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner break; 3018d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner 3019edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner case ISD::CTPOP: 3020edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 30219b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner Lo = DAG.getNode(ISD::ADD, NVT, // ctpop(HL) -> ctpop(H)+ctpop(L) 30229b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Lo), 30239b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Hi)); 3024edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getConstant(0, NVT); 3025edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner break; 3026edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 302739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTLZ: { 302839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // ctlz (HL) -> ctlz(H) != 32 ? ctlz(H) : (ctlz(L)+32) 30293becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 303039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 303139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 30327cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand TopNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), HLZ, BitsC, 30337cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 303439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LowPart = DAG.getNode(ISD::CTLZ, NVT, Lo); 303539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LowPart = DAG.getNode(ISD::ADD, NVT, LowPart, BitsC); 303639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 303739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, TopNotZero, HLZ, LowPart); 303839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 303939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 304039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 304139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 304239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTTZ: { 304339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // cttz (HL) -> cttz(L) != 32 ? cttz(L) : (cttz(H)+32) 30443becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 304539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 304639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LTZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 30477cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand BotNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), LTZ, BitsC, 30487cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 304939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HiPart = DAG.getNode(ISD::CTTZ, NVT, Hi); 305039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HiPart = DAG.getNode(ISD::ADD, NVT, HiPart, BitsC); 305139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 305239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, BotNotZero, LTZ, HiPart); 305339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 305439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 305539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 3056edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 30573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: { 30583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 30593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 30602d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Lo = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 30613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 30623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Increment the pointer to the other half. 306338d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner unsigned IncrementSize = MVT::getSizeInBits(Lo.getValueType())/8; 30643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 30653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 306600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen //Is this safe? declaring that the two parts of the split load 30672d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //are from the same instruction? 30682d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Hi = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 3069ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner 3070ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Build a factor node to remember that this load is independent of the 3071ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // other one. 3072ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 3073ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi.getValue(1)); 3074edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 30753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember that we legalized the chain. 3076ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner AddLegalizedOperand(Op.getValue(1), TF); 30773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 30783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 30793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 30803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3081d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 30823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CALL: { 30833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 30843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Callee = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 30853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 30863d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 30873d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 30883d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 30893d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 30903d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 30913d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 30923d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 30933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 30943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Can only expand a call once so far, not i64 -> i16!"); 30953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 30963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 30973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(3); 30983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 30993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 31003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(MVT::Other); 3101d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Chain, Callee, Ops, 3102d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 31033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = SDOperand(NC, 0); 31043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = SDOperand(NC, 1); 31053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 31063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Insert the new chain mapping. 3107e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner AddLegalizedOperand(Op.getValue(1), Hi.getValue(2)); 31083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 31093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 31103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 31113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 31123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: { // Simple logical operators -> two trivial pieces. 31133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LL, LH, RL, RH; 31143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LL, LH); 31153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RL, RH); 31163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(Node->getOpcode(), NVT, LL, RL); 31173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(Node->getOpcode(), NVT, LH, RH); 31183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 31193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 31203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SELECT: { 31213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand C, LL, LH, RL, RH; 312247e9223e06390897c3834f8c527001df392570ffChris Lattner 312347e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 312447e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 312547e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 312647e9223e06390897c3834f8c527001df392570ffChris Lattner C = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 312747e9223e06390897c3834f8c527001df392570ffChris Lattner break; 312847e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 312947e9223e06390897c3834f8c527001df392570ffChris Lattner C = PromoteOp(Node->getOperand(0)); // Promote the condition. 313047e9223e06390897c3834f8c527001df392570ffChris Lattner break; 313147e9223e06390897c3834f8c527001df392570ffChris Lattner } 31323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), LL, LH); 31333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(2), RL, RH); 31343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, C, LL, RL); 31353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, C, LH, RH); 31363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 31373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 31389373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: { 31399373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand TL, TH, FL, FH; 31409373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(2), TL, TH); 31419373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(3), FL, FH); 31429373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Lo = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 31439373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TL, FL, Node->getOperand(4)); 31449373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Hi = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 31459373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TH, FH, Node->getOperand(4)); 3146e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Lo = LegalizeOp(Lo); 3147e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Hi = LegalizeOp(Hi); 31489373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 31499373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 3150144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::SEXTLOAD: { 3151144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 3152144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 3153144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3154144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 3155144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 3156144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 3157144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 3158144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::SEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 3159144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 31609ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 31619ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 31629ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 31639ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 3164144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is obtained by SRA'ing all but one of the bits of the lo 3165144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // part. 3166144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 3167144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 3168144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman TLI.getShiftAmountTy())); 3169144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 3170144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = LegalizeOp(Hi); 3171144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 3172144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 3173144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::ZEXTLOAD: { 3174144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 3175144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 3176144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3177144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 3178144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 3179144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 3180144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 3181144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 3182144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 31839ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 31849ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 31859ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 31869ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 3187144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is just a zero. 31889ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getConstant(0, NVT)); 31899ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = LegalizeOp(Lo); 31909ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner break; 31919ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner } 31929ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner case ISD::EXTLOAD: { 31939ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); 31949ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 31959ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 31969ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 31979ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner if (EVT == NVT) 31989ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 31999ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner else 32009ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getExtLoad(ISD::EXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 32019ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner EVT); 32029ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 32039ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 32049ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 32059ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 32069ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // The high part is undefined. 32079ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getNode(ISD::UNDEF, NVT)); 3208144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 3209144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 3210144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 321113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: { 321213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner SDOperand In; 321313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 321413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 321513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 321613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Promote: 321713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner In = PromoteOp(Node->getOperand(0)); 321813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 321913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 322013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner 322113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The low part is any extension of the input (which degenerates to a copy). 322213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Lo = DAG.getNode(ISD::ANY_EXTEND, NVT, In); 322313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The high part is undefined. 322413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); 322513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 322613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 32273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: { 322806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 322906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 323006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 323106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 323206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 323306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 323406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate sign_extend_inreg to get the value we want. 323506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), In, 323615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 323706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 323806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 323906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 32403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a sign extension of the input (which degenerates to 32413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 324206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, In); 3243edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 32443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is obtained by SRA'ing all but one of the bits of the lo 32453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // part. 32462dad454af674cb41a14a85ad6ce5c85c43959acdChris Lattner unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 324727ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 324827ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner TLI.getShiftAmountTy())); 32493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 32503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 325106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case ISD::ZERO_EXTEND: { 325206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 325306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 325406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 325506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 325606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 325706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 325806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate zero_extend_inreg to get the value we want. 325923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner In = DAG.getZeroExtendInReg(In, Node->getOperand(0).getValueType()); 326006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 326106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 326206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 32633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a zero extension of the input (which degenerates to 32643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 3265dea29e25c32d2651e2efaff67bc30803ea24d991Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, In); 3266edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 32673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is just a zero. 32683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(0, NVT); 32693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 327006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 32714e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // These operators cannot be expanded directly, emit them as calls to 32724e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // library functions. 32734e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_SINT: 327480a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_SINT, VT) == TargetLowering::Custom) { 3275f20d183c2268553c738fefb014959ea924dd0555Chris Lattner SDOperand Op; 3276f20d183c2268553c738fefb014959ea924dd0555Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 3277f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Expand: assert(0 && "cannot expand FP!"); 3278f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Legal: Op = LegalizeOp(Node->getOperand(0)); break; 3279f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Promote: Op = PromoteOp(Node->getOperand(0)); break; 3280f20d183c2268553c738fefb014959ea924dd0555Chris Lattner } 3281d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3282f20d183c2268553c738fefb014959ea924dd0555Chris Lattner Op = TLI.LowerOperation(DAG.getNode(ISD::FP_TO_SINT, VT, Op), DAG); 3283f20d183c2268553c738fefb014959ea924dd0555Chris Lattner 328480a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 328580a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 328607dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 328707dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 328807dffd6af673c73352150583150b242a93694f00Chris Lattner break; 328907dffd6af673c73352150583150b242a93694f00Chris Lattner } 329080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3291d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 32924e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 329377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixsfdi", Node, Hi); 32944e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 329577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixdfdi", Node, Hi); 32964e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 3297d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 32984e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_UINT: 329980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_UINT, VT) == TargetLowering::Custom) { 330080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner SDOperand Op = DAG.getNode(ISD::FP_TO_UINT, VT, 330180a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner LegalizeOp(Node->getOperand(0))); 330280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 330380a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 330407dffd6af673c73352150583150b242a93694f00Chris Lattner Op = TLI.LowerOperation(Op, DAG); 330507dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 330607dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 330707dffd6af673c73352150583150b242a93694f00Chris Lattner break; 330807dffd6af673c73352150583150b242a93694f00Chris Lattner } 330980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3310d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 33114e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 331277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunssfdi", Node, Hi); 33134e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 331477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunsdfdi", Node, Hi); 33154e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 33164e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner 3317e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SHL: 331850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 331950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SHL, VT) == TargetLowering::Custom) { 332050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SHL, VT, Node->getOperand(0), 332150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 332250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 332350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 332450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 332550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 332650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 332750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 332850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 332950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 333050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3331e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 333277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SHL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3333e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 33344759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 33354759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SHL_PARTS, use it. 3336c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SHL_PARTS, NVT)) { 33375b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SHL_PARTS, Node->getOperand(0), Node->getOperand(1), 33385b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 33394759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 33404759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 33414759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3342e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 334377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashldi3", Node, Hi); 3344e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3345e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3346e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRA: 334750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 334850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRA, VT) == TargetLowering::Custom) { 334950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRA, VT, Node->getOperand(0), 335050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 335150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 335250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 335350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 335450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 335550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 335650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 335750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 335850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 335950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3360e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 336177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRA, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3362e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 33634759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 33644759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRA_PARTS, use it. 3365c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRA_PARTS, NVT)) { 33665b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRA_PARTS, Node->getOperand(0), Node->getOperand(1), 33675b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 33684759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 33694759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 33704759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3371e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 337277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashrdi3", Node, Hi); 3373e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3374e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRL: 337550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 337650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRL, VT) == TargetLowering::Custom) { 337750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRL, VT, Node->getOperand(0), 337850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 337950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 338050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 338150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 338250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 338350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 338450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 338550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 338650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 338750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3388e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 338977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3390e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 33914759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 33924759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRL_PARTS, use it. 3393c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRL_PARTS, NVT)) { 33945b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRL_PARTS, Node->getOperand(0), Node->getOperand(1), 33955b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 33964759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 33974759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 33984759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3399e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 340077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__lshrdi3", Node, Hi); 3401e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3402e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3403edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case ISD::ADD: 34044759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::ADD_PARTS, Node->getOperand(0), Node->getOperand(1), 34054759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 340684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 340784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::SUB: 34084759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::SUB_PARTS, Node->getOperand(0), Node->getOperand(1), 34094759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 341084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 3411c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MUL: { 3412c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::MULHU, NVT)) { 3413c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman SDOperand LL, LH, RL, RH; 3414c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3415c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 341656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman unsigned SH = MVT::getSizeInBits(RH.getValueType())-1; 341756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // MULHS implicitly sign extends its inputs. Check to see if ExpandOp 341856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // extended the sign bit of the low half through the upper half, and if so 341956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // emit a MULHS instead of the alternate sequence that is valid for any 342056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // i64 x i64 multiply. 342156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman if (TLI.isOperationLegal(ISD::MULHS, NVT) && 342256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is RH an extension of the sign bit of RL? 342356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOpcode() == ISD::SRA && RH.getOperand(0) == RL && 342456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOperand(1).getOpcode() == ISD::Constant && 342556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(RH.getOperand(1))->getValue() == SH && 342656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is LH an extension of the sign bit of LL? 342756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOpcode() == ISD::SRA && LH.getOperand(0) == LL && 342856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOperand(1).getOpcode() == ISD::Constant && 342956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(LH.getOperand(1))->getValue() == SH) { 343056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHS, NVT, LL, RL); 343156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } else { 343256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 343356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 343456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 343556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 343656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 343756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } 3438c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 3439c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } else { 3440c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = ExpandLibCall("__muldi3" , Node, Hi); break; 3441c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 3442c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman break; 3443c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 344477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SDIV: Lo = ExpandLibCall("__divdi3" , Node, Hi); break; 344577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UDIV: Lo = ExpandLibCall("__udivdi3", Node, Hi); break; 344677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SREM: Lo = ExpandLibCall("__moddi3" , Node, Hi); break; 344777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UREM: Lo = ExpandLibCall("__umoddi3", Node, Hi); break; 34483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 34493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 34503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember in a map if the values will be reused later. 34516fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner bool isNew = ExpandedNodes.insert(std::make_pair(Op, 34526fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::make_pair(Lo, Hi))).second; 34536fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner assert(isNew && "Value already expanded?!?"); 34543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 34553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 34563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 34573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 34583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 34599c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnervoid SelectionDAG::Legalize() { 34603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 34613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 34629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(*this).Run(); 34633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 34643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3465