LegalizeDAG.cpp revision 50ec8979047065bd0ff41fac4ffd44f744b77723
13e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===-- LegalizeDAG.cpp - Implement SelectionDAG::Legalize ----------------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 33e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// The LLVM Compiler Infrastructure 43e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 53e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file was developed by the LLVM research group and is distributed under 63e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 83e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 93e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file implements the SelectionDAG::Legalize method. 113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/MachineFunction.h" 1645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 1702659d23637f69f90640bfa3e66919517103c57aJim Laskey#include "llvm/Support/MathExtras.h" 183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Target/TargetLowering.h" 19e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner#include "llvm/Target/TargetData.h" 200f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner#include "llvm/Target/TargetOptions.h" 21adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Constants.h" 233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include <iostream> 2482299e70977500209c951404e354510feffb8efaChris Lattner#include <set> 253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerusing namespace llvm; 263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// SelectionDAGLegalize - This takes an arbitrary SelectionDAG as input and 293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// hacks on it until the target machine can handle it. This involves 303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating value sizes the machine cannot handle (promoting small sizes to 313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// large sizes or splitting up large values into small values) as well as 323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating operations the machine cannot handle. 333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// This code also does a small amount of optimization and recognition of idioms 353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// as part of its processing. For example, if a target does not support a 363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 'setcc' instruction efficiently, but does support 'brcc' instruction, this 373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// will attempt merge setcc and brc instructions into brcc's. 383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnernamespace { 403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerclass SelectionDAGLegalize { 413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner TargetLowering &TLI; 423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SelectionDAG &DAG; 433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizeAction - This enum indicates what action we should take for each 453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type the can occur in the program. 463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner enum LegalizeAction { 473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Legal, // The target natively supports this value type. 483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Promote, // This should be promoted to the next larger type. 493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Expand, // This integer type should be broken into smaller pieces. 503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner }; 513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ValueTypeActions - This is a bitvector that contains two bits for each 533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type, where the two bits correspond to the LegalizeAction enum. 543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// This can be queried with "getTypeAction(VT)". 553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner unsigned ValueTypeActions; 563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// NeedsAnotherIteration - This is set when we expand a large integer 583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// operation into smaller integer operations, but the smaller operations are 593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// not set. This occurs only rarely in practice, for targets that don't have 603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 32-bit or larger integer registers. 613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool NeedsAnotherIteration; 623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizedNodes - For nodes that are of legal width, and that have more 643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates what regularized operand to use. This 653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// allows us to avoid legalizing the same thing more than once. 663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, SDOperand> LegalizedNodes; 673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6803c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// PromotedNodes - For nodes that are below legal width, and that have more 6903c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// than one use, this map indicates what promoted value to use. This allows 7003c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// us to avoid promoting the same thing more than once. 7103c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::map<SDOperand, SDOperand> PromotedNodes; 7203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ExpandedNodes - For nodes that need to be expanded, and which have more 743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates which which operands are the expanded 753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// version of the input. This allows us to avoid expanding the same node 763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// more than once. 773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> > ExpandedNodes; 783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 798afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner void AddLegalizedOperand(SDOperand From, SDOperand To) { 808afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner bool isNew = LegalizedNodes.insert(std::make_pair(From, To)).second; 818afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner assert(isNew && "Got into the map somehow?"); 828afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner } 8303c8546ec57523970874917854a2fb77b1ff598eChris Lattner void AddPromotedOperand(SDOperand From, SDOperand To) { 8403c8546ec57523970874917854a2fb77b1ff598eChris Lattner bool isNew = PromotedNodes.insert(std::make_pair(From, To)).second; 8503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isNew && "Got into the map somehow?"); 8603c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 878afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner 883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerpublic: 893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 909c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(SelectionDAG &DAG); 913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Run - While there is still lowering to do, perform a pass over the DAG. 933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Most regularization can be done in a single pass, but targets that require 943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// large values to be split into registers multiple times (e.g. i64 -> 4x 953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// i16) require iteration for these values (the first iteration will demote 963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// to i32, the second will demote to i16). 973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void Run() { 983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner do { 993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NeedsAnotherIteration = false; 1003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeDAG(); 1013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } while (NeedsAnotherIteration); 1023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// getTypeAction - Return how we should legalize values of this type, either 1053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// it is already legal or we need to expand it into multiple registers of 1063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// smaller integer type, or we need to promote it to a larger type. 1073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeAction getTypeAction(MVT::ValueType VT) const { 1083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return (LegalizeAction)((ValueTypeActions >> (2*VT)) & 3); 1093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// isTypeLegal - Return true if this type is legal on this target. 1123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 1133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isTypeLegal(MVT::ValueType VT) const { 1143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return getTypeAction(VT) == Legal; 1153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerprivate: 1183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void LegalizeDAG(); 1193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LegalizeOp(SDOperand O); 1213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void ExpandOp(SDOperand O, SDOperand &Lo, SDOperand &Hi); 12203c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand PromoteOp(SDOperand O); 1233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandLibCall(const char *Name, SDNode *Node, 12577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi); 12677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandIntToFP(bool isSigned, MVT::ValueType DestTy, 12777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Source); 128cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 1296269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand ExpandLegalINT_TO_FP(bool isSigned, 1306269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand LegalOp, 1316269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT); 1325a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman SDOperand PromoteLegalINT_TO_FP(SDOperand LegalOp, MVT::ValueType DestVT, 1335a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned); 1341618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner SDOperand PromoteLegalFP_TO_INT(SDOperand LegalOp, MVT::ValueType DestVT, 1351618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned); 13600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 137e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner bool ExpandShift(unsigned Opc, SDOperand Op, SDOperand Amt, 138e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi); 1395b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandShiftParts(unsigned NodeOp, SDOperand Op, SDOperand Amt, 1405b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi); 1415b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 1424759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi); 143e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 144b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner void SpliceCallInto(const SDOperand &CallResult, SDNode *OutChain); 145b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 1463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 1473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 1483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner}; 1503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris LattnerSelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag) 1549c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner : TLI(dag.getTargetLoweringInfo()), DAG(dag), 1559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner ValueTypeActions(TLI.getValueTypeActions()) { 1563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::LAST_VALUETYPE <= 16 && 1573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Too many value types for ValueTypeActions to hold!"); 1583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1606269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// ExpandLegalINT_TO_FP - This function is responsible for legalizing a 1616269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// INT_TO_FP operation of the specified operand when the target requests that 162cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we expand it. At this point, we know that the result and operand types are 163cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target. 1646269ed125fc492d81dc5e3f48482816fc9d47f49Jim LaskeySDOperand SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned, 1656269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0, 1666269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT) { 1676269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (Op0.getValueType() == MVT::i32) { 1686269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // simple 32-bit [signed|unsigned] integer to float/double expansion 1696269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey 1706269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get the stack frame index of a 8 byte buffer 1716269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MachineFunction &MF = DAG.getMachineFunction(); 1726269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey int SSFI = MF.getFrameInfo()->CreateStackObject(8, 8); 1736269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get address of 8 byte buffer 1746269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 1756269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // word offset constant for Hi/Lo address computation 1766269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy()); 1776269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // set up Hi and Lo (into buffer) address based on endian 1786269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Hi, Lo; 1796269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (TLI.isLittleEndian()) { 1806269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1816269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = StackSlot; 1826269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 1836269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = StackSlot; 1846269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1856269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 1866269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if signed map to unsigned space 1876269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0Mapped; 1886269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (isSigned) { 1896269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // constant used to invert sign bit (signed to unsigned mapping) 1906269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand SignBit = DAG.getConstant(0x80000000u, MVT::i32); 1916269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = DAG.getNode(ISD::XOR, MVT::i32, Op0, SignBit); 1926269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 1936269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = Op0; 1946269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 1956269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the lo of the constructed double - based on integer input 1966269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store1 = DAG.getNode(ISD::STORE, MVT::Other, DAG.getEntryNode(), 1976269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped, Lo, DAG.getSrcValue(NULL)); 1986269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // initial hi portion of constructed double 1996269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand InitialHi = DAG.getConstant(0x43300000u, MVT::i32); 2006269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the hi of the constructed double - biased exponent 2016269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store2 = DAG.getNode(ISD::STORE, MVT::Other, Store1, 2026269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey InitialHi, Hi, DAG.getSrcValue(NULL)); 2036269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // load the constructed double 2046269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Load = DAG.getLoad(MVT::f64, Store2, StackSlot, 2056269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey DAG.getSrcValue(NULL)); 2066269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // FP constant to bias correct the final result 20702659d23637f69f90640bfa3e66919517103c57aJim Laskey SDOperand Bias = DAG.getConstantFP(isSigned ? 20802659d23637f69f90640bfa3e66919517103c57aJim Laskey BitsToDouble(0x4330000080000000ULL) 20902659d23637f69f90640bfa3e66919517103c57aJim Laskey : BitsToDouble(0x4330000000000000ULL), 2106269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::f64); 2116269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // subtract the bias 2126269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Sub = DAG.getNode(ISD::SUB, MVT::f64, Load, Bias); 2136269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // final result 2146269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Result; 2156269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // handle final rounding 2166269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (DestVT == MVT::f64) { 2176269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // do nothing 2186269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = Sub; 2196269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 2206269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if f32 then cast to f32 2216269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = DAG.getNode(ISD::FP_ROUND, MVT::f32, Sub); 2226269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2236269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey NeedsAnotherIteration = true; 2246269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey return Result; 2256269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2266269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey assert(!isSigned && "Legalize cannot Expand SINT_TO_FP for i64 yet"); 227cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Tmp1 = DAG.getNode(ISD::SINT_TO_FP, DestVT, Op0); 22800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2297cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Op0, 2307cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Op0.getValueType()), 2317cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 232cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 233cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 234cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SignSet, Four, Zero); 23500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2366269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // If the sign bit of the integer is set, the large number will be treated 2376269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // as a negative number. To counteract this, the dynamic code adds an 2386269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // offset depending on the data type. 239f4d32726e622c740b4befc803e604903eb1349dfChris Lattner uint64_t FF; 240f4d32726e622c740b4befc803e604903eb1349dfChris Lattner switch (Op0.getValueType()) { 241f4d32726e622c740b4befc803e604903eb1349dfChris Lattner default: assert(0 && "Unsupported integer type!"); 242f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i8 : FF = 0x43800000ULL; break; // 2^8 (as a float) 243f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i16: FF = 0x47800000ULL; break; // 2^16 (as a float) 244f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i32: FF = 0x4F800000ULL; break; // 2^32 (as a float) 245f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i64: FF = 0x5F800000ULL; break; // 2^64 (as a float) 246f4d32726e622c740b4befc803e604903eb1349dfChris Lattner } 247cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 248cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 24900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2505839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 251cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 252cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand FudgeInReg; 253cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (DestVT == MVT::f32) 254cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 255cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL)); 256cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner else { 257cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(DestVT == MVT::f64 && "Unexpected conversion"); 258cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = LegalizeOp(DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, 259cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getEntryNode(), CPIdx, 260cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL), MVT::f32)); 261cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 26200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 263cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NeedsAnotherIteration = true; 264cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner return DAG.getNode(ISD::ADD, DestVT, Tmp1, FudgeInReg); 265cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 266cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 267149c58ce0b94e64faf3c4ccdbf894061cf7d66e1Chris Lattner/// PromoteLegalINT_TO_FP - This function is responsible for legalizing a 2681618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// *INT_TO_FP operation of the specified operand when the target requests that 269cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we promote it. At this point, we know that the result and operand types are 270cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target, and that there is a legal UINT_TO_FP or SINT_TO_FP 271cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// operation that takes a larger input. 2725a8441ea3fc145393d6274156bd05c4a006099eaNate BegemanSDOperand SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDOperand LegalOp, 2735a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman MVT::ValueType DestVT, 2745a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned) { 275cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // First step, figure out the appropriate *INT_TO_FP operation to use. 276cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner MVT::ValueType NewInTy = LegalOp.getValueType(); 27700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 278cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner unsigned OpToUse = 0; 27900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 280cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Scan for the appropriate larger type to use. 281cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner while (1) { 282cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NewInTy = (MVT::ValueType)(NewInTy+1); 283cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(MVT::isInteger(NewInTy) && "Ran out of possibilities!"); 28400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 285cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports SINT_TO_FP of this type, use it. 286cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, NewInTy)) { 287cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 288cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 289c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewInTy)) 290cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 291cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 292cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 293cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::SINT_TO_FP; 294cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 295cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 296cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 2975a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman if (isSigned) continue; 29800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 299cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports UINT_TO_FP of this type, use it. 300cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::UINT_TO_FP, NewInTy)) { 301cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 302cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 303c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewInTy)) 304cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 305cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 306cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 307cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::UINT_TO_FP; 308cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 309cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 310cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 31100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 312cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Otherwise, try a larger type. 313cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 314cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 315cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Make sure to legalize any nodes we create here in the next pass. 316cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NeedsAnotherIteration = true; 31700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 318cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Okay, we found the operation and type to use. Zero extend our input to the 319cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // desired type then run the operation on it. 320cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner return DAG.getNode(OpToUse, DestVT, 3215a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, 3225a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman NewInTy, LegalOp)); 323cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 324cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 3251618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// PromoteLegalFP_TO_INT - This function is responsible for legalizing a 3261618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// FP_TO_*INT operation of the specified operand when the target requests that 3271618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// we promote it. At this point, we know that the result and operand types are 3281618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// legal for the target, and that there is a legal FP_TO_UINT or FP_TO_SINT 3291618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// operation that returns a larger result. 3301618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris LattnerSDOperand SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDOperand LegalOp, 3311618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType DestVT, 3321618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned) { 3331618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // First step, figure out the appropriate FP_TO*INT operation to use. 3341618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType NewOutTy = DestVT; 335d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3361618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner unsigned OpToUse = 0; 337d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3381618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Scan for the appropriate larger type to use. 3391618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner while (1) { 3401618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NewOutTy = (MVT::ValueType)(NewOutTy+1); 3411618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner assert(MVT::isInteger(NewOutTy) && "Ran out of possibilities!"); 342d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3431618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_SINT returning this type, use it. 3441618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_SINT, NewOutTy)) { 3451618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3461618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 347c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewOutTy)) 3481618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3491618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3501618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3511618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_SINT; 3521618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3531618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3541618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 355d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3561618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_UINT of this type, use it. 3571618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_UINT, NewOutTy)) { 3581618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3591618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 360c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewOutTy)) 3611618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3621618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3631618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3641618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_UINT; 3651618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3661618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3671618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 368d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3691618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Otherwise, try a larger type. 3701618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 371d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3721618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Make sure to legalize any nodes we create here in the next pass. 3731618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NeedsAnotherIteration = true; 374d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3751618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Okay, we found the operation and type to use. Truncate the result of the 3761618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // extended FP_TO_*INT operation to the desired size. 3771618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return DAG.getNode(ISD::TRUNCATE, DestVT, 3781618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner DAG.getNode(OpToUse, NewOutTy, LegalOp)); 3791618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner} 3801618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 3811618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 3823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 3833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand OldRoot = DAG.getRoot(); 3843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand NewRoot = LegalizeOp(OldRoot); 3853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner DAG.setRoot(NewRoot); 3863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandedNodes.clear(); 3883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizedNodes.clear(); 38971c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner PromotedNodes.clear(); 3903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remove dead nodes now. 39262fd269c146d9023efe32644e44cd97b88631d4fChris Lattner DAG.RemoveDeadNodes(OldRoot.Val); 3933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 3943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris LattnerSDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { 396c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Op.getValueType()) && 397e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner "Caller should expand or promote operands that are not legal!"); 39845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner SDNode *Node = Op.Val; 399e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 4003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If this operation defines any values that cannot be represented in a 401e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner // register on this target, make sure to expand or promote them. 40245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Node->getNumValues() > 1) { 40345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 40445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner switch (getTypeAction(Node->getValueType(i))) { 4053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: break; // Nothing to do. 4063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 4073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand T1, T2; 4083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Op.getValue(i), T1, T2); 4093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(LegalizedNodes.count(Op) && 4103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Expansion didn't add legal operands!"); 4113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return LegalizedNodes[Op]; 4123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 41403c8546ec57523970874917854a2fb77b1ff598eChris Lattner PromoteOp(Op.getValue(i)); 41503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(LegalizedNodes.count(Op) && 41603c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Expansion didn't add legal operands!"); 41703c8546ec57523970874917854a2fb77b1ff598eChris Lattner return LegalizedNodes[Op]; 4183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 42145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 42245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 423e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::map<SDOperand, SDOperand>::iterator I = LegalizedNodes.find(Op); 424e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (I != LegalizedNodes.end()) return I->second; 4253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4269373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand Tmp1, Tmp2, Tmp3, Tmp4; 4273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Result = Op; 4293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 4313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 432d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getOpcode() >= ISD::BUILTIN_OP_END) { 433d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // If this is a target node, legalize it by legalizing the operands then 434d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // passing it through. 435d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<SDOperand> Ops; 436d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner bool Changed = false; 437d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 438d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 439d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Changed = Changed || Node->getOperand(i) != Ops.back(); 440d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 441d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Changed) 442d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getNumValues() == 1) 443d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Ops); 444d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner else { 445d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), 446d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Node->value_end()); 447d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 448d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 449d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner 450d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 451d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner AddLegalizedOperand(Op.getValue(i), Result.getValue(i)); 452d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner return Result.getValue(Op.ResNo); 453d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 454d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // Otherwise this is an unhandled builtin node. splat. 4553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 4563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to legalize this operator!"); 4573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 4583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EntryToken: 45956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman case ISD::AssertSext: 46056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman case ISD::AssertZext: 4613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::FrameIndex: 4623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::GlobalAddress: 46303c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::ExternalSymbol: 46469a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::ConstantPool: // Nothing to do. 465c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getValueType(0)) && "This must be legal!"); 4663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 46769a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::CopyFromReg: 46869a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 46969a52155d2eff066b49dbac385113002fd9dba14Chris Lattner if (Tmp1 != Node->getOperand(0)) 470d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getCopyFromReg(Tmp1, 471d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Node->getOperand(1))->getReg(), 472d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getValueType(0)); 47313c184de29c09294ed63b01ac43e1b46c049278eChris Lattner else 47413c184de29c09294ed63b01ac43e1b46c049278eChris Lattner Result = Op.getValue(0); 47513c184de29c09294ed63b01ac43e1b46c049278eChris Lattner 47613c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // Since CopyFromReg produces two values, make sure to remember that we 47713c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // legalized both of them. 47813c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 47913c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 48013c184de29c09294ed63b01ac43e1b46c049278eChris Lattner return Result.getValue(Op.ResNo); 48118c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner case ISD::ImplicitDef: 48218c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 48318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner if (Tmp1 != Node->getOperand(0)) 484d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::ImplicitDef, MVT::Other, 485d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp1, Node->getOperand(1)); 48618c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner break; 487fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: { 488fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman MVT::ValueType VT = Op.getValueType(); 489fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman switch (TLI.getOperationAction(ISD::UNDEF, VT)) { 490ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman default: assert(0 && "This action is not supported yet!"); 491ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Expand: 492ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Promote: 493fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman if (MVT::isInteger(VT)) 494fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstant(0, VT); 495fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else if (MVT::isFloatingPoint(VT)) 496fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstantFP(0, VT); 497fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else 498fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman assert(0 && "Unknown value type!"); 499fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 500ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Legal: 501fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 502fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 503fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 504fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 5053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: 5063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // We know we don't need to expand constants here, constants only have one 5073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // value and we check that it is fine above. 5083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: Maybe we should handle things like targets that don't support full 5103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // 32-bit immediates? 5113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 5133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 5143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 5153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 5163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 5173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 5193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Check to see if this FP immediate is already legal. 5213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isLegal = false; 5223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 5233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner E = TLI.legal_fpimm_end(); I != E; ++I) 5243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (CFP->isExactlyValue(*I)) { 5253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner isLegal = true; 5263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!isLegal) { 5303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Otherwise we need to spill the constant to memory. 5313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool Extend = false; 5323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If a FP immediate is precise when represented as a float, we put it 5343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // into the constant pool as a float, even if it's is statically typed 5353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // as a double. 5363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = CFP->getValueType(0); 5373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isDouble = VT == MVT::f64; 5383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFP *LLVMC = ConstantFP::get(isDouble ? Type::DoubleTy : 5393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Type::FloatTy, CFP->getValue()); 54099939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner if (isDouble && CFP->isExactlyValue((float)CFP->getValue()) && 54199939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // Only do this if the target has a native EXTLOAD instruction from 54299939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // f32. 543c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::EXTLOAD, MVT::f32)) { 5443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LLVMC = cast<ConstantFP>(ConstantExpr::getCast(LLVMC, Type::FloatTy)); 5453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner VT = MVT::f32; 5463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Extend = true; 5473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 548edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 5495839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy()); 550f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner if (Extend) { 5515f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 5525f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 553f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } else { 55452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, 55552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 556f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } 5573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 5583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 5593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 560a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner case ISD::TokenFactor: { 561a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner std::vector<SDOperand> Ops; 562a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner bool Changed = false; 563a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 5641e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner SDOperand Op = Node->getOperand(i); 5651e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner // Fold single-use TokenFactor nodes into this token factor as we go. 566e131e5b81e5853f3c2a8c63651898ecd37eaf6f8Chris Lattner // FIXME: This is something that the DAGCombiner should do!! 5671e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner if (Op.getOpcode() == ISD::TokenFactor && Op.hasOneUse()) { 5681e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Changed = true; 5691e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner for (unsigned j = 0, e = Op.getNumOperands(); j != e; ++j) 5701e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Ops.push_back(LegalizeOp(Op.getOperand(j))); 5711e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner } else { 5721e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Ops.push_back(LegalizeOp(Op)); // Legalize the operands 5731e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner Changed |= Ops[i] != Op; 5741e81b9e5112c40c23ecca9a64b6ab2ce97c8c6d4Chris Lattner } 575a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 576a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner if (Changed) 577a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Ops); 578a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner break; 579a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 580a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner 58116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_START: 58216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 5833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 584128b52d3d75f4b74367de43e891cd98b5a9b5483Chris Lattner // Do not try to legalize the target-specific arguments (#1+) 58545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner Tmp2 = Node->getOperand(0); 58645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Tmp1 != Tmp2) { 58788de6e77bfadea8962b017f372658204ab71448cChris Lattner Node->setAdjCallChain(Tmp1); 58845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 58945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // If moving the operand from pointing to Tmp2 dropped its use count to 1, 59045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // this will cause the maps used to memoize results to get confused. 59145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Create and add a dummy use, just to increase its use count. This will 59245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // be removed at the end of legalize when dead nodes are removed. 59345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Tmp2.Val->hasOneUse()) 59445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp2, 59545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner DAG.getConstant(0, MVT::i32)); 59645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } 59716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // Note that we do not create new CALLSEQ_DOWN/UP nodes here. These 59888de6e77bfadea8962b017f372658204ab71448cChris Lattner // nodes are treated specially and are mutated in place. This makes the dag 59988de6e77bfadea8962b017f372658204ab71448cChris Lattner // legalization process more efficient and also makes libcall insertion 60088de6e77bfadea8962b017f372658204ab71448cChris Lattner // easier. 6013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 602fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner case ISD::DYNAMIC_STACKALLOC: 603fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 604fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 605fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 606fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 607adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Tmp3 != Node->getOperand(2)) { 608adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 609adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 610adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 611adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 612adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner } else 613513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner Result = Op.getValue(0); 614fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 615fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // Since this op produces two values, make sure to remember that we 616fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // legalized both of them. 617fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 618fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 619fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner return Result.getValue(Op.ResNo); 620fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 621d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 6223d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner case ISD::CALL: { 6233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 6253d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 6263d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 6273d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 6283d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 6293d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 6303d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 6313d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 6323d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 6333d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || Changed) { 6343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 6353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(Node->getNumValues()); 6363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 637ebda942efcb86634a6581aae76a0d0c92c4a232eChris Lattner RetTyVTs.push_back(Node->getValueType(i)); 638d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Result = SDOperand(DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 639d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL), 0); 64038d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner } else { 64138d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner Result = Result.getValue(0); 6423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 64338d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // Since calls produce multiple values, make sure to remember that we 64438d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // legalized all of them. 64538d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 64638d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 64738d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner return Result.getValue(Op.ResNo); 6483d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 649c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 650c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 651c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner if (Tmp1 != Node->getOperand(0)) 652c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); 653c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 654c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner 655c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 656c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 65847e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 65947e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 66047e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 66147e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 66247e9223e06390897c3834f8c527001df392570ffChris Lattner break; 66347e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 66447e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 66547e9223e06390897c3834f8c527001df392570ffChris Lattner break; 66647e9223e06390897c3834f8c527001df392570ffChris Lattner } 6677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 6687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 6697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 6707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 6717cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 6727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 6737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 6747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 6757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 6767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 6777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 678550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 679550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 680550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, MVT::i1); 681550b1e59c4eb5db020766012b1406fc56833251dChris Lattner 6827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 6837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 6847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 6857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 6867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 6877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 6887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 6897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Basic block destination (Op#2) is always legal. 6907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 6917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 6927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 6937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 6947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 6957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 6967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 6977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 6987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 699c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 7007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 7017cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 7027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 7037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 7047cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 7057cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, Tmp3, Node->getOperand(4)); 7067cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 7107cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 7117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 7127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 7137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 7147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 7157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 7167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 7177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 7187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 7197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 7207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 7217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7227cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 7237cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), 7247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, DAG.getConstant(0, Tmp2.getValueType()), 7257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 7267cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7277cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 728c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 729411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case ISD::BRCONDTWOWAY: 730411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 731411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 732411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 733411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Legal: 734411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 735411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 736411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Promote: 737411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 738411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 739411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 740411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR 741411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // pair. 742411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { 743411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Promote: 744411e888c1b4155190c8cffe388631ee20693b309Chris Lattner default: assert(0 && "This action is not supported yet!"); 745411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Legal: 746411e888c1b4155190c8cffe388631ee20693b309Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 747411e888c1b4155190c8cffe388631ee20693b309Chris Lattner std::vector<SDOperand> Ops; 748411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp1); 749411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp2); 750411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(2)); 751411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(3)); 752411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); 753411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 754411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 755411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Expand: 7567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If BRTWOWAY_CC is legal for this target, then simply expand this node 7577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // to that. Otherwise, skip BRTWOWAY_CC and expand directly to a 7587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // BRCOND/BR pair. 759c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::BRTWOWAY_CC, MVT::Other)) { 7607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 7617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 7627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 7637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 7647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 7667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 7677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 7687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 771411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Node->getOperand(2)); 7727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(3)); 7737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 774411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 775411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 776411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 7777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BRTWOWAY_CC: 7787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 779c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 7807cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 7817cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 7827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 7837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 7847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Node->getOperand(1), Tmp2, Tmp3, 7857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 7867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 7877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 7887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 7897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 7907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 7917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 7927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 7937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If this target does not support BRTWOWAY_CC, lower it to a BRCOND/BR 7947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // pair. 7957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other)) { 7967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 7977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 7987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 7997cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 8007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 8017cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 8027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 8037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 8047cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 8057cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 8067cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 8077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 8087cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 8097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 8107cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 8137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 8147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 8157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(5)); 8167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 8197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 8203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: 8213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 8232d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 8243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 8253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 82652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(Node->getValueType(0), Tmp1, Tmp2, 82752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(2)); 8288afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner else 8298afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner Result = SDOperand(Node, 0); 830edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 8318afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // Since loads produce two values, make sure to remember that we legalized 8328afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner // both of them. 8338afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 8348afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 8358afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner return Result.getValue(Op.ResNo); 8363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 8370f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::EXTLOAD: 8380f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::SEXTLOAD: 83901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case ISD::ZEXTLOAD: { 8400f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8410f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 8420f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 8435f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner MVT::ValueType SrcVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 84401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), SrcVT)) { 84501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner default: assert(0 && "This action is not supported yet!"); 8461c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner case TargetLowering::Promote: 8471c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); 8485f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 8495f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), MVT::i8); 8501c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // Since loads produce two values, make sure to remember that we legalized 8511c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // both of them. 8521c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 8531c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 8541c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner return Result.getValue(Op.ResNo); 855edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 85601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Legal: 85701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Tmp1 != Node->getOperand(0) || 85801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Tmp2 != Node->getOperand(1)) 8595f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 8605f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 86101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner else 86201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = SDOperand(Node, 0); 86301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner 86401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Since loads produce two values, make sure to remember that we legalized 86501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // both of them. 86601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 86701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 86801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(Op.ResNo); 86901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Expand: 8709d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth //f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 8719d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 8729d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth SDOperand Load = DAG.getLoad(SrcVT, Tmp1, Tmp2, Node->getOperand(2)); 87331559081a4285f4b7282e765aea4ec8a8e1d396cAndrew Lenharth Result = DAG.getNode(ISD::FP_EXTEND, Node->getValueType(0), Load); 8749d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (Op.ResNo) 8759d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Load.getValue(1); 8769d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Result; 8779d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 87801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(Node->getOpcode() != ISD::EXTLOAD && 87901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner "EXTLOAD should always be supported!"); 88001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 88101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // zero/sign extend inreg. 8825f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 8835f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 88423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner SDOperand ValRes; 88523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SEXTLOAD) 88623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 88715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, DAG.getValueType(SrcVT)); 88823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner else 88923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getZeroExtendInReg(Result, SrcVT); 89001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), ValRes); 89101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 89201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Op.ResNo) 89301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(1); 89401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return ValRes; 89501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 89601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(0 && "Unreachable"); 89701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 8983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EXTRACT_ELEMENT: 8993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Get both the low and high parts. 9003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 9013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) 9023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = Tmp2; // 1 -> Hi 9033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner else 9043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = Tmp1; // 0 -> Lo 9053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 9083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 909edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 910c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getOperand(2).getValueType()) && 911d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner "Register type must be legal!"); 912d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // Legalize the incoming value (must be legal). 913d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 914d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) 915d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Result = DAG.getNode(ISD::CopyToReg, MVT::Other, Tmp1, 916d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Node->getOperand(1), Tmp2); 9173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 9203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 9223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 2: // ret val 9233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 9243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 9253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 9268afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 9273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 9283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 9303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 9313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 9323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Lo, Hi); 933edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 9343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 9368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 9378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 9388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 9393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 9423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 9433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); 9443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 9463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<SDOperand> NewValues; 9473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 9483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) 9493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(i).getValueType())) { 9503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 9514e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NewValues.push_back(LegalizeOp(Node->getOperand(i))); 9523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 9543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 9553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(i), Lo, Hi); 9563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Lo); 9573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Hi); 958edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 9593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 9618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Can't promote multiple return value yet!"); 9623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); 9643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 9673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::STORE: 9693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 9713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9725d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 97303c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ 9745d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner if (CFP->getValueType(0) == MVT::f32) { 97500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 976cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(FloatToBits(CFP->getValue()), 977cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i32), 978cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 97952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 9805d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } else { 9815d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); 98200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 983cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(DoubleToBits(CFP->getValue()), 984cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i64), 985cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 98652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 9875d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 98884734ce8ef1a21eb347d4deca0bf32d59001f751Chris Lattner Node = Result.Val; 9895d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 9905d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner 9913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 9923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: { 9933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Val = LegalizeOp(Node->getOperand(1)); 9943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Val != Node->getOperand(1) || Tmp1 != Node->getOperand(0) || 9953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(2)) 99652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, 99752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 9983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 100103c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Truncate the value and store the result. 100203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(1)); 100303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp3, Tmp2, 10042d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 10059fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getValueType(Node->getOperand(1).getValueType())); 100603c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 100703c8546ec57523970874917854a2fb77b1ff598eChris Lattner 10083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: 10093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 10103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 10113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 10123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 10133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 10143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1015edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Lo = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Lo, Tmp2, 1016edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1017ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner unsigned IncrementSize = MVT::getSizeInBits(Hi.getValueType())/8; 10183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::ADD, Tmp2.getValueType(), Tmp2, 10193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 10203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Tmp2.getValueType()) && 10213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Pointers must be legal!"); 10222d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Again, claiming both parts of the store came form the same Instr 1023edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Hi, Tmp2, 1024edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1025ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1026ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner break; 10273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 10283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 102995762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 103095762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10312c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 10322c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); 103395762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 10340f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::TRUNCSTORE: 10350f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10360f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 10370f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 10380f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 10390f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Legal: 10400f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 10410f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 10420f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 != Node->getOperand(2)) 104345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 10449fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner Node->getOperand(3), Node->getOperand(4)); 10450f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 10460f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Promote: 10470f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Expand: 10480f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(0 && "Cannot handle illegal TRUNCSTORE yet!"); 10490f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner } 10500f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 10512ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 105247e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 105347e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 105447e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 105547e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 105647e9223e06390897c3834f8c527001df392570ffChris Lattner break; 105747e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 105847e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 105947e9223e06390897c3834f8c527001df392570ffChris Lattner break; 106047e9223e06390897c3834f8c527001df392570ffChris Lattner } 10613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 10622ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 106355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 1064b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { 106555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 10669373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 10679373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 10689373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1.getOperand(0), Tmp1.getOperand(1), 10699373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 10709373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 10719373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 1072550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 1073550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 1074550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, MVT::i1); 10759373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1, 10769373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 10779373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 10789373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 10799373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 108055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 108155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 108255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 != Node->getOperand(2)) 108355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), 108455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp1, Tmp2, Tmp3); 108555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 108655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 108755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner MVT::ValueType NVT = 108855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 108955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 109055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (MVT::isInteger(Tmp2.getValueType())) { 109155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::ZERO_EXTEND; 109255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::TRUNCATE; 109355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 109455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::FP_EXTEND; 109555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::FP_ROUND; 109655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 109755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 109855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp2 = DAG.getNode(ExtOp, NVT, Tmp2); 109955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 = DAG.getNode(ExtOp, NVT, Tmp3); 110055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 110155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2,Tmp3); 110255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(TruncOp, Node->getValueType(0), Result); 110355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 110455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 110555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 11063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11079373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 11089373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 11099373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 11109373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 1111c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(0).getValueType())) { 111223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner // Everything is legal, see if we should expand this op or something. 111323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner switch (TLI.getOperationAction(ISD::SELECT_CC, 111423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0).getValueType())) { 111523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner default: assert(0 && "This action is not supported yet!"); 111623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Custom: { 111723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner SDOperand Tmp = 111823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner TLI.LowerOperation(DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), 111923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0), 112023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(1), Tmp3, Tmp4, 1121d7050a9c50211dd215cb3c2bc28b4fb6bfa4a116Chris Lattner Node->getOperand(4)), DAG); 112223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp.Val) { 112323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = LegalizeOp(Tmp); 112423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 112523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 112623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } // FALLTHROUGH if the target can't lower this operation after all. 112723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Legal: 112823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 112923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 113023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 113123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3)) { 113223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), Tmp1, Tmp2, 113323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3, Tmp4, Node->getOperand(4)); 113423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 113523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 11369373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 11379373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 11389373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 11399373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp1 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 11409373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(0), // LHS 11419373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), // RHS 11429373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4))); 11437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 11447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 11457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 11467cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 11477cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 11487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, Tmp3.getValueType(), 11497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1.getOperand(0), Tmp1.getOperand(1), 11507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, Tmp1.getOperand(2)); 11517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 11527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getSelectCC(Tmp1, 11537cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 11547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, ISD::SETNE); 11557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 11569373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 11579373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 11583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 11593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 11603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 11613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 11623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 11633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 11643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 11658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // LHS 11668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // RHS 11678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 11688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // If this is an FP compare, the operands have already been extended. 11698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(Node->getOperand(0).getValueType())) { 11708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner MVT::ValueType VT = Node->getOperand(0).getValueType(); 117171c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 11728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 11738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Otherwise, we have to insert explicit sign or zero extends. Note 11748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // that we could insert sign extends for ALL conditions, but zero extend 11758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // is cheaper on many machines (an AND instead of two shifts), so prefer 11768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // it. 11777cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 11788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner default: assert(0 && "Unknown integer comparison!"); 11798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETEQ: 11808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETNE: 11818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGE: 11828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGT: 11838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULE: 11848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULT: 11858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // ALL of these operations will work if we either sign or zero extend 11868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // the operands (including the unsigned comparisons!). Zero extend is 11878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // usually a simpler/cheaper operation, so prefer it. 118823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 118923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 11908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 11918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGE: 11928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGT: 11938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLT: 11948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLE: 119515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 119615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 119715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 119815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 11998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 12008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 12018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 12023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1203edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case Expand: 12043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 12053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LHSLo, LHSHi); 12063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RHSLo, RHSHi); 12077cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 12083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETEQ: 12093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETNE: 121008b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSLo == RHSHi) 121108b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 121208b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSCST->isAllOnesValue()) { 121308b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner // Comparison to -1. 121408b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Tmp1 = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 1215b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSLo; 1216edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 121708b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner } 121808b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner 12193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 12203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 12213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp2); 1222b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 12233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 12255b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 12265b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // X > -1, x < 0 12275b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Node->getOperand(1))) 12287cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner if ((cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETLT && 12295b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner CST->getValue() == 0) || // X < 0 12307cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner (cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETGT && 1231b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman (CST->isAllOnesValue()))) { // X > -1 1232b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp1 = LHSHi; 1233b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSHi; 1234b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1235b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 12365b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner 12373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: This generated code sucks. 12383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ISD::CondCode LowCC; 12397cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 12403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: assert(0 && "Unknown integer setcc!"); 12413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLT: 12423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 12433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGT: 12443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 12453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLE: 12463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 12473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGE: 12483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 12493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1250edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 12513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 12523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 12533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 12543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 12563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 12577cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp1 = DAG.getSetCC(Node->getValueType(0), LHSLo, RHSLo, LowCC); 12587cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getNode(ISD::SETCC, Node->getValueType(0), LHSHi, RHSHi, 12597cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 12607cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getSetCC(Node->getValueType(0), LHSHi, RHSHi, ISD::SETEQ); 1261b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1262b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result, Tmp1, Tmp2)); 1263b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman return Result; 12643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1266b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman 1267b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch(TLI.getOperationAction(ISD::SETCC, Node->getOperand(0).getValueType())) { 1268b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman default: 1269b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman assert(0 && "Cannot handle this action for SETCC yet!"); 1270b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 12715e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth case TargetLowering::Promote: 12725e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 12735e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Node->getOperand(2)); 12745e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth break; 1275b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Legal: 1276b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1277b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 1278b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1279b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1280b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Expand: 1281b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // Expand a setcc node into a select_cc of the same condition, lhs, and 1282b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // rhs that selects between const 1 (true) and const 0 (false). 1283b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman MVT::ValueType VT = Node->getValueType(0); 1284b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SELECT_CC, VT, Tmp1, Tmp2, 1285b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman DAG.getConstant(1, VT), DAG.getConstant(0, VT), 1286b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1287b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(Result); 1288b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1289b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 12903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1292e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMSET: 1293e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMCPY: 1294e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMMOVE: { 1295deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Chain 1296e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Pointer 1297e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner 1298e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { // memset = ubyte 1299e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner switch (getTypeAction(Node->getOperand(2).getValueType())) { 1300e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand a byte!"); 1301e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1302deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 1303e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1304e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1305deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); 1306e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1307e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1308e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } else { 1309edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Tmp3 = LegalizeOp(Node->getOperand(2)); // memcpy/move = pointer, 1310e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1311272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1312272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp4; 1313272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(3).getValueType())) { 13146814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner case Expand: { 13156814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner // Length is too big, just take the lo-part of the length. 13166814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner SDOperand HiPart; 13176814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner ExpandOp(Node->getOperand(3), HiPart, Tmp4); 13186814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner break; 13196814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner } 1320e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1321e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = LegalizeOp(Node->getOperand(3)); 1322e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1323e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1324e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = PromoteOp(Node->getOperand(3)); 1325272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1326272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner } 1327272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1328272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp5; 1329272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(4).getValueType())) { // uint 1330272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 1331272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Legal: 1332272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner Tmp5 = LegalizeOp(Node->getOperand(4)); 1333272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1334272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Promote: 1335e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp5 = PromoteOp(Node->getOperand(4)); 1336e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1337e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 133855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 133955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 134055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 134107dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 134207dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 134307dffd6af673c73352150583150b242a93694f00Chris Lattner TLI.LowerOperation(DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, 134407dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp2, Tmp3, Tmp4, Tmp5), DAG); 134507dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 134607dffd6af673c73352150583150b242a93694f00Chris Lattner Result = LegalizeOp(Tmp); 134707dffd6af673c73352150583150b242a93694f00Chris Lattner break; 134807dffd6af673c73352150583150b242a93694f00Chris Lattner } 134907dffd6af673c73352150583150b242a93694f00Chris Lattner // FALLTHROUGH if the target thinks it is legal. 135007dffd6af673c73352150583150b242a93694f00Chris Lattner } 135155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 1352e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 1353e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || 1354e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp5 != Node->getOperand(4)) { 1355e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<SDOperand> Ops; 1356e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 1357e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 1358e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 1359e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 136055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 136155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: { 1362e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Otherwise, the target does not support this operation. Lower the 1363e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // operation to an explicit libcall as appropriate. 1364e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 1365e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner const Type *IntPtrTy = TLI.getTargetData().getIntPtrType(); 1366e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1367e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 13683bfbf4ea990930d153e58e153f319408341a94feReid Spencer const char *FnName = 0; 1369e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { 1370e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1371e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Extend the ubyte argument to be an int value for the call. 1372e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Tmp3); 1373e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, Type::IntTy)); 1374e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1375e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 1376e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = "memset"; 1377e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else if (Node->getOpcode() == ISD::MEMCPY || 1378e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Node->getOpcode() == ISD::MEMMOVE) { 1379e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1380e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, IntPtrTy)); 1381e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1382e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = Node->getOpcode() == ISD::MEMMOVE ? "memmove" : "memcpy"; 1383e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else { 1384e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner assert(0 && "Unknown op!"); 1385e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 138645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 1387e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 1388adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(Tmp1, Type::VoidTy, false, CallingConv::C, false, 1389e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner DAG.getExternalSymbol(FnName, IntPtr), Args, DAG); 1390c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner Result = CallResult.second; 1391c087a435109cdc943da094a21371f7d66d5b0e54Chris Lattner NeedsAnotherIteration = true; 139255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 139355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 1394e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 1395e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner break; 1396e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 139752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 139852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::READPORT: 139952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 140052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 14016d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14023e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 14033e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 14043e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 14053e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 14063e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 14073e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 14083e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 140952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = SDOperand(Node, 0); 141052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // Since these produce two values, make sure to remember that we legalized 141152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // both of them. 141252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 141352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 141452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner return Result.getValue(Op.ResNo); 141552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::WRITEPORT: 141652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 141752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 141852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 141952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 142052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 != Node->getOperand(2)) 142152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 142252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner break; 142352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 14246d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::READIO: 14256d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 14266d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 14276d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14286d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 14296d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 14306d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 14316d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 14323e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 14333e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 14343e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 14353e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 14363e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 14373e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 14383e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 14396d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = SDOperand(Node, 0); 14406d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14416d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 14426d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a load from memory. 14436d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0), 14446d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), DAG.getSrcValue(NULL)); 14456d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 14466d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14476d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 14486d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14496d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Since these produce two values, make sure to remember that we legalized 14506d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // both of them. 14516d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 14526d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 14536d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner return Result.getValue(Op.ResNo); 14546d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14556d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::WRITEIO: 14566d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 14576d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 14586d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 14596d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 14606d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 14616d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1).getValueType())) { 14626d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 14636d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 14646d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 14656d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 14666d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 != Node->getOperand(2)) 14676d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 14686d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14696d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 14706d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a store to memory. 14716d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0), 14726d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), Node->getOperand(2), 14736d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getSrcValue(NULL)); 14746d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 14756d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14766d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 14776d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 14786d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 147984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::ADD_PARTS: 14805b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SUB_PARTS: 14815b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 14825b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 14835b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 148484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 148584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 148684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 148784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 148884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 148984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 1490e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (Changed) { 1491e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 1492e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 1493e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 14942c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 14952c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 14962c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 14972c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 14982c8086f4b9916b2d02842be5e375276023225fbaChris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 14992c8086f4b9916b2d02842be5e375276023225fbaChris Lattner return Result.getValue(Op.ResNo); 150084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 15012c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 15022c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 15033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 15043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 15053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 1506c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 1507c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 15083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 15093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 15103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 15113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 15123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 151303c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 151403c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 151503c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 15163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1517f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth switch (getTypeAction(Node->getOperand(1).getValueType())) { 1518f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Expand: assert(0 && "Not possible"); 1519f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Legal: 1520f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 1521f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1522f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Promote: 1523f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the RHS. 1524f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 1525f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth } 15263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0) || 15273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(1)) 15283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 15293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1530edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1531c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 1532c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 1533c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1534c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 1535c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1536c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Legal: 1537c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman if (Tmp1 != Node->getOperand(0) || 1538c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 != Node->getOperand(1)) 1539edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 1540c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2); 1541c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1542c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Promote: 1543c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case TargetLowering::Custom: 1544c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman assert(0 && "Cannot promote/custom handle this yet!"); 15454c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner case TargetLowering::Expand: 15464c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner if (MVT::isInteger(Node->getValueType(0))) { 15474c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner MVT::ValueType VT = Node->getValueType(0); 15484c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner unsigned Opc = (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 15494c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(Opc, VT, Tmp1, Tmp2); 15504c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::MUL, VT, Result, Tmp2); 15514c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::SUB, VT, Tmp1, Result); 15524c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner } else { 15534c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner // Floating point mod -> fmod libcall. 15544c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner const char *FnName = Node->getValueType(0) == MVT::f32 ? "fmodf":"fmod"; 15554c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner SDOperand Dummy; 15564c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = ExpandLibCall(FnName, Node, Dummy); 1557c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1558c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 1559c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 1560c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 15612c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 1562691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1563691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1564691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1565691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 1566691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1567691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 1568691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth if (Tmp1 != Node->getOperand(0)) 1569691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1570691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1571691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 1572691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType OVT = Tmp1.getValueType(); 1573691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 1574edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 1575edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 1576691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 1577691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 1578691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1579691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch(Node->getOpcode()) 1580691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth { 1581691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 1582691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 1583691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1584691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 1585691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 15867cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 15877cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), 15887cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ); 158900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 1590691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(OVT),NVT), Tmp1); 1591691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1592691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 1593691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 159400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 159500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 1596691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getSizeInBits(OVT), NVT)); 1597691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1598691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1599691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1600691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1601691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Custom: 1602691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth assert(0 && "Cannot custom handle this yet!"); 1603691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 1604ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth switch(Node->getOpcode()) 1605ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth { 1606ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth case ISD::CTPOP: { 1607e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner static const uint64_t mask[6] = { 1608e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 1609e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 1610e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 1611e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner }; 1612ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth MVT::ValueType VT = Tmp1.getValueType(); 1613e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner MVT::ValueType ShVT = TLI.getShiftAmountTy(); 1614e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner unsigned len = getSizeInBits(VT); 1615e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 1616ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 1617e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp2 = DAG.getConstant(mask[i], VT); 1618e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp3 = DAG.getConstant(1ULL << i, ShVT); 161900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::ADD, VT, 1620ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, Tmp1, Tmp2), 1621ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, 1622ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3), 1623ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp2)); 1624ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1625ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Result = Tmp1; 1626ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1627ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 162857ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTLZ: { 162957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina /* for now, we do this: 16305c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 1); 16315c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 2); 16325c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner ... 16335c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>16); 163400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen x = x | (x >>32); // for 64-bit input 16355c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner return popcount(~x); 163600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 16375c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner but see also: http://www.hackersdelight.org/HDcode/nlz.cc */ 16385c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 163957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina MVT::ValueType ShVT = TLI.getShiftAmountTy(); 164057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina unsigned len = getSizeInBits(VT); 164157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 164257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getConstant(1ULL << i, ShVT); 164300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::OR, VT, Tmp1, 164457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3)); 164557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 164657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getNode(ISD::XOR, VT, Tmp1, DAG.getConstant(~0ULL, VT)); 16475c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 164818aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 164957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 165057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTTZ: { 165100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen // for now, we use: { return popcount(~x & (x - 1)); } 1652d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // unless the target has ctlz but not ctpop, in which case we use: 1653d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // { return 32 - nlz(~x & (x-1)); } 1654d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // see also http://www.hackersdelight.org/HDcode/ntz.cc 16555c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 16565c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp2 = DAG.getConstant(~0ULL, VT); 165700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp3 = DAG.getNode(ISD::AND, VT, 16585c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::XOR, VT, Tmp1, Tmp2), 16595c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::SUB, VT, Tmp1, 16605c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getConstant(1, VT))); 1661d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // If ISD::CTLZ is legal and CTPOP isn't, then do that instead 1662c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::CTPOP, VT) && 1663c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::CTLZ, VT)) { 166400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = LegalizeOp(DAG.getNode(ISD::SUB, VT, 1665d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getConstant(getSizeInBits(VT), VT), 1666d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getNode(ISD::CTLZ, VT, Tmp3))); 1667d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } else { 1668d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 1669d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } 167018aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 167157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 1672ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth default: 1673ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth assert(0 && "Cannot expand this yet!"); 1674ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 1675ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 1676691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 1677691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 1678691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 167900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 16802c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 16812c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 16822c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 1683da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 1684da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 1685da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 16862c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 16872c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 16882c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 16892c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 16902c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 16912c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 16922c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Promote: 16932c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Custom: 16942c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Cannot promote/custom handle this yet!"); 16952c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 1696f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1697f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FNEG: { 16982c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 16992c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 17002c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = LegalizeOp(DAG.getNode(ISD::SUB, Node->getValueType(0), 17012c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2, Tmp1)); 1702f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1703f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1704f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 17054af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 17064af6e0d7836126630f579b0a34f054321187f00bChris Lattner MVT::ValueType VT = Node->getValueType(0); 17074af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 17087cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, Tmp2, ISD::SETUGT); 17094af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp3 = DAG.getNode(ISD::FNEG, VT, Tmp1); 17104af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = DAG.getNode(ISD::SELECT, VT, Tmp2, Tmp1, Tmp3); 17114af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = LegalizeOp(Result); 1712f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1713f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1714f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: 1715f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: 1716f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: { 1717f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner MVT::ValueType VT = Node->getValueType(0); 1718f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner const char *FnName = 0; 1719f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 1720f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: FnName = VT == MVT::f32 ? "sqrtf" : "sqrt"; break; 1721f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: FnName = VT == MVT::f32 ? "sinf" : "sin"; break; 1722f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: FnName = VT == MVT::f32 ? "cosf" : "cos"; break; 1723f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 1724f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 17252ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman SDOperand Dummy; 17262ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman Result = ExpandLibCall(FnName, Node, Dummy); 1727f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 1728f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1729f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: 17304af6e0d7836126630f579b0a34f054321187f00bChris Lattner assert(0 && "Unreachable!"); 17312c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 17322c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 17332c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 17342c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 17352c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 17362c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 1737fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::SINT_TO_FP: 1738fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::UINT_TO_FP: { 1739fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP; 1740fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1741fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1742d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen switch (TLI.getOperationAction(Node->getOpcode(), 1743fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType())) { 1744fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner default: assert(0 && "Unknown operation action!"); 1745fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Expand: 17466269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = ExpandLegalINT_TO_FP(isSigned, 17476269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey LegalizeOp(Node->getOperand(0)), 17486269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Node->getValueType(0)); 1749fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 1750fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 1751fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Promote: 1752fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteLegalINT_TO_FP(LegalizeOp(Node->getOperand(0)), 1753fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), 1754fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner isSigned); 1755fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 1756fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 1757fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Legal: 1758fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1759fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1760fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 1761fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1762fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1763fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1764fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1765fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1766fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, 1767fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), Node->getOperand(0)); 1768fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1769fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1770fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (isSigned) { 1771fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1772fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 1773fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result, DAG.getValueType(Node->getOperand(0).getValueType())); 1774fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SINT_TO_FP, Op.getValueType(), Result); 1775fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } else { 1776fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1777fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getZeroExtendInReg(Result, 1778fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType()); 1779fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::UINT_TO_FP, Op.getValueType(), Result); 1780fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1781fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1782fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1783fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1784fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1785fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::TRUNCATE: 1786fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1787fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1788fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1789fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1790fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1791fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1792fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1793fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 1794fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 1795fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // Since the result is legal, we should just be able to truncate the low 1796fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // part of the source. 1797fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Tmp1); 1798fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1799fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1800fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1801fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Op.getValueType(), Result); 1802fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1803fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1804fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1805d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 1806fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_SINT: 1807fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_UINT: 1808fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 1809fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 1810f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1811f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner 18121618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))){ 18131618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: assert(0 && "Unknown operation action!"); 18141618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Expand: 1815d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT) { 1816d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman SDOperand True, False; 1817d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType VT = Node->getOperand(0).getValueType(); 1818d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType NVT = Node->getValueType(0); 1819d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman unsigned ShiftAmt = MVT::getSizeInBits(Node->getValueType(0))-1; 1820d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getConstantFP((double)(1ULL << ShiftAmt), VT); 1821d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp3 = DAG.getSetCC(TLI.getSetCCResultTy(), 1822d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Node->getOperand(0), Tmp2, ISD::SETLT); 1823d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman True = DAG.getNode(ISD::FP_TO_SINT, NVT, Node->getOperand(0)); 1824d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::FP_TO_SINT, NVT, 1825d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getNode(ISD::SUB, VT, Node->getOperand(0), 1826d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2)); 1827d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::XOR, NVT, False, 1828d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getConstant(1ULL << ShiftAmt, NVT)); 1829d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, NVT, Tmp3, True, False)); 18302d56e72f09337a1cab3ba199a9467c159296f3faNate Begeman return Result; 1831d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 1832d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman assert(0 && "Do not know how to expand FP_TO_SINT yet!"); 1833d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 1834d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman break; 18351618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Promote: 1836f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = PromoteLegalFP_TO_INT(Tmp1, Node->getValueType(0), 18371618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner Node->getOpcode() == ISD::FP_TO_SINT); 18381618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner AddLegalizedOperand(Op, Result); 18391618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return Result; 184007dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 184107dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 184207dffd6af673c73352150583150b242a93694f00Chris Lattner DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 184307dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp = TLI.LowerOperation(Tmp, DAG); 184407dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 184507dffd6af673c73352150583150b242a93694f00Chris Lattner AddLegalizedOperand(Op, Tmp); 184607dffd6af673c73352150583150b242a93694f00Chris Lattner NeedsAnotherIteration = true; 1847507f752f6ed28aa9f0ae680e95bfc93df4e9e2dcChris Lattner return Tmp; 184807dffd6af673c73352150583150b242a93694f00Chris Lattner } else { 184907dffd6af673c73352150583150b242a93694f00Chris Lattner // The target thinks this is legal afterall. 185007dffd6af673c73352150583150b242a93694f00Chris Lattner break; 185107dffd6af673c73352150583150b242a93694f00Chris Lattner } 185207dffd6af673c73352150583150b242a93694f00Chris Lattner } 18531618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 18541618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 18551618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 1856d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 1857fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 1858fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 1859fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1860fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 1861fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 1862fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 1863fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 1864fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 1865fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1866fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 1867fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 1868d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 18693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 18703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 187103c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_EXTEND: 187203c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_ROUND: 18733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 18743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 18753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 18763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 18773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 18783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1879b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner case Expand: 18802c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 1881b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner 188203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Promote: 188303c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 18841713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner case ISD::ZERO_EXTEND: 18851713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 188647e9223e06390897c3834f8c527001df392570ffChris Lattner // NOTE: Any extend would work here... 188747e9223e06390897c3834f8c527001df392570ffChris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, Op.getValueType(), Result); 188823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 188923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 189003c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 189103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SIGN_EXTEND: 18921713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 189347e9223e06390897c3834f8c527001df392570ffChris Lattner // NOTE: Any extend would work here... 1894d5d56825123665b60d4eada0a4ad7d0adc5cf3a3Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, Op.getValueType(), Result); 18951713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 189615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 189715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 18981713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 189903c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_EXTEND: 19001713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 19011713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner if (Result.getValueType() != Op.getValueType()) 19021713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner // Dynamically dead while we have only 2 FP types. 19031713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::FP_EXTEND, Op.getValueType(), Result); 19041713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 190503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_ROUND: 1906f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 1907f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 1908f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 190903c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 19103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 19113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 19120f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 191323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 19140f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 191515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 191645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 191745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 191845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 191955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 192055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 192155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 192255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0)) 192355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 19245f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner DAG.getValueType(ExtraVT)); 192555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 192655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 192745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 192823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 192945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 193045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 193145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned BitsDiff = MVT::getSizeInBits(Node->getValueType(0)) - 193245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::getSizeInBits(ExtraVT); 193327ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner SDOperand ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 193445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SHL, Node->getValueType(0), 193545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 193645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SRA, Node->getValueType(0), 193745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 193845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 193945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // The only way we can lower this is to turn it into a STORETRUNC, 194045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 194145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 194245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 194345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 194445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 194545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner const Type *Ty = MVT::getTypeForValueType(ExtraVT); 194645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned TySize = (unsigned)TLI.getTargetData().getTypeSize(Ty); 194745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 194845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 1949edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman int SSFI = 195045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 195145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 195245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, DAG.getEntryNode(), 195352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(0), StackSlot, 19549fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getSrcValue(NULL), DAG.getValueType(ExtraVT)); 19555f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 19565f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result, StackSlot, DAG.getSrcValue(NULL), 19575f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner ExtraVT); 195845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 195945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 196045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 196145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = LegalizeOp(Result); 196255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 196345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 19640f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 19653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 196645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 19673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 196845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 196945982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 197045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 19713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 19723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 19733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 19748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// PromoteOp - Given an operation that produces a value in an invalid type, 19758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// promote it to compute the value into a larger type. The produced value will 19768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// have the correct bits for the low portion of the register, but no guarantee 19778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// is made about the top bits: it may be zero, sign-extended, or garbage. 197803c8546ec57523970874917854a2fb77b1ff598eChris LattnerSDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) { 197903c8546ec57523970874917854a2fb77b1ff598eChris Lattner MVT::ValueType VT = Op.getValueType(); 198071c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 198103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(getTypeAction(VT) == Promote && 198203c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Caller should expand or legalize operands that are not promotable!"); 198303c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(NVT > VT && MVT::isInteger(NVT) == MVT::isInteger(VT) && 198403c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Cannot promote to smaller type!"); 198503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 198603c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Tmp1, Tmp2, Tmp3; 198703c8546ec57523970874917854a2fb77b1ff598eChris Lattner 198803c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Result; 198903c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDNode *Node = Op.Val; 199003c8546ec57523970874917854a2fb77b1ff598eChris Lattner 199145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (!Node->hasOneUse()) { 199245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner std::map<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op); 199345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (I != PromotedNodes.end()) return I->second; 199445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } else { 199545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner assert(!PromotedNodes.count(Op) && "Repromoted this node??"); 199645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } 199745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 19980f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // Promotion needs an optimization step to clean up after it, and is not 19990f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // careful to avoid operations the target does not support. Make sure that 20000f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // all generated operations are legalized in the next iteration. 20010f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner NeedsAnotherIteration = true; 20020f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 200303c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 2004d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2005d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 200603c8546ec57523970874917854a2fb77b1ff598eChris Lattner default: 200703c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 200803c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(0 && "Do not know how to promote this operator!"); 200903c8546ec57523970874917854a2fb77b1ff598eChris Lattner abort(); 2010fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2011fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getNode(ISD::UNDEF, NVT); 2012fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 201303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::Constant: 2014ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner if (VT != MVT::i1) 2015ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND, NVT, Op); 2016ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner else 2017ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, NVT, Op); 201803c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantSDNode>(Result) && "Didn't constant fold zext?"); 201903c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 202003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::ConstantFP: 202103c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::FP_EXTEND, NVT, Op); 202203c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantFPSDNode>(Result) && "Didn't constant fold fp_extend?"); 202303c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2024ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner 202582fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner case ISD::SETCC: 2026c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(TLI.getSetCCResultTy()) && "SetCC type is not legal??"); 20277cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(),Node->getOperand(0), 20287cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(1), Node->getOperand(2)); 202982fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = LegalizeOp(Result); 203082fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner break; 203103c8546ec57523970874917854a2fb77b1ff598eChris Lattner 203203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 203303c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 203403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Legal: 203503c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 203603c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.getValueType() >= NVT && 203703c8546ec57523970874917854a2fb77b1ff598eChris Lattner "This truncation doesn't make sense!"); 203803c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (Result.getValueType() > NVT) // Truncate to NVT instead of VT 203903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Result); 204003c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2041e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner case Promote: 2042e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // The truncation is not required, because we don't guarantee anything 2043e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // about high bits anyway. 2044e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner Result = PromoteOp(Node->getOperand(0)); 2045e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner break; 204603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Expand: 204779e46acd35df36477029e9f534ab1a366a98df56Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 204879e46acd35df36477029e9f534ab1a366a98df56Nate Begeman // Truncate the low part of the expanded value to the result type 2049e21c305ed85b2be4a27784ba52471f6b68fdd255Chris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Tmp1); 205003c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 205103c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 20528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SIGN_EXTEND: 20538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::ZERO_EXTEND: 20548b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 20558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Smaller reg should have been promoted!"); 20568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 20578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Just do extend all the way to the larger type. 20588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 20598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 20608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 20628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Promote the reg if it's smaller. 20638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 20648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The high bits are not guaranteed to be anything. Insert an extend. 20658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND) 2066595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 206715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 20688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 206923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 207023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 20718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 20738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 20758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_EXTEND: 20768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Case not implemented. Dynamically dead with 2 FP types!"); 20778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_ROUND: 20788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 20798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Cannot expand FP regs!"); 20808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: assert(0 && "Unreachable with 2 FP types!"); 20818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 20828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Do an FP_ROUND_INREG. 20838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 208415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 208515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 20868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 20888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 20908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SINT_TO_FP: 20918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UINT_TO_FP: 20928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 20938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 20948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 209577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 209677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 20978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 20988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 20998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 21008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 21018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP) 21028b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 210315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 210415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 21058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 210623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 210723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 210877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 210977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 21108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 211277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, NVT, 211377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOperand(0)); 211477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // Round if we cannot tolerate excess precision. 211577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (NoExcessFPPrecision) 211615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 211715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 211877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 21198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 21208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 21228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_SINT: 21238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_UINT: 21248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 21258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 21268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 21278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 21298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input result is prerounded, so we don't have to do anything 21308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // special. 21318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 21348b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "not implemented"); 21358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 2136d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // If we're promoting a UINT to a larger size, check to see if the new node 2137d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 2138d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // we can use that instead. This allows us to generate better code for 2139d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 2140d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // legal, such as PowerPC. 2141d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT && 2142c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) && 2143c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::FP_TO_SINT, NVT)) { 2144d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(ISD::FP_TO_SINT, NVT, Tmp1); 2145d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2146d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2147d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 21488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 21498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 21502c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 21512c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 21522c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21532c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(Tmp1.getValueType() == NVT); 21542c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 21552c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NOTE: we do not have to do any extra rounding here for 21562c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NoExcessFPPrecision, because we know the input will have the appropriate 21572c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // precision, and these operations don't modify precision at all. 21582c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 21592c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 2160da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2161da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2162da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 2163da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 2164da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner assert(Tmp1.getValueType() == NVT); 2165da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2166da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner if(NoExcessFPPrecision) 216715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 216815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 2169da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner break; 2170da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner 217103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::AND: 217203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::OR: 217303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::XOR: 21740f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::ADD: 21758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SUB: 21760f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::MUL: 21770f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // The input may have strange things in the top bits of the registers, but 21780f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // these operations don't care. They may have wierd bits going out, but 21790f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // that too is okay if they are integer operations. 21800f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21810f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 21820f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 21830f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 21840f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 21850f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // However, if this is a floating point operation, they will give excess 21860f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // precision that we may not be able to tolerate. If we DO allow excess 21870f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // precision, just leave it, otherwise excise it. 21888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // FIXME: Why would we need to round FP ops more than integer ones? 21898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Is Round(Add(Add(A,B),C)) != Round(Add(Round(Add(A,B)), C)) 21900f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 219115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 219215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 21930f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 21940f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 21958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SDIV: 21968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SREM: 21978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be sign extended. 21988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 21998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 22008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(NVT)) { 220115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 220215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 220315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 220415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 22058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 22068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 22078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 22098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 221015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 221115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 22128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UDIV: 22158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UREM: 22168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be zero extended. 22178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 22188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 22198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(MVT::isInteger(NVT) && "Operators don't apply to FP!"); 222023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 222123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 22228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 22238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 22258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SHL: 22268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 22278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 22288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SHL, NVT, Tmp1, Tmp2); 22298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRA: 22318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly sign extended. 22328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 223315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 223415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 22358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 22368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRA, NVT, Tmp1, Tmp2); 22378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 22388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRL: 22398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly zero extended. 22408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 224123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 22428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 22438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRL, NVT, Tmp1, Tmp2); 22448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 224503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::LOAD: 224603c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 224703c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2248232ee95a09a583b7d66b90ee7ddf7fdb9c194a04Chris Lattner // FIXME: When the DAG combiner exists, change this to use EXTLOAD! 22496841dec8c1c071b5a417fb4172633c68301be36cChris Lattner if (MVT::isInteger(NVT)) 22505f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Tmp1, Tmp2, 22515f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Node->getOperand(2), VT); 22526841dec8c1c071b5a417fb4172633c68301be36cChris Lattner else 22535f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, NVT, Tmp1, Tmp2, 22545f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Node->getOperand(2), VT); 225503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 225603c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Remember that we legalized the chain. 225703c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 225803c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 225903c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SELECT: 226047e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 226147e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 226247e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 226347e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0));// Legalize the condition. 226447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 226547e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 226647e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 226747e9223e06390897c3834f8c527001df392570ffChris Lattner break; 226847e9223e06390897c3834f8c527001df392570ffChris Lattner } 226903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Legalize the op0 227003c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); // Legalize the op1 227103c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2, Tmp3); 227203c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 22739373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 22749373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2 = PromoteOp(Node->getOperand(2)); // True 22759373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = PromoteOp(Node->getOperand(3)); // False 22769373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 22779373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), Tmp2, Tmp3, 22789373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4)); 22799373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 2280d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 22818ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner case ISD::CALL: { 22828ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 22838ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 22848ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 22853d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 22863d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) 22873d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 22883d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 22898ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 22908ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner "Can only promote single result calls"); 22918ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner std::vector<MVT::ValueType> RetTyVTs; 22928ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.reserve(2); 22938ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(NVT); 22948ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(MVT::Other); 2295d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 2296d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 22978ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Result = SDOperand(NC, 0); 22988ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 22998ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner // Insert the new chain mapping. 23008ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 23018ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner break; 2302edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 2303fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2304fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2305fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2306fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = Node->getOperand(0); 2307fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Zero extend the argument 2308fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2309fecf095292991bdf9396fec474011446107f9813Andrew Lenharth // Perform the larger operation, then subtract if needed. 2310fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2311fecf095292991bdf9396fec474011446107f9813Andrew Lenharth switch(Node->getOpcode()) 2312fecf095292991bdf9396fec474011446107f9813Andrew Lenharth { 2313fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2314fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = Tmp1; 2315fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2316fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2317fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 2318d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 23197cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), ISD::SETEQ); 232000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 2321fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(VT),NVT), Tmp1); 2322fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2323fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2324fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 232500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 232600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 2327fecf095292991bdf9396fec474011446107f9813Andrew Lenharth getSizeInBits(VT), NVT)); 2328fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2329fecf095292991bdf9396fec474011446107f9813Andrew Lenharth } 2330fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 233103c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 233203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 233303c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.Val && "Didn't set a result!"); 233403c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddPromotedOperand(Op, Result); 233503c8546ec57523970874917854a2fb77b1ff598eChris Lattner return Result; 233603c8546ec57523970874917854a2fb77b1ff598eChris Lattner} 23373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 233884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// ExpandAddSub - Find a clever way to expand this add operation into 233984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// subcomponents. 23404759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattnervoid SelectionDAGLegalize:: 23414759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris LattnerExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 23424759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi) { 234384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner // Expand the subcomponents. 234484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 234584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(LHS, LHSL, LHSH); 234684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(RHS, RHSL, RHSH); 234784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 2348bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner // FIXME: this should be moved to the dag combiner someday. 2349e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner assert(NodeOp == ISD::ADD_PARTS || NodeOp == ISD::SUB_PARTS); 2350e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (LHSL.getValueType() == MVT::i32) { 2351e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner SDOperand LowEl; 2352e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(LHSL)) 2353e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (C->getValue() == 0) 2354e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner LowEl = RHSL; 2355e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHSL)) 2356e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (C->getValue() == 0) 2357e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner LowEl = LHSL; 2358e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (LowEl.Val) { 2359e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner // Turn this into an add/sub of the high part only. 2360e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner SDOperand HiEl = 2361e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner DAG.getNode(NodeOp == ISD::ADD_PARTS ? ISD::ADD : ISD::SUB, 2362e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner LowEl.getValueType(), LHSH, RHSH); 2363e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = LowEl; 2364e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Hi = HiEl; 2365e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner return; 2366bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner } 2367e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 2368bd0781ed12dd817f760065e3ac2dcff12fb29440Chris Lattner 236984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 237084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSL); 237184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSH); 237284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSL); 237384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSH); 2374e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner 2375e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2376e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 237784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Hi = Lo.getValue(1); 237884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner} 237984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 23805b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattnervoid SelectionDAGLegalize::ExpandShiftParts(unsigned NodeOp, 23815b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand Op, SDOperand Amt, 23825b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi) { 23835b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner // Expand the subcomponents. 23845b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand LHSL, LHSH; 23855b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandOp(Op, LHSL, LHSH); 23865b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 23875b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner std::vector<SDOperand> Ops; 23885b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSL); 23895b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSH); 23905b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(Amt); 2391cc0675a4be9a5133abd48ee272ff999ae48feabfChris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2392e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 23935b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Hi = Lo.getValue(1); 23945b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner} 23955b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 23965b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 2397e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// ExpandShift - Try to find a clever way to expand this shift operation out to 2398e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// smaller elements. If we can't find a way that is more efficient than a 2399e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// libcall on this target, return false. Otherwise, return true with the 2400e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// low-parts expanded into Lo and Hi. 2401e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattnerbool SelectionDAGLegalize::ExpandShift(unsigned Opc, SDOperand Op,SDOperand Amt, 2402e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi) { 2403e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner assert((Opc == ISD::SHL || Opc == ISD::SRA || Opc == ISD::SRL) && 2404e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner "This is not a shift!"); 2405f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2406e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(Op.getValueType()); 2407f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand ShAmt = LegalizeOp(Amt); 2408f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman MVT::ValueType ShTy = ShAmt.getValueType(); 2409f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned VTBits = MVT::getSizeInBits(Op.getValueType()); 2410f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned NVTBits = MVT::getSizeInBits(NVT); 2411f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 2412f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Handle the case when Amt is an immediate. Other cases are currently broken 2413f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and are disabled. 2414f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Amt.Val)) { 2415f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned Cst = CN->getValue(); 2416f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Expand the incoming operand to be shifted, so that we have its parts 2417f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand InL, InH; 2418f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman ExpandOp(Op, InL, InH); 2419f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman switch(Opc) { 2420f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SHL: 2421f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2422f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2423f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2424f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2425f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2426f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst-NVTBits,ShTy)); 2427ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2428ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = DAG.getConstant(0, NVT); 2429ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = InL; 2430f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2431f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst, ShTy)); 2432f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::OR, NVT, 2433f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(Cst, ShTy)), 2434f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(NVTBits-Cst, ShTy))); 2435f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2436f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2437f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRL: 2438f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2439f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 2440f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2441f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2442f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst-NVTBits,ShTy)); 2443f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 2444ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2445ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2446ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = DAG.getConstant(0, NVT); 2447f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2448f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2449f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2450f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2451f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst, ShTy)); 2452f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2453f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2454f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRA: 2455f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 2456edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 2457f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2458f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 2459edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Lo = DAG.getNode(ISD::SRA, NVT, InH, 2460f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(Cst-NVTBits, ShTy)); 2461edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2462f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 2463ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 2464ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 2465edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 2466ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2467f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 2468f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 2469f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 2470f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 2471f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Cst, ShTy)); 2472f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2473f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 2474f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2475f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 2476f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // FIXME: The following code for expanding shifts using ISD::SELECT is buggy, 2477f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // so disable it for now. Currently targets are handling this via SHL_PARTS 2478f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and friends. 2479f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return false; 2480e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2481e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we have an efficient select operation (or if the selects will all fold 2482e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // away), lower to some complex code, otherwise just emit the libcall. 2483c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::SELECT, NVT) && !isa<ConstantSDNode>(Amt)) 2484e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return false; 2485e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2486e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand InL, InH; 2487e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ExpandOp(Op, InL, InH); 2488e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand NAmt = DAG.getNode(ISD::SUB, ShTy, // NAmt = 32-ShAmt 2489e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits, ShTy), ShAmt); 2490e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2491e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner // Compare the unmasked shift amount against 32. 24927cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand Cond = DAG.getSetCC(TLI.getSetCCResultTy(), ShAmt, 24937cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(NVTBits, ShTy), ISD::SETGE); 2494e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner 2495e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getShiftAmountFlavor() != TargetLowering::Mask) { 2496e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ShAmt = DAG.getNode(ISD::AND, ShTy, ShAmt, // ShAmt &= 31 2497e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2498e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner NAmt = DAG.getNode(ISD::AND, ShTy, NAmt, // NAmt &= 31 2499e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2500e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2501e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2502e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (Opc == ISD::SHL) { 2503e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << Amt) | (Lo >> NAmt) 2504e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, ShAmt), 2505e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, NAmt)); 2506e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(ISD::SHL, NVT, InL, ShAmt); // T2 = Lo << Amt&31 2507edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2508e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2509e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, DAG.getConstant(0, NVT), T2); 2510e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } else { 251177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand HiLoPart = DAG.getNode(ISD::SELECT, NVT, 25127cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getSetCC(TLI.getSetCCResultTy(), NAmt, 25137cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(32, ShTy), 25147cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ), 251577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(0, NVT), 251677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, NAmt)); 2517e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << NAmt) | (Lo >> Amt) 251877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiLoPart, 2519e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, ShAmt)); 2520e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(Opc, NVT, InH, ShAmt); // T2 = InH >> ShAmt&31 2521e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2522e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand HiPart; 252377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Opc == ISD::SRA) 252477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiPart = DAG.getNode(ISD::SRA, NVT, InH, 252577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 2526e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner else 2527e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner HiPart = DAG.getConstant(0, NVT); 2528e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 2529e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, HiPart, T2); 2530e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 2531e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return true; 2532e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner} 253377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 25349530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindLatestCallSeqStart - Scan up the dag to find the latest (highest 25359530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqStart operation and occurs later than 25369c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// Found. 25379530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic void FindLatestCallSeqStart(SDNode *Node, SDNode *&Found) { 25389c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->getNodeDepth() <= Found->getNodeDepth()) return; 25392f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner 254016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_START, we already know this node occurs later 25419c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 254216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) { 25439c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 25449c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 25459c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 25469c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25479c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 25489c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(Node->getNumOperands() != 0 && 25499c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner "All leaves should have depth equal to the entry node!"); 25509c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = Node->getNumOperands()-1; i != e; ++i) 25519530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(i).Val, Found); 25529c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 25549530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(Node->getNumOperands()-1).Val, 25559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found); 25569c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 25579c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25589c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25599530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindEarliestCallSeqEnd - Scan down the dag to find the earliest (lowest 25609530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqEnd operation and occurs more recent 25619c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// than Found. 256282299e70977500209c951404e354510feffb8efaChris Lattnerstatic void FindEarliestCallSeqEnd(SDNode *Node, SDNode *&Found, 256382299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> &Visited) { 256482299e70977500209c951404e354510feffb8efaChris Lattner if ((Found && Node->getNodeDepth() >= Found->getNodeDepth()) || 256582299e70977500209c951404e354510feffb8efaChris Lattner !Visited.insert(Node).second) return; 25669c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 256716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_END, we already know this node occurs earlier 25689c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 256916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) { 25709c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 25719c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 25729c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 25739c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25749c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 25759c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end(); 25769c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (UI == E) return; 25779c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (--E; UI != E; ++UI) 257882299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 25799c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25809c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 258182299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 25829c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 25839c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25849530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqEnd - Given a chained node that is part of a call sequence, 258516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_END node that terminates the call sequence. 25869530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqEnd(SDNode *Node) { 258716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 25889c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return Node; 2589f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (Node->use_empty()) 25909530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return 0; // No CallSeqEnd 25919c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 25929c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (Node->hasOneUse()) // Simple case, only has one user to check. 25939530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqEnd(*Node->use_begin()); 2594edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 25959c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand TheChain(Node, Node->getNumValues()-1); 25962789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner if (TheChain.getValueType() != MVT::Other) 25972789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner TheChain = SDOperand(Node, 0); 25989c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(TheChain.getValueType() == MVT::Other && "Is not a token chain!"); 2599edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2600edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman for (SDNode::use_iterator UI = Node->use_begin(), 26012f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner E = Node->use_end(); UI != E; ++UI) { 2602edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 26039c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Make sure to only follow users of our token chain. 26049c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *User = *UI; 26059c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 26069c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (User->getOperand(i) == TheChain) 2607eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner if (SDNode *Result = FindCallSeqEnd(User)) 2608eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner return Result; 26099c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 26102f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner return 0; 26119c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 26129c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26139530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqStart - Given a chained node that is part of a call sequence, 261416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_START node that initiates the call sequence. 26159530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqStart(SDNode *Node) { 26169530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(Node && "Didn't find callseq_start for a call??"); 261716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 26180d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26190d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 26200d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner "Node doesn't have a token chain argument!"); 26219530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqStart(Node->getOperand(0).Val); 26220d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 26230d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26240d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26259c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// FindInputOutputChains - If we are replacing an operation with a call we need 26269c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// to find the call that occurs before and the call that occurs after it to 26270d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// properly serialize the calls in the block. The returned operand is the 26280d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// input chain value for the new call (e.g. the entry node or the previous 26290d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// call), and OutChain is set to be the chain node to update to point to the 26300d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// end of the call chain. 26319c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnerstatic SDOperand FindInputOutputChains(SDNode *OpNode, SDNode *&OutChain, 26329c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand Entry) { 26339530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqStart = Entry.Val; 26349530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqEnd = 0; 26359530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(OpNode, LatestCallSeqStart); 26369530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner //std::cerr<<"Found node: "; LatestCallSeqStart->dump(); std::cerr <<"\n"; 2637edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 263816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // It is possible that no ISD::CALLSEQ_START was found because there is no 2639c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman // previous call in the function. LatestCallStackDown may in that case be 264016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // the entry node itself. Do not attempt to find a matching CALLSEQ_END 264116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // unless LatestCallStackDown is an CALLSEQ_START. 26429530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner if (LatestCallSeqStart->getOpcode() == ISD::CALLSEQ_START) 26439530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = FindCallSeqEnd(LatestCallSeqStart); 2644c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman else 26459530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = Entry.Val; 26469530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(LatestCallSeqEnd && "NULL return from FindCallSeqEnd"); 2647edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 26480d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Finally, find the first call that this must come before, first we find the 26499530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // CallSeqEnd that ends the call. 26500d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain = 0; 265182299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> Visited; 265282299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(OpNode, OutChain, Visited); 26539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26549530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // If we found one, translate from the adj up to the callseq_start. 26550d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain) 26569530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner OutChain = FindCallSeqStart(OutChain); 26579c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26589530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return SDOperand(LatestCallSeqEnd, 0); 26599c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 26609c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 266100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen/// SpliceCallInto - Given the result chain of a libcall (CallResult), and a 2662b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattnervoid SelectionDAGLegalize::SpliceCallInto(const SDOperand &CallResult, 2663b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SDNode *OutChain) { 26640d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Nothing to splice it into? 26650d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain == 0) return; 26660d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26670d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(OutChain->getOperand(0).getValueType() == MVT::Other); 26680d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner //OutChain->dump(); 26690d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26700d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Form a token factor node merging the old inval and the new inval. 26710d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InToken = DAG.getNode(ISD::TokenFactor, MVT::Other, CallResult, 26720d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->getOperand(0)); 26730d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Change the node to refer to the new token. 26740d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->setAdjCallChain(InToken); 26750d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 26769c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 26779c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 267877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 267977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 268077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 268177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 268277e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize::ExpandLibCall(const char *Name, SDNode *Node, 268377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi) { 26849c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *OutChain; 26859c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand InChain = FindInputOutputChains(Node, OutChain, 26869c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner DAG.getEntryNode()); 2687f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (InChain.Val == 0) 2688f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner InChain = DAG.getEntryNode(); 26899c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 269077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 269177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 269277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner MVT::ValueType ArgVT = Node->getOperand(i).getValueType(); 269377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(ArgVT); 269477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Node->getOperand(i), ArgTy)); 269577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 269677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(Name, TLI.getPointerTy()); 2697edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 26980d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 269977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(Node->getValueType(0)); 27000d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallInfo = 2701adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, false, 2702adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 2703b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallInfo.second, OutChain); 2704b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 2705b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner NeedsAnotherIteration = true; 27060d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 27070d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner switch (getTypeAction(CallInfo.first.getValueType())) { 270877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner default: assert(0 && "Unknown thing"); 270977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Legal: 27100d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallInfo.first; 271177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Promote: 271277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(0 && "Cannot promote this yet!"); 271377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Expand: 271477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Lo; 27150d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner ExpandOp(CallInfo.first, Lo, Hi); 271677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner return Lo; 271777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 271877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 271977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 27209c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 272177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// ExpandIntToFP - Expand a [US]INT_TO_FP operation, assuming that the 272277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// destination type is legal. 272377e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize:: 272477e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) { 2725c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(DestTy) && "Destination type is not legal!"); 272677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(Source.getValueType()) == Expand && 272777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner "This is not an expansion!"); 272877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(Source.getValueType() == MVT::i64 && "Only handle expand from i64!"); 272977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 27300d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (!isSigned) { 2731e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(Source.getValueType() == MVT::i64 && 2732e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner "This only works for 64-bit -> FP"); 2733e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 2734e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // incoming integer is set. To handle this, we dynamically test to see if 2735e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // it is set, and, if so, add a fudge factor. 2736e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Lo, Hi; 2737e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner ExpandOp(Source, Lo, Hi); 2738e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 273966de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 274066de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // signed, then adjust the result if the sign bit is set. 274166de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner SDOperand SignedConv = ExpandIntToFP(true, DestTy, 274266de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), Lo, Hi)); 274366de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 27447cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Hi, 27457cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Hi.getValueType()), 27467cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 2747e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 2748e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 2749e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SignSet, Four, Zero); 2750383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner uint64_t FF = 0x5f800000ULL; 2751383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 2752383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 2753e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 27545839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 2755e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 2756e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand FudgeInReg; 2757e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner if (DestTy == MVT::f32) 275852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 275952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 2760e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner else { 2761e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(DestTy == MVT::f64 && "Unexpected conversion"); 27625f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 27635f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 2764e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 2765e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner return DAG.getNode(ISD::ADD, DestTy, SignedConv, FudgeInReg); 276677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 27670d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 2768a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 2769a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, Source.getValueType())) { 2770a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 2771a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Legal: 2772a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Expand: 2773a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner break; // This case is handled below. 277407dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 277507dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand NV = TLI.LowerOperation(DAG.getNode(ISD::SINT_TO_FP, DestTy, 277607dffd6af673c73352150583150b242a93694f00Chris Lattner Source), DAG); 277707dffd6af673c73352150583150b242a93694f00Chris Lattner if (NV.Val) 277807dffd6af673c73352150583150b242a93694f00Chris Lattner return LegalizeOp(NV); 277907dffd6af673c73352150583150b242a93694f00Chris Lattner break; // The target decided this was legal after all 278007dffd6af673c73352150583150b242a93694f00Chris Lattner } 2781a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 2782a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 278313689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // Expand the source, then glue it back together for the call. We must expand 278413689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // the source in case it is shared (this pass of legalize must traverse it). 278513689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner SDOperand SrcLo, SrcHi; 278613689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner ExpandOp(Source, SrcLo, SrcHi); 278713689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner Source = DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), SrcLo, SrcHi); 278813689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 27890d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDNode *OutChain = 0; 27900d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InChain = FindInputOutputChains(Source.Val, OutChain, 27910d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner DAG.getEntryNode()); 27920d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner const char *FnName = 0; 27930d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (DestTy == MVT::f32) 27940d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdisf"; 27950d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner else { 27960d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(DestTy == MVT::f64 && "Unknown fp value type!"); 27970d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdidf"; 27980d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 27990d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 280077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(FnName, TLI.getPointerTy()); 280177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 280277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 280377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(Source.getValueType()); 280444d105b7faf5672a2af61a3f0fdfed0d437d5777Chris Lattner 280577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Source, ArgTy)); 280677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 280777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // We don't care about token chains for libcalls. We just use the entry 280877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // node as our input and ignore the output chain. This allows us to place 280977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // calls wherever we need them to satisfy data dependences. 281077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(DestTy); 28110d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 28120d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 2813adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, true, 2814adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 28150d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 2816b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallResult.second, OutChain); 28170d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallResult.first; 281877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 2819edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2820e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2821e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 28223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandOp - Expand the specified SDOperand into its two component pieces 28233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo&Hi. Note that the Op MUST be an expanded type. As a result of this, the 28243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// LegalizeNodes map is filled in for any results that are not expanded, the 28253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandedNodes map is filled in for any results that are expanded, and the 28263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo/Hi values are returned. 28273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){ 28283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = Op.getValueType(); 282971c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 28303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDNode *Node = Op.Val; 28313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(VT) == Expand && "Not an expanded type!"); 28323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::isInteger(VT) && "Cannot expand FP values!"); 28333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(MVT::isInteger(NVT) && NVT < VT && 28343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand to FP value or to larger int value!"); 28353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 28363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If there is more than one use of this, see if we already expanded it. 28373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // There is no use remembering values that only have a single use, as the map 28383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // entries will never be reused. 28393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!Node->hasOneUse()) { 28403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I 28413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner = ExpandedNodes.find(Op); 28423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (I != ExpandedNodes.end()) { 28433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = I->second.first; 28443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = I->second.second; 28453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return; 28463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 284745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner } else { 284845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner assert(!ExpandedNodes.count(Op) && "Re-expanding a node!"); 28493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 28503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 28514e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // Expanding to multiple registers needs to perform an optimization step, and 28524e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // is not careful to avoid operations the target does not support. Make sure 28534e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // that all generated operations are legalized in the next iteration. 28544e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NeedsAnotherIteration = true; 28553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 28563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 2857d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2858d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 2859d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner default: 28603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 28613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to expand this operator!"); 28623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 2863fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2864fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Lo = DAG.getNode(ISD::UNDEF, NVT); 2865fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Hi = DAG.getNode(ISD::UNDEF, NVT); 2866fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 28673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: { 28683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner uint64_t Cst = cast<ConstantSDNode>(Node)->getValue(); 28693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getConstant(Cst, NVT); 28703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT); 28713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 28723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 28733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2874d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner case ISD::BUILD_PAIR: 2875d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // Legalize both operands. FIXME: in the future we should handle the case 2876d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // where the two elements are not legal. 2877d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 2878d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Lo = LegalizeOp(Node->getOperand(0)); 2879d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Hi = LegalizeOp(Node->getOperand(1)); 2880d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner break; 2881d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner 2882edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner case ISD::CTPOP: 2883edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 28849b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner Lo = DAG.getNode(ISD::ADD, NVT, // ctpop(HL) -> ctpop(H)+ctpop(L) 28859b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Lo), 28869b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Hi)); 2887edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getConstant(0, NVT); 2888edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner break; 2889edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 289039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTLZ: { 289139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // ctlz (HL) -> ctlz(H) != 32 ? ctlz(H) : (ctlz(L)+32) 28923becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 289339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 289439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 28957cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand TopNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), HLZ, BitsC, 28967cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 289739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LowPart = DAG.getNode(ISD::CTLZ, NVT, Lo); 289839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LowPart = DAG.getNode(ISD::ADD, NVT, LowPart, BitsC); 289939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 290039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, TopNotZero, HLZ, LowPart); 290139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 290239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 290339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 290439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 290539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTTZ: { 290639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // cttz (HL) -> cttz(L) != 32 ? cttz(L) : (cttz(H)+32) 29073becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 290839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 290939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LTZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 29107cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand BotNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), LTZ, BitsC, 29117cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 291239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HiPart = DAG.getNode(ISD::CTTZ, NVT, Hi); 291339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HiPart = DAG.getNode(ISD::ADD, NVT, HiPart, BitsC); 291439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 291539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, BotNotZero, LTZ, HiPart); 291639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 291739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 291839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 2919edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 29203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: { 29213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 29223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 29232d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Lo = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 29243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Increment the pointer to the other half. 292638d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner unsigned IncrementSize = MVT::getSizeInBits(Lo.getValueType())/8; 29273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 29283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 292900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen //Is this safe? declaring that the two parts of the split load 29302d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //are from the same instruction? 29312d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Hi = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 2932ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner 2933ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Build a factor node to remember that this load is independent of the 2934ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // other one. 2935ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 2936ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi.getValue(1)); 2937edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 29383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember that we legalized the chain. 2939ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner AddLegalizedOperand(Op.getValue(1), TF); 29403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 29413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 29423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 2944d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 29453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CALL: { 29463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 29473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Callee = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 29483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29493d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 29503d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 29513d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 29523d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 29533d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 29543d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 29553d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 29563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 29573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Can only expand a call once so far, not i64 -> i16!"); 29583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 29603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(3); 29613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 29623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 29633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(MVT::Other); 2964d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Chain, Callee, Ops, 2965d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 29663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = SDOperand(NC, 0); 29673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = SDOperand(NC, 1); 29683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Insert the new chain mapping. 2970e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner AddLegalizedOperand(Op.getValue(1), Hi.getValue(2)); 29713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 29733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 29743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 29753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: { // Simple logical operators -> two trivial pieces. 29763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LL, LH, RL, RH; 29773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LL, LH); 29783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RL, RH); 29793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(Node->getOpcode(), NVT, LL, RL); 29803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(Node->getOpcode(), NVT, LH, RH); 29813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 29823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 29833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SELECT: { 29843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand C, LL, LH, RL, RH; 298547e9223e06390897c3834f8c527001df392570ffChris Lattner 298647e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 298747e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 298847e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 298947e9223e06390897c3834f8c527001df392570ffChris Lattner C = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 299047e9223e06390897c3834f8c527001df392570ffChris Lattner break; 299147e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 299247e9223e06390897c3834f8c527001df392570ffChris Lattner C = PromoteOp(Node->getOperand(0)); // Promote the condition. 299347e9223e06390897c3834f8c527001df392570ffChris Lattner break; 299447e9223e06390897c3834f8c527001df392570ffChris Lattner } 29953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), LL, LH); 29963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(2), RL, RH); 29973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, C, LL, RL); 29983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, C, LH, RH); 29993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 30003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 30019373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: { 30029373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand TL, TH, FL, FH; 30039373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(2), TL, TH); 30049373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(3), FL, FH); 30059373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Lo = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 30069373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TL, FL, Node->getOperand(4)); 30079373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Hi = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 30089373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TH, FH, Node->getOperand(4)); 3009e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Lo = LegalizeOp(Lo); 3010e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Hi = LegalizeOp(Hi); 30119373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 30129373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 30133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: { 301406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 301506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 301606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 301706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 301806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 301906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 302006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate sign_extend_inreg to get the value we want. 302106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), In, 302215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 302306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 302406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 302506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 30263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a sign extension of the input (which degenerates to 30273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 302806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, In); 3029edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 30303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is obtained by SRA'ing all but one of the bits of the lo 30313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // part. 30322dad454af674cb41a14a85ad6ce5c85c43959acdChris Lattner unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 303327ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 303427ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner TLI.getShiftAmountTy())); 30353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 30363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 303706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case ISD::ZERO_EXTEND: { 303806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 303906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 304006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 304106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 304206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 304306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 304406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate zero_extend_inreg to get the value we want. 304523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner In = DAG.getZeroExtendInReg(In, Node->getOperand(0).getValueType()); 304606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 304706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 304806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 30493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a zero extension of the input (which degenerates to 30503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 3051dea29e25c32d2651e2efaff67bc30803ea24d991Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, In); 3052edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 30533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is just a zero. 30543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(0, NVT); 30553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 305606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 30574e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // These operators cannot be expanded directly, emit them as calls to 30584e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // library functions. 30594e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_SINT: 306080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_SINT, VT) == TargetLowering::Custom) { 3061f20d183c2268553c738fefb014959ea924dd0555Chris Lattner SDOperand Op; 3062f20d183c2268553c738fefb014959ea924dd0555Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 3063f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Expand: assert(0 && "cannot expand FP!"); 3064f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Legal: Op = LegalizeOp(Node->getOperand(0)); break; 3065f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Promote: Op = PromoteOp(Node->getOperand(0)); break; 3066f20d183c2268553c738fefb014959ea924dd0555Chris Lattner } 3067d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3068f20d183c2268553c738fefb014959ea924dd0555Chris Lattner Op = TLI.LowerOperation(DAG.getNode(ISD::FP_TO_SINT, VT, Op), DAG); 3069f20d183c2268553c738fefb014959ea924dd0555Chris Lattner 307080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 307180a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 307207dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 307307dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 307407dffd6af673c73352150583150b242a93694f00Chris Lattner break; 307507dffd6af673c73352150583150b242a93694f00Chris Lattner } 307680a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3077d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 30784e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 307977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixsfdi", Node, Hi); 30804e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 308177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixdfdi", Node, Hi); 30824e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 3083d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 30844e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_UINT: 308580a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_UINT, VT) == TargetLowering::Custom) { 308680a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner SDOperand Op = DAG.getNode(ISD::FP_TO_UINT, VT, 308780a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner LegalizeOp(Node->getOperand(0))); 308880a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 308980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 309007dffd6af673c73352150583150b242a93694f00Chris Lattner Op = TLI.LowerOperation(Op, DAG); 309107dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 309207dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 309307dffd6af673c73352150583150b242a93694f00Chris Lattner break; 309407dffd6af673c73352150583150b242a93694f00Chris Lattner } 309580a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3096d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 30974e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 309877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunssfdi", Node, Hi); 30994e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 310077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunsdfdi", Node, Hi); 31014e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 31024e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner 3103e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SHL: 310450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 310550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SHL, VT) == TargetLowering::Custom) { 310650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SHL, VT, Node->getOperand(0), 310750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 310850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 310950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 311050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 311150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 311250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 311350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 311450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 311550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 311650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3117e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 311877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SHL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3119e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 31204759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 31214759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SHL_PARTS, use it. 3122c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SHL_PARTS, NVT)) { 31235b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SHL_PARTS, Node->getOperand(0), Node->getOperand(1), 31245b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 31254759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 31264759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 31274759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3128e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 312977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashldi3", Node, Hi); 3130e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3131e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3132e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRA: 313350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 313450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRA, VT) == TargetLowering::Custom) { 313550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRA, VT, Node->getOperand(0), 313650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 313750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 313850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 313950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 314050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 314150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 314250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 314350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 314450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 314550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3146e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 314777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRA, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3148e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 31494759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 31504759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRA_PARTS, use it. 3151c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRA_PARTS, NVT)) { 31525b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRA_PARTS, Node->getOperand(0), Node->getOperand(1), 31535b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 31544759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 31554759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 31564759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3157e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 315877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashrdi3", Node, Hi); 3159e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3160e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner case ISD::SRL: 316150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 316250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRL, VT) == TargetLowering::Custom) { 316350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRL, VT, Node->getOperand(0), 316450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 316550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 316650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 316750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 316850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 316950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 317050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 317150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 317250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 317350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3174e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 317577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3176e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 31774759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 31784759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRL_PARTS, use it. 3179c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::SRL_PARTS, NVT)) { 31805b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRL_PARTS, Node->getOperand(0), Node->getOperand(1), 31815b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 31824759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 31834759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 31844759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3185e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 318677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__lshrdi3", Node, Hi); 3187e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 3188e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3189edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case ISD::ADD: 31904759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::ADD_PARTS, Node->getOperand(0), Node->getOperand(1), 31914759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 319284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 319384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::SUB: 31944759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::SUB_PARTS, Node->getOperand(0), Node->getOperand(1), 31954759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 319684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 3197c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MUL: { 3198c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::MULHU, NVT)) { 3199c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman SDOperand LL, LH, RL, RH; 3200c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3201c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 320256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman unsigned SH = MVT::getSizeInBits(RH.getValueType())-1; 320356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // MULHS implicitly sign extends its inputs. Check to see if ExpandOp 320456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // extended the sign bit of the low half through the upper half, and if so 320556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // emit a MULHS instead of the alternate sequence that is valid for any 320656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // i64 x i64 multiply. 320756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman if (TLI.isOperationLegal(ISD::MULHS, NVT) && 320856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is RH an extension of the sign bit of RL? 320956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOpcode() == ISD::SRA && RH.getOperand(0) == RL && 321056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOperand(1).getOpcode() == ISD::Constant && 321156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(RH.getOperand(1))->getValue() == SH && 321256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is LH an extension of the sign bit of LL? 321356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOpcode() == ISD::SRA && LH.getOperand(0) == LL && 321456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOperand(1).getOpcode() == ISD::Constant && 321556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(LH.getOperand(1))->getValue() == SH) { 321656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHS, NVT, LL, RL); 321756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } else { 321856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 321956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 322056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 322156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 322256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 322356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } 3224c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 3225c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } else { 3226c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = ExpandLibCall("__muldi3" , Node, Hi); break; 3227c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 3228c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman break; 3229c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 323077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SDIV: Lo = ExpandLibCall("__divdi3" , Node, Hi); break; 323177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UDIV: Lo = ExpandLibCall("__udivdi3", Node, Hi); break; 323277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SREM: Lo = ExpandLibCall("__moddi3" , Node, Hi); break; 323377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UREM: Lo = ExpandLibCall("__umoddi3", Node, Hi); break; 32343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 32353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember in a map if the values will be reused later. 32373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!Node->hasOneUse()) { 32383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isNew = ExpandedNodes.insert(std::make_pair(Op, 32393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::make_pair(Lo, Hi))).second; 32403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isNew && "Value already expanded?!?"); 32413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 32423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 32433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 32453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 32463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 32479c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnervoid SelectionDAG::Legalize() { 32483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 32493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 32509c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(*this).Run(); 32513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 32523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3253