LegalizeDAG.cpp revision de387ce81024f9be0ca523e9487b1aafeb95fa22
13e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===-- LegalizeDAG.cpp - Implement SelectionDAG::Legalize ----------------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 33e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// The LLVM Compiler Infrastructure 43e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 53e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file was developed by the LLVM research group and is distributed under 63e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 83e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 93e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file implements the SelectionDAG::Legalize method. 113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/MachineFunction.h" 1645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 1702659d23637f69f90640bfa3e66919517103c57aJim Laskey#include "llvm/Support/MathExtras.h" 183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Target/TargetLowering.h" 19e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner#include "llvm/Target/TargetData.h" 200f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner#include "llvm/Target/TargetOptions.h" 21adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Constants.h" 233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include <iostream> 2482299e70977500209c951404e354510feffb8efaChris Lattner#include <set> 253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerusing namespace llvm; 263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// SelectionDAGLegalize - This takes an arbitrary SelectionDAG as input and 293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// hacks on it until the target machine can handle it. This involves 303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating value sizes the machine cannot handle (promoting small sizes to 313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// large sizes or splitting up large values into small values) as well as 323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating operations the machine cannot handle. 333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// This code also does a small amount of optimization and recognition of idioms 353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// as part of its processing. For example, if a target does not support a 363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 'setcc' instruction efficiently, but does support 'brcc' instruction, this 373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// will attempt merge setcc and brc instructions into brcc's. 383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnernamespace { 403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerclass SelectionDAGLegalize { 413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner TargetLowering &TLI; 423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SelectionDAG &DAG; 433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizeAction - This enum indicates what action we should take for each 453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type the can occur in the program. 463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner enum LegalizeAction { 473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Legal, // The target natively supports this value type. 483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Promote, // This should be promoted to the next larger type. 493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Expand, // This integer type should be broken into smaller pieces. 503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner }; 513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ValueTypeActions - This is a bitvector that contains two bits for each 533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type, where the two bits correspond to the LegalizeAction enum. 543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// This can be queried with "getTypeAction(VT)". 556a648614e88586e85a36ceb5c1d3b84e4f55b458Nate Begeman unsigned long long ValueTypeActions; 563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// NeedsAnotherIteration - This is set when we expand a large integer 583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// operation into smaller integer operations, but the smaller operations are 593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// not set. This occurs only rarely in practice, for targets that don't have 603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 32-bit or larger integer registers. 613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool NeedsAnotherIteration; 623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizedNodes - For nodes that are of legal width, and that have more 643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates what regularized operand to use. This 653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// allows us to avoid legalizing the same thing more than once. 663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, SDOperand> LegalizedNodes; 673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 6803c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// PromotedNodes - For nodes that are below legal width, and that have more 6903c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// than one use, this map indicates what promoted value to use. This allows 7003c8546ec57523970874917854a2fb77b1ff598eChris Lattner /// us to avoid promoting the same thing more than once. 7103c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::map<SDOperand, SDOperand> PromotedNodes; 7203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ExpandedNodes - For nodes that need to be expanded, and which have more 743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates which which operands are the expanded 753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// version of the input. This allows us to avoid expanding the same node 763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// more than once. 773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> > ExpandedNodes; 783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 798afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner void AddLegalizedOperand(SDOperand From, SDOperand To) { 8069a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner LegalizedNodes.insert(std::make_pair(From, To)); 8169a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner // If someone requests legalization of the new node, return itself. 8269a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner if (From != To) 8369a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner LegalizedNodes.insert(std::make_pair(To, To)); 848afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner } 8503c8546ec57523970874917854a2fb77b1ff598eChris Lattner void AddPromotedOperand(SDOperand From, SDOperand To) { 8603c8546ec57523970874917854a2fb77b1ff598eChris Lattner bool isNew = PromotedNodes.insert(std::make_pair(From, To)).second; 8703c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isNew && "Got into the map somehow?"); 8869a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner // If someone requests legalization of the new node, return itself. 8969a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner LegalizedNodes.insert(std::make_pair(To, To)); 9003c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 918afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner 923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerpublic: 933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 949c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(SelectionDAG &DAG); 953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Run - While there is still lowering to do, perform a pass over the DAG. 973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// Most regularization can be done in a single pass, but targets that require 983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// large values to be split into registers multiple times (e.g. i64 -> 4x 993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// i16) require iteration for these values (the first iteration will demote 1003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// to i32, the second will demote to i16). 1013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void Run() { 1023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner do { 1033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NeedsAnotherIteration = false; 1043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeDAG(); 1053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } while (NeedsAnotherIteration); 1063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// getTypeAction - Return how we should legalize values of this type, either 1093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// it is already legal or we need to expand it into multiple registers of 1103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// smaller integer type, or we need to promote it to a larger type. 1113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizeAction getTypeAction(MVT::ValueType VT) const { 1123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return (LegalizeAction)((ValueTypeActions >> (2*VT)) & 3); 1133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// isTypeLegal - Return true if this type is legal on this target. 1163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 1173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isTypeLegal(MVT::ValueType VT) const { 1183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return getTypeAction(VT) == Legal; 1193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerprivate: 1223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void LegalizeDAG(); 1233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LegalizeOp(SDOperand O); 1253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void ExpandOp(SDOperand O, SDOperand &Lo, SDOperand &Hi); 12603c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand PromoteOp(SDOperand O); 1273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandLibCall(const char *Name, SDNode *Node, 12977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi); 13077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand ExpandIntToFP(bool isSigned, MVT::ValueType DestTy, 13177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Source); 132cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 13335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner SDOperand ExpandBIT_CONVERT(MVT::ValueType DestVT, SDOperand SrcOp); 1346269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand ExpandLegalINT_TO_FP(bool isSigned, 1356269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand LegalOp, 1366269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT); 1375a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman SDOperand PromoteLegalINT_TO_FP(SDOperand LegalOp, MVT::ValueType DestVT, 1385a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned); 1391618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner SDOperand PromoteLegalFP_TO_INT(SDOperand LegalOp, MVT::ValueType DestVT, 1401618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned); 14100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 142e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner bool ExpandShift(unsigned Opc, SDOperand Op, SDOperand Amt, 143e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi); 1445b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandShiftParts(unsigned NodeOp, SDOperand Op, SDOperand Amt, 1455b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi); 1465b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner void ExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 1474759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi); 148e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 149b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner void SpliceCallInto(const SDOperand &CallResult, SDNode *OutChain); 150b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner 1513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 1523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 1533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner}; 1553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 157b89175feffa7148c05d1d30a8e382b8d321edae5Chris Lattnerstatic unsigned getScalarizedOpcode(unsigned VecOp, MVT::ValueType VT) { 1585fbb5d2459a5410590f285250faa604576308a93Nate Begeman switch (VecOp) { 1595fbb5d2459a5410590f285250faa604576308a93Nate Begeman default: assert(0 && "Don't know how to scalarize this opcode!"); 1605fbb5d2459a5410590f285250faa604576308a93Nate Begeman case ISD::VADD: return MVT::isInteger(VT) ? ISD::ADD : ISD::FADD; 1615fbb5d2459a5410590f285250faa604576308a93Nate Begeman case ISD::VSUB: return MVT::isInteger(VT) ? ISD::SUB : ISD::FSUB; 1625fbb5d2459a5410590f285250faa604576308a93Nate Begeman case ISD::VMUL: return MVT::isInteger(VT) ? ISD::MUL : ISD::FMUL; 1635fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1645fbb5d2459a5410590f285250faa604576308a93Nate Begeman} 1653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1669c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris LattnerSelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag) 1679c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner : TLI(dag.getTargetLoweringInfo()), DAG(dag), 1689c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner ValueTypeActions(TLI.getValueTypeActions()) { 1696a648614e88586e85a36ceb5c1d3b84e4f55b458Nate Begeman assert(MVT::LAST_VALUETYPE <= 32 && 1703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Too many value types for ValueTypeActions to hold!"); 1713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1736269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// ExpandLegalINT_TO_FP - This function is responsible for legalizing a 1746269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey/// INT_TO_FP operation of the specified operand when the target requests that 175cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we expand it. At this point, we know that the result and operand types are 176cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target. 1776269ed125fc492d81dc5e3f48482816fc9d47f49Jim LaskeySDOperand SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned, 1786269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0, 1796269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::ValueType DestVT) { 1806269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (Op0.getValueType() == MVT::i32) { 1816269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // simple 32-bit [signed|unsigned] integer to float/double expansion 1826269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey 1836269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get the stack frame index of a 8 byte buffer 1846269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MachineFunction &MF = DAG.getMachineFunction(); 1856269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey int SSFI = MF.getFrameInfo()->CreateStackObject(8, 8); 1866269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // get address of 8 byte buffer 1876269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 1886269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // word offset constant for Hi/Lo address computation 1896269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy()); 1906269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // set up Hi and Lo (into buffer) address based on endian 1916269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Hi, Lo; 1926269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (TLI.isLittleEndian()) { 1936269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1946269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = StackSlot; 1956269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 1966269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Hi = StackSlot; 1976269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Lo = DAG.getNode(ISD::ADD, TLI.getPointerTy(), StackSlot, WordOff); 1986269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 1996269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if signed map to unsigned space 2006269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Op0Mapped; 2016269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (isSigned) { 2026269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // constant used to invert sign bit (signed to unsigned mapping) 2036269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand SignBit = DAG.getConstant(0x80000000u, MVT::i32); 2046269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = DAG.getNode(ISD::XOR, MVT::i32, Op0, SignBit); 2056269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 2066269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped = Op0; 2076269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2086269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the lo of the constructed double - based on integer input 2096269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store1 = DAG.getNode(ISD::STORE, MVT::Other, DAG.getEntryNode(), 2106269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Op0Mapped, Lo, DAG.getSrcValue(NULL)); 2116269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // initial hi portion of constructed double 2126269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand InitialHi = DAG.getConstant(0x43300000u, MVT::i32); 2136269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // store the hi of the constructed double - biased exponent 2146269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Store2 = DAG.getNode(ISD::STORE, MVT::Other, Store1, 2156269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey InitialHi, Hi, DAG.getSrcValue(NULL)); 2166269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // load the constructed double 2176269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Load = DAG.getLoad(MVT::f64, Store2, StackSlot, 2186269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey DAG.getSrcValue(NULL)); 2196269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // FP constant to bias correct the final result 22002659d23637f69f90640bfa3e66919517103c57aJim Laskey SDOperand Bias = DAG.getConstantFP(isSigned ? 22102659d23637f69f90640bfa3e66919517103c57aJim Laskey BitsToDouble(0x4330000080000000ULL) 22202659d23637f69f90640bfa3e66919517103c57aJim Laskey : BitsToDouble(0x4330000000000000ULL), 2236269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey MVT::f64); 2246269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // subtract the bias 22501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Sub = DAG.getNode(ISD::FSUB, MVT::f64, Load, Bias); 2266269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // final result 2276269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey SDOperand Result; 2286269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // handle final rounding 2296269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey if (DestVT == MVT::f64) { 2306269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // do nothing 2316269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = Sub; 2326269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } else { 2336269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // if f32 then cast to f32 2346269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = DAG.getNode(ISD::FP_ROUND, MVT::f32, Sub); 2356269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 23669a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner return LegalizeOp(Result); 2376269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey } 2386269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey assert(!isSigned && "Legalize cannot Expand SINT_TO_FP for i64 yet"); 239cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Tmp1 = DAG.getNode(ISD::SINT_TO_FP, DestVT, Op0); 24000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2417cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Op0, 2427cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Op0.getValueType()), 2437cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 244cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 245cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 246cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SignSet, Four, Zero); 24700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2486269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // If the sign bit of the integer is set, the large number will be treated 2496269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // as a negative number. To counteract this, the dynamic code adds an 2506269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey // offset depending on the data type. 251f4d32726e622c740b4befc803e604903eb1349dfChris Lattner uint64_t FF; 252f4d32726e622c740b4befc803e604903eb1349dfChris Lattner switch (Op0.getValueType()) { 253f4d32726e622c740b4befc803e604903eb1349dfChris Lattner default: assert(0 && "Unsupported integer type!"); 254f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i8 : FF = 0x43800000ULL; break; // 2^8 (as a float) 255f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i16: FF = 0x47800000ULL; break; // 2^16 (as a float) 256f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i32: FF = 0x4F800000ULL; break; // 2^32 (as a float) 257f4d32726e622c740b4befc803e604903eb1349dfChris Lattner case MVT::i64: FF = 0x5F800000ULL; break; // 2^64 (as a float) 258f4d32726e622c740b4befc803e604903eb1349dfChris Lattner } 259cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 260cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 26100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 2625839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 263cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 264cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner SDOperand FudgeInReg; 265cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (DestVT == MVT::f32) 266cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 267cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL)); 268cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner else { 269cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(DestVT == MVT::f64 && "Unexpected conversion"); 270cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner FudgeInReg = LegalizeOp(DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, 271cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getEntryNode(), CPIdx, 272cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner DAG.getSrcValue(NULL), MVT::f32)); 273cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 27400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 27569a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner return LegalizeOp(DAG.getNode(ISD::FADD, DestVT, Tmp1, FudgeInReg)); 276cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 277cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 278149c58ce0b94e64faf3c4ccdbf894061cf7d66e1Chris Lattner/// PromoteLegalINT_TO_FP - This function is responsible for legalizing a 2791618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// *INT_TO_FP operation of the specified operand when the target requests that 280cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// we promote it. At this point, we know that the result and operand types are 281cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// legal for the target, and that there is a legal UINT_TO_FP or SINT_TO_FP 282cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner/// operation that takes a larger input. 2835a8441ea3fc145393d6274156bd05c4a006099eaNate BegemanSDOperand SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDOperand LegalOp, 2845a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman MVT::ValueType DestVT, 2855a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman bool isSigned) { 286cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // First step, figure out the appropriate *INT_TO_FP operation to use. 287cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner MVT::ValueType NewInTy = LegalOp.getValueType(); 28800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 289cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner unsigned OpToUse = 0; 29000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 291cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Scan for the appropriate larger type to use. 292cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner while (1) { 293cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner NewInTy = (MVT::ValueType)(NewInTy+1); 294cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner assert(MVT::isInteger(NewInTy) && "Ran out of possibilities!"); 29500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 296cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports SINT_TO_FP of this type, use it. 297cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, NewInTy)) { 298cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 299cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 300c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewInTy)) 301cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 302cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 303cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 304cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::SINT_TO_FP; 305cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 306cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 307cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 3085a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman if (isSigned) continue; 30900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 310cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // If the target supports UINT_TO_FP of this type, use it. 311cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner switch (TLI.getOperationAction(ISD::UINT_TO_FP, NewInTy)) { 312cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner default: break; 313cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Legal: 314c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewInTy)) 315cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; // Can't use this datatype. 316cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // FALL THROUGH. 317cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner case TargetLowering::Custom: 318cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner OpToUse = ISD::UINT_TO_FP; 319cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner break; 320cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 321cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner if (OpToUse) break; 32200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 323cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Otherwise, try a larger type. 324cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner } 325cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 326cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // Okay, we found the operation and type to use. Zero extend our input to the 327cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner // desired type then run the operation on it. 32869a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner SDOperand N = DAG.getNode(OpToUse, DestVT, 3295a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, 3305a8441ea3fc145393d6274156bd05c4a006099eaNate Begeman NewInTy, LegalOp)); 33169a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner // Make sure to legalize any nodes we create here. 33269a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner return LegalizeOp(N); 333cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner} 334cad063f1a8ecda4fd556a733dc5eaa8a96acb80dChris Lattner 3351618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// PromoteLegalFP_TO_INT - This function is responsible for legalizing a 3361618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// FP_TO_*INT operation of the specified operand when the target requests that 3371618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// we promote it. At this point, we know that the result and operand types are 3381618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// legal for the target, and that there is a legal FP_TO_UINT or FP_TO_SINT 3391618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner/// operation that returns a larger result. 3401618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris LattnerSDOperand SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDOperand LegalOp, 3411618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType DestVT, 3421618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner bool isSigned) { 3431618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // First step, figure out the appropriate FP_TO*INT operation to use. 3441618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner MVT::ValueType NewOutTy = DestVT; 345d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3461618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner unsigned OpToUse = 0; 347d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3481618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Scan for the appropriate larger type to use. 3491618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner while (1) { 3501618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner NewOutTy = (MVT::ValueType)(NewOutTy+1); 3511618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner assert(MVT::isInteger(NewOutTy) && "Ran out of possibilities!"); 352d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3531618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_SINT returning this type, use it. 3541618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_SINT, NewOutTy)) { 3551618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3561618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 357c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewOutTy)) 3581618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3591618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3601618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3611618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_SINT; 3621618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3631618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3641618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 365d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3661618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // If the target supports FP_TO_UINT of this type, use it. 3671618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(ISD::FP_TO_UINT, NewOutTy)) { 3681618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: break; 3691618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 370c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isTypeLegal(NewOutTy)) 3711618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; // Can't use this datatype. 3721618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // FALL THROUGH. 3731618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Custom: 3741618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner OpToUse = ISD::FP_TO_UINT; 3751618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 3761618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3771618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner if (OpToUse) break; 378d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3791618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Otherwise, try a larger type. 3801618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 381d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3821618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // Okay, we found the operation and type to use. Truncate the result of the 3831618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner // extended FP_TO_*INT operation to the desired size. 38469a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner SDOperand N = DAG.getNode(ISD::TRUNCATE, DestVT, 38569a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner DAG.getNode(OpToUse, NewOutTy, LegalOp)); 38669a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner // Make sure to legalize any nodes we create here in the next pass. 38769a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner return LegalizeOp(N); 3881618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner} 3891618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 39032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner/// ComputeTopDownOrdering - Add the specified node to the Order list if it has 39132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner/// not been visited yet and if all of its operands have already been visited. 39232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattnerstatic void ComputeTopDownOrdering(SDNode *N, std::vector<SDNode*> &Order, 39332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::map<SDNode*, unsigned> &Visited) { 39432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner if (++Visited[N] != N->getNumOperands()) 39532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner return; // Haven't visited all operands yet 39632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 39732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner Order.push_back(N); 39832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 39932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner if (N->hasOneUse()) { // Tail recurse in common case. 40032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ComputeTopDownOrdering(*N->use_begin(), Order, Visited); 40132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner return; 40232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 40332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 40432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Now that we have N in, add anything that uses it if all of their operands 40532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // are now done. 40632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (SDNode::use_iterator UI = N->use_begin(), E = N->use_end(); UI != E;++UI) 40732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ComputeTopDownOrdering(*UI, Order, Visited); 40832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner} 40932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 4101618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner 4113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 412ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // The legalize process is inherently a bottom-up recursive process (users 413ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // legalize their uses before themselves). Given infinite stack space, we 414ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // could just start legalizing on the root and traverse the whole graph. In 415ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // practice however, this causes us to run out of stack space on large basic 41632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // blocks. To avoid this problem, compute an ordering of the nodes where each 41732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // node is only legalized after all of its operands are legalized. 41832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::map<SDNode*, unsigned> Visited; 41932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner std::vector<SDNode*> Order; 420ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 42132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Compute ordering from all of the leaves in the graphs, those (like the 42232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // entry node) that have no operands. 42332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (SelectionDAG::allnodes_iterator I = DAG.allnodes_begin(), 42432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner E = DAG.allnodes_end(); I != E; ++I) { 425de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner if (I->getNumOperands() == 0) { 426de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner Visited[I] = 0 - 1U; 427de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner ComputeTopDownOrdering(I, Order, Visited); 428ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner } 429ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner } 430ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 431de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner assert(Order.size() == Visited.size() && 432de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner Order.size() == 433de202b3cda00f17ba2c047be7270b51f9585a413Chris Lattner (unsigned)std::distance(DAG.allnodes_begin(), DAG.allnodes_end()) && 43432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner "Error: DAG is cyclic!"); 43532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner Visited.clear(); 436ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner 43732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner for (unsigned i = 0, e = Order.size(); i != e; ++i) { 43832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner SDNode *N = Order[i]; 43932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner switch (getTypeAction(N->getValueType(0))) { 44032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner default: assert(0 && "Bad type action!"); 44132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Legal: 44232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner LegalizeOp(SDOperand(N, 0)); 44332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 44432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Promote: 44532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner PromoteOp(SDOperand(N, 0)); 44632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 44732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case Expand: { 44832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner SDOperand X, Y; 44932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner ExpandOp(SDOperand(N, 0), X, Y); 45032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner break; 45132fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 45232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 45332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner } 45432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 45532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Finally, it's possible the root changed. Get the new root. 4563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand OldRoot = DAG.getRoot(); 45732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner assert(LegalizedNodes.count(OldRoot) && "Root didn't get legalized?"); 45832fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner DAG.setRoot(LegalizedNodes[OldRoot]); 4593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandedNodes.clear(); 4613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizedNodes.clear(); 46271c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner PromotedNodes.clear(); 4633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remove dead nodes now. 46562fd269c146d9023efe32644e44cd97b88631d4fChris Lattner DAG.RemoveDeadNodes(OldRoot.Val); 4663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 4673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris LattnerSDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { 469c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Op.getValueType()) && 470e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner "Caller should expand or promote operands that are not legal!"); 47145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner SDNode *Node = Op.Val; 472e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 4733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If this operation defines any values that cannot be represented in a 474e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner // register on this target, make sure to expand or promote them. 47545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner if (Node->getNumValues() > 1) { 47645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 47745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner switch (getTypeAction(Node->getValueType(i))) { 4783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: break; // Nothing to do. 4793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 4803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand T1, T2; 4813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Op.getValue(i), T1, T2); 4823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(LegalizedNodes.count(Op) && 4833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Expansion didn't add legal operands!"); 4843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return LegalizedNodes[Op]; 4853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 48703c8546ec57523970874917854a2fb77b1ff598eChris Lattner PromoteOp(Op.getValue(i)); 48803c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(LegalizedNodes.count(Op) && 48903c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Expansion didn't add legal operands!"); 49003c8546ec57523970874917854a2fb77b1ff598eChris Lattner return LegalizedNodes[Op]; 4913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 4933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 49445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 49545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 496e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::map<SDOperand, SDOperand>::iterator I = LegalizedNodes.find(Op); 497e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (I != LegalizedNodes.end()) return I->second; 4983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4999373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand Tmp1, Tmp2, Tmp3, Tmp4; 5003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Result = Op; 5023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 5043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 505d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getOpcode() >= ISD::BUILTIN_OP_END) { 506d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // If this is a target node, legalize it by legalizing the operands then 507d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // passing it through. 508d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<SDOperand> Ops; 509d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner bool Changed = false; 510d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 511d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 512d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Changed = Changed || Node->getOperand(i) != Ops.back(); 513d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 514d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Changed) 515d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getNumValues() == 1) 516d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Ops); 517d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner else { 518d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), 519d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Node->value_end()); 520d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 521d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 522d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner 523d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 524d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner AddLegalizedOperand(Op.getValue(i), Result.getValue(i)); 525d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner return Result.getValue(Op.ResNo); 526d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 527d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // Otherwise this is an unhandled builtin node. splat. 5283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 5293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to legalize this operator!"); 5303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 5313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::EntryToken: 5323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::FrameIndex: 53332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::TargetFrameIndex: 53432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::Register: 53532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::TargetConstant: 53628a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman case ISD::TargetConstantPool: 5373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::GlobalAddress: 538b9debbf54c926036d5c22b3e7f0d12c79c1c15a3Chris Lattner case ISD::TargetGlobalAddress: 53903c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::ExternalSymbol: 540e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth case ISD::TargetExternalSymbol: 54169a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::ConstantPool: // Nothing to do. 54232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::BasicBlock: 54332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::CONDCODE: 54432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::VALUETYPE: 54532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner case ISD::SRCVALUE: 54636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case ISD::STRING: 5470c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 5480c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner default: assert(0 && "This action is not supported yet!"); 5490c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner case TargetLowering::Custom: { 5500c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner SDOperand Tmp = TLI.LowerOperation(Op, DAG); 5510c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner if (Tmp.Val) { 5520c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner Result = LegalizeOp(Tmp); 5530c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner break; 5540c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } 5550c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } // FALLTHROUGH if the target doesn't want to lower this op after all. 5560c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner case TargetLowering::Legal: 5570c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner assert(isTypeLegal(Node->getValueType(0)) && "This must be legal!"); 5580c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner break; 5590c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } 5603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 56108951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertSext: 56208951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertZext: 56308951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 56408951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner if (Tmp1 != Node->getOperand(0)) 56508951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 56608951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Node->getOperand(1)); 56708951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner break; 568308575be66ec3870d27b19df044fda18448feb41Chris Lattner case ISD::MERGE_VALUES: 569308575be66ec3870d27b19df044fda18448feb41Chris Lattner return LegalizeOp(Node->getOperand(Op.ResNo)); 57069a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::CopyFromReg: 57169a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 5727310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = Op.getValue(0); 573f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner if (Node->getNumValues() == 2) { 5747310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Tmp1 != Node->getOperand(0)) 5757310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = DAG.getCopyFromReg(Tmp1, 576d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Node->getOperand(1))->getReg(), 5777310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Node->getValueType(0)); 5787310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } else { 579f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner assert(Node->getNumValues() == 3 && "Invalid copyfromreg!"); 580f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner if (Node->getNumOperands() == 3) 581f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 582f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner if (Tmp1 != Node->getOperand(0) || 583f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner (Node->getNumOperands() == 3 && Tmp2 != Node->getOperand(2))) 5847310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = DAG.getCopyFromReg(Tmp1, 5857310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner cast<RegisterSDNode>(Node->getOperand(1))->getReg(), 5867310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Node->getValueType(0), Tmp2); 5877310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner AddLegalizedOperand(Op.getValue(2), Result.getValue(2)); 5887310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 58913c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // Since CopyFromReg produces two values, make sure to remember that we 59013c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // legalized both of them. 59113c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 59213c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 59313c184de29c09294ed63b01ac43e1b46c049278eChris Lattner return Result.getValue(Op.ResNo); 594fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: { 595fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman MVT::ValueType VT = Op.getValueType(); 596fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman switch (TLI.getOperationAction(ISD::UNDEF, VT)) { 597ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman default: assert(0 && "This action is not supported yet!"); 598ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Expand: 599ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Promote: 600fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman if (MVT::isInteger(VT)) 601fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstant(0, VT); 602fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else if (MVT::isFloatingPoint(VT)) 603fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstantFP(0, VT); 604fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else 605fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman assert(0 && "Unknown value type!"); 606fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 607ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Legal: 608fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 609fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 610fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 611fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 61236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 61336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case ISD::LOCATION: 61436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner assert(Node->getNumOperands() == 5 && "Invalid LOCATION node!"); 61536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the input chain. 61636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 61736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner switch (TLI.getOperationAction(ISD::LOCATION, MVT::Other)) { 61836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Promote: 61936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner default: assert(0 && "This action is not supported yet!"); 620f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey case TargetLowering::Expand: { 621b2efb853f00d45b1c8d57f92acd0028fbdeffda6Jim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 622abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey bool useDEBUG_LOC = TLI.isOperationLegal(ISD::DEBUG_LOC, MVT::Other); 623abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey bool useDEBUG_LABEL = TLI.isOperationLegal(ISD::DEBUG_LABEL, MVT::Other); 624abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey 625abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey if (DebugInfo && (useDEBUG_LOC || useDEBUG_LABEL)) { 626abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey const std::string &FName = 627e81aecbae69d4b3bd24523ec87673632d3b0beecJim Laskey cast<StringSDNode>(Node->getOperand(3))->getValue(); 628abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey const std::string &DirName = 629e81aecbae69d4b3bd24523ec87673632d3b0beecJim Laskey cast<StringSDNode>(Node->getOperand(4))->getValue(); 630abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey unsigned SrcFile = DebugInfo->getUniqueSourceID(FName, DirName); 631abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey 632abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey std::vector<SDOperand> Ops; 633abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Ops.push_back(Tmp1); // chain 634abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey SDOperand LineOp = Node->getOperand(1); 635abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey SDOperand ColOp = Node->getOperand(2); 636abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey 637abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey if (useDEBUG_LOC) { 638abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Ops.push_back(LineOp); // line # 639abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Ops.push_back(ColOp); // col # 640abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Ops.push_back(DAG.getConstant(SrcFile, MVT::i32)); // source file id 641abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Result = DAG.getNode(ISD::DEBUG_LOC, MVT::Other, Ops); 642abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey } else { 643abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey unsigned Line = dyn_cast<ConstantSDNode>(LineOp)->getValue(); 644abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey unsigned Col = dyn_cast<ConstantSDNode>(ColOp)->getValue(); 645abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey unsigned ID = DebugInfo->RecordLabel(Line, Col, SrcFile); 646abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Ops.push_back(DAG.getConstant(ID, MVT::i32)); 647abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Result = DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, Ops); 648abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey } 649e81aecbae69d4b3bd24523ec87673632d3b0beecJim Laskey } else { 650e81aecbae69d4b3bd24523ec87673632d3b0beecJim Laskey Result = Tmp1; // chain 651e81aecbae69d4b3bd24523ec87673632d3b0beecJim Laskey } 652e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 65336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 654e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner } 65536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Legal: 6569ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner if (Tmp1 != Node->getOperand(0) || 6579ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner getTypeAction(Node->getOperand(1).getValueType()) == Promote) { 65836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner std::vector<SDOperand> Ops; 65936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Tmp1); 6609ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner if (getTypeAction(Node->getOperand(1).getValueType()) == Legal) { 6619ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(Node->getOperand(1)); // line # must be legal. 6629ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(Node->getOperand(2)); // col # must be legal. 6639ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner } else { 6649ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner // Otherwise promote them. 6659ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(PromoteOp(Node->getOperand(1))); 6669ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner Ops.push_back(PromoteOp(Node->getOperand(2))); 6679ad17c9c9abfd6e011751d2fd2b03448e1dccb71Chris Lattner } 66836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Node->getOperand(3)); // filename must be legal. 66936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(Node->getOperand(4)); // working dir # must be legal. 67036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Result = DAG.getNode(ISD::LOCATION, MVT::Other, Ops); 67136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 67236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 67336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 67436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 675f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey 676f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey case ISD::DEBUG_LOC: 677abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey assert(Node->getNumOperands() == 4 && "Invalid DEBUG_LOC node!"); 678f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey switch (TLI.getOperationAction(ISD::DEBUG_LOC, MVT::Other)) { 679f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey case TargetLowering::Promote: 680f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey case TargetLowering::Expand: 681f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey default: assert(0 && "This action is not supported yet!"); 682abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey case TargetLowering::Legal: 683abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 684abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the line #. 685abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the col #. 686abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp4 = LegalizeOp(Node->getOperand(3)); // Legalize the source file id. 687abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey 688abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey if (Tmp1 != Node->getOperand(0) || 689abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp2 != Node->getOperand(1) || 690abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp3 != Node->getOperand(2) || 691abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp4 != Node->getOperand(3)) { 692abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Result = DAG.getNode(ISD::DEBUG_LOC,MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4); 693abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey } 694abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey break; 695abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey } 696abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey break; 697abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey 698abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey case ISD::DEBUG_LABEL: 699abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey assert(Node->getNumOperands() == 2 && "Invalid DEBUG_LABEL node!"); 700abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey switch (TLI.getOperationAction(ISD::DEBUG_LABEL, MVT::Other)) { 701abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey case TargetLowering::Promote: 702abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey case TargetLowering::Expand: 703abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey default: assert(0 && "This action is not supported yet!"); 704abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey case TargetLowering::Legal: 705abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 706abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the label id. 707abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey 708abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey if (Tmp1 != Node->getOperand(0) || 709abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp2 != Node->getOperand(1)) { 710abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Result = DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, Tmp1, Tmp2); 711f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey } 712f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey break; 713f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey } 714f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey break; 71536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 7163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: 7173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // We know we don't need to expand constants here, constants only have one 7183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // value and we check that it is fine above. 7193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 7203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: Maybe we should handle things like targets that don't support full 7213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // 32-bit immediates? 7223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 7233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 7243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 7253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 7263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 7273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 7283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 7293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 7303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 7313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Check to see if this FP immediate is already legal. 7323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isLegal = false; 7333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 7343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner E = TLI.legal_fpimm_end(); I != E; ++I) 7353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (CFP->isExactlyValue(*I)) { 7363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner isLegal = true; 7373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 7383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 7393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 7403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!isLegal) { 7413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Otherwise we need to spill the constant to memory. 7423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool Extend = false; 7433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 7443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // If a FP immediate is precise when represented as a float, we put it 7453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // into the constant pool as a float, even if it's is statically typed 7463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // as a double. 7473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = CFP->getValueType(0); 7483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner bool isDouble = VT == MVT::f64; 7493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFP *LLVMC = ConstantFP::get(isDouble ? Type::DoubleTy : 7503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Type::FloatTy, CFP->getValue()); 75199939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner if (isDouble && CFP->isExactlyValue((float)CFP->getValue()) && 75299939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // Only do this if the target has a native EXTLOAD instruction from 75399939d39c9555ebecbcd24c1b607eae52804ea37Chris Lattner // f32. 754c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::EXTLOAD, MVT::f32)) { 7553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LLVMC = cast<ConstantFP>(ConstantExpr::getCast(LLVMC, Type::FloatTy)); 7563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner VT = MVT::f32; 7573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Extend = true; 7583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 759edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 76028a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman SDOperand CPIdx = 76128a6b02626c29b1fe9bb16c14c193549fab4cab8Nate Begeman LegalizeOp(DAG.getConstantPool(LLVMC, TLI.getPointerTy())); 762f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner if (Extend) { 7635f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 7645f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 765f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } else { 76652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, 76752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 768f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner } 7693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 7703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 7713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 7728cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman case ISD::ConstantVec: { 7738cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // We assume that vector constants are not legal, and will be immediately 7748cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // spilled to the constant pool. 7758cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // 7768cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // FIXME: revisit this when we have some kind of mechanism by which targets 7778cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // can decided legality of vector constants, of which there may be very 7788cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // many. 7798cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // 7808cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // Create a ConstantPacked, and put it in the constant pool. 7818cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman std::vector<Constant*> CV; 7828cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman MVT::ValueType VT = Node->getValueType(0); 7838cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman for (unsigned I = 0, E = Node->getNumOperands(); I < E; ++I) { 7848cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman SDOperand OpN = Node->getOperand(I); 7858cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman const Type* OpNTy = MVT::getTypeForValueType(OpN.getValueType()); 7868cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman if (MVT::isFloatingPoint(VT)) 7878cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman CV.push_back(ConstantFP::get(OpNTy, 7888cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman cast<ConstantFPSDNode>(OpN)->getValue())); 7898cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman else 7908cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman CV.push_back(ConstantUInt::get(OpNTy, 7918cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman cast<ConstantSDNode>(OpN)->getValue())); 7928cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman } 7938cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman Constant *CP = ConstantPacked::get(CV); 794d7d746f60337684310fcd985d4466edd6a5980acNate Begeman SDOperand CPIdx = LegalizeOp(DAG.getConstantPool(CP, TLI.getPointerTy())); 7958cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman Result = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx, DAG.getSrcValue(NULL)); 7968cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman break; 7978cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman } 798040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner case ISD::TokenFactor: 799040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Node->getNumOperands() == 2) { 800040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner bool Changed = false; 801040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op0 = LegalizeOp(Node->getOperand(0)); 802040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op1 = LegalizeOp(Node->getOperand(1)); 803040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Op0 != Node->getOperand(0) || Op1 != Node->getOperand(1)) 804040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 805040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } else { 806040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner std::vector<SDOperand> Ops; 807040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner bool Changed = false; 808040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner // Legalize the operands. 809040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 810040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner SDOperand Op = Node->getOperand(i); 811040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Ops.push_back(LegalizeOp(Op)); 812040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Changed |= Ops[i] != Op; 813040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } 814040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Changed) 815040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Ops); 816a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 817a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner break; 818a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner 81916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_START: 82016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 8213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 822128b52d3d75f4b74367de43e891cd98b5a9b5483Chris Lattner // Do not try to legalize the target-specific arguments (#1+) 82345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner Tmp2 = Node->getOperand(0); 8241aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (Tmp1 != Tmp2) 82588de6e77bfadea8962b017f372658204ab71448cChris Lattner Node->setAdjCallChain(Tmp1); 82627d404ccd1e86b7fffaf8037bf6b6dfb0b9d683bNate Begeman 82716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // Note that we do not create new CALLSEQ_DOWN/UP nodes here. These 82888de6e77bfadea8962b017f372658204ab71448cChris Lattner // nodes are treated specially and are mutated in place. This makes the dag 82988de6e77bfadea8962b017f372658204ab71448cChris Lattner // legalization process more efficient and also makes libcall insertion 83088de6e77bfadea8962b017f372658204ab71448cChris Lattner // easier. 8313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 832fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner case ISD::DYNAMIC_STACKALLOC: 833fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 834fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 835fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 836fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 837adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Tmp3 != Node->getOperand(2)) { 838adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 839adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 840adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 841adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 842adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner } else 843513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner Result = Op.getValue(0); 844fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 845fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // Since this op produces two values, make sure to remember that we 846fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner // legalized both of them. 847fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 848fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 849fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner return Result.getValue(Op.ResNo); 850fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 851d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 8523d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner case ISD::CALL: { 8533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 8553d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 8563d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 8573d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 8583d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 8593d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 8603d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 8613d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 8623d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 8633d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || Changed) { 8643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 8653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(Node->getNumValues()); 8663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 867ebda942efcb86634a6581aae76a0d0c92c4a232eChris Lattner RetTyVTs.push_back(Node->getValueType(i)); 868d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Result = SDOperand(DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 869d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL), 0); 87038d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner } else { 87138d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner Result = Result.getValue(0); 8723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 87338d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // Since calls produce multiple values, make sure to remember that we 87438d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner // legalized all of them. 87538d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 87638d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 87738d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner return Result.getValue(Op.ResNo); 8783d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 879c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 880c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 881c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner if (Tmp1 != Node->getOperand(0)) 882c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); 883c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 884c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner 885c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 886c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 8877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 88847e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 88947e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 89047e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 89147e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 89247e9223e06390897c3834f8c527001df392570ffChris Lattner break; 89347e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 89447e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 89547e9223e06390897c3834f8c527001df392570ffChris Lattner break; 89647e9223e06390897c3834f8c527001df392570ffChris Lattner } 8977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 8987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 8997cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 9007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 9017cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 9027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 9037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 9047cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 9057cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 9067cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 9077cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 908550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 909550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 910550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, MVT::i1); 911550b1e59c4eb5db020766012b1406fc56833251dChris Lattner 9127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 9137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 9147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 9157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 9167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 917e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 9187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 919898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng case TargetLowering::Custom: { 920898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng SDOperand Tmp = 921898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng TLI.LowerOperation(DAG.getNode(ISD::BRCOND, Node->getValueType(0), 922898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng Tmp1, Tmp2, Node->getOperand(2)), DAG); 923898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng if (Tmp.Val) { 924898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng Result = LegalizeOp(Tmp); 925898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng break; 926898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng } 927898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng // FALLTHROUGH if the target thinks it is legal. 928898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng } 9297cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 9307cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Basic block destination (Op#2) is always legal. 9317cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 9327cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 9337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 9347cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9357cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9367cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 9387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 939181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner if (!isTypeLegal(Node->getOperand(2).getValueType())) { 9407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 9417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 9427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 9437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 9447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 9457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 9467cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 9477cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 9487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 9497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 9507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 9517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 9527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9537cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 9547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), 9557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, DAG.getConstant(0, Tmp2.getValueType()), 9567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 9577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 958181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 959181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } 960181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner 961181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 962181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 963181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner 964181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner switch (TLI.getOperationAction(ISD::BR_CC, Tmp3.getValueType())) { 965181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner default: assert(0 && "Unexpected action for BR_CC!"); 966181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner case TargetLowering::Custom: { 967181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp4 = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 968181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp2, Tmp3, Node->getOperand(4)); 969181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp4 = TLI.LowerOperation(Tmp4, DAG); 970181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner if (Tmp4.Val) { 971181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Result = LegalizeOp(Tmp4); 972181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 973181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } 974181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } // FALLTHROUGH if the target doesn't want to lower this op after all. 975181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner case TargetLowering::Legal: 976181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 977181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp3 != Node->getOperand(3)) { 978181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 979181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp2, Tmp3, Node->getOperand(4)); 980181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } 981181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 9827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 983c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 984411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case ISD::BRCONDTWOWAY: 985411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 986411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 987411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 988411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Legal: 989411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 990411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 991411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Promote: 992411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 993411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 994411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 995411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR 996411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // pair. 997411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { 998411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Promote: 999411e888c1b4155190c8cffe388631ee20693b309Chris Lattner default: assert(0 && "This action is not supported yet!"); 1000411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Legal: 1001411e888c1b4155190c8cffe388631ee20693b309Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 1002411e888c1b4155190c8cffe388631ee20693b309Chris Lattner std::vector<SDOperand> Ops; 1003411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp1); 1004411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp2); 1005411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(2)); 1006411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(3)); 1007411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); 1008411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 1009411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 1010411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Expand: 10117cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If BRTWOWAY_CC is legal for this target, then simply expand this node 10127cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // to that. Otherwise, skip BRTWOWAY_CC and expand directly to a 10137cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // BRCOND/BR pair. 1014c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::BRTWOWAY_CC, MVT::Other)) { 10157cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 10167cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 10177cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 10187cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 10197cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 10207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 10217cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 10227cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 10237cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 10247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 10257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 1026411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Node->getOperand(2)); 10277cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(3)); 10287cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 1029e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 1030411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 1031411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 1032411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 10337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BRTWOWAY_CC: 10347cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1035c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 10367cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 10377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 10387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 10397cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 10407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Node->getOperand(1), Tmp2, Tmp3, 10417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 10427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 10437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 10447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 10457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 10467cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 10477cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 10487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 10497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If this target does not support BRTWOWAY_CC, lower it to a BRCOND/BR 10507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // pair. 10517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other)) { 10527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 10537cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 10547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 10557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 10567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 10577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 10587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 10597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 10607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 10617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 10627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 10637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 10647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 10657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 10667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 10677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 10687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 10697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 10707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 10717cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(5)); 10727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 10737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 1074f9dee6a0473db4f3713bf40c7408fa30578ac141Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 10757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 10767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 1077f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::LOAD: { 10783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 10802d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 1081f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng MVT::ValueType VT = Node->getValueType(0); 1082f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 1083f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng default: assert(0 && "This action is not supported yet!"); 1084f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Custom: { 1085f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Op = DAG.getLoad(Node->getValueType(0), 1086f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Tmp1, Tmp2, Node->getOperand(2)); 1087f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Tmp = TLI.LowerOperation(Op, DAG); 1088f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng if (Tmp.Val) { 1089f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = LegalizeOp(Tmp); 1090f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // Since loads produce two values, make sure to remember that we legalized 1091f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // both of them. 1092f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 0), Result); 1093f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 1094f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng return Result.getValue(Op.ResNo); 1095f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1096f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // FALLTHROUGH if the target thinks it is legal. 1097f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1098f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Legal: 1099f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng if (Tmp1 != Node->getOperand(0) || 1100f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Tmp2 != Node->getOperand(1)) 1101f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = DAG.getLoad(Node->getValueType(0), Tmp1, Tmp2, 1102f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Node->getOperand(2)); 1103f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng else 1104f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = SDOperand(Node, 0); 1105edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1106f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // Since loads produce two values, make sure to remember that we legalized 1107f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // both of them. 1108f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 0), Result); 1109f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 1110f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng return Result.getValue(Op.ResNo); 1111f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1112f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng assert(0 && "Unreachable"); 1113f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 11140f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::EXTLOAD: 11150f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::SEXTLOAD: 111601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case ISD::ZEXTLOAD: { 11170f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 11180f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 11190f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 11205f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner MVT::ValueType SrcVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 112101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), SrcVT)) { 112201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner default: assert(0 && "This action is not supported yet!"); 11231c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner case TargetLowering::Promote: 11241c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); 11255f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 11265f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), MVT::i8); 11271c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // Since loads produce two values, make sure to remember that we legalized 11281c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // both of them. 11291c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 11301c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 11311c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner return Result.getValue(Op.ResNo); 1132edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1133f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Custom: { 1134f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Op = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 1135f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Tmp1, Tmp2, Node->getOperand(2), 1136f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SrcVT); 1137f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Tmp = TLI.LowerOperation(Op, DAG); 1138f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng if (Tmp.Val) { 1139f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = LegalizeOp(Tmp); 1140f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // Since loads produce two values, make sure to remember that we legalized 1141f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // both of them. 1142f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 0), Result); 1143f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 1144f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng return Result.getValue(Op.ResNo); 1145f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1146f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // FALLTHROUGH if the target thinks it is legal. 1147f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 114801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Legal: 114901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Tmp1 != Node->getOperand(0) || 115001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Tmp2 != Node->getOperand(1)) 11515f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 11525f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 115301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner else 115401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = SDOperand(Node, 0); 115501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner 115601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Since loads produce two values, make sure to remember that we legalized 115701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // both of them. 115801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 115901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 116001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(Op.ResNo); 116101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Expand: 116269a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner // f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 11639d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 11649d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth SDOperand Load = DAG.getLoad(SrcVT, Tmp1, Tmp2, Node->getOperand(2)); 116531559081a4285f4b7282e765aea4ec8a8e1d396cAndrew Lenharth Result = DAG.getNode(ISD::FP_EXTEND, Node->getValueType(0), Load); 1166e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 116769a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner Load = LegalizeOp(Load); 116869a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 116969a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Load.getValue(1)); 11709d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (Op.ResNo) 11719d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Load.getValue(1); 11729d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Result; 11739d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 117401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(Node->getOpcode() != ISD::EXTLOAD && 117501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner "EXTLOAD should always be supported!"); 117601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 117701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // zero/sign extend inreg. 11785f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 11795f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 118023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner SDOperand ValRes; 118123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SEXTLOAD) 118223993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 118315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, DAG.getValueType(SrcVT)); 118423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner else 118523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getZeroExtendInReg(Result, SrcVT); 1186e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 1187e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner ValRes = LegalizeOp(ValRes); // Relegalize new nodes. 118869a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 0), ValRes); 118969a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 119001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Op.ResNo) 119101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(1); 119201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return ValRes; 119301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 119401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(0 && "Unreachable"); 119501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 11965dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case ISD::EXTRACT_ELEMENT: { 11975dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman MVT::ValueType OpTy = Node->getOperand(0).getValueType(); 11985dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman switch (getTypeAction(OpTy)) { 11995dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman default: 12005dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman assert(0 && "EXTRACT_ELEMENT action for type unimplemented!"); 12015dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 12025dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Legal: 12035dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) { 12045dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 1 -> Hi 12055dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::SRL, OpTy, Node->getOperand(0), 12065dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman DAG.getConstant(MVT::getSizeInBits(OpTy)/2, 12075dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman TLI.getShiftAmountTy())); 12085dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Result); 12095dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } else { 12105dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 0 -> Lo 12115dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), 12125dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Node->getOperand(0)); 12135dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 12145dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = LegalizeOp(Result); 12155dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 12165dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Expand: 12175dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // Get both the low and high parts. 12185dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 12195dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) 12205dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp2; // 1 -> Hi 12215dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman else 12225dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp1; // 0 -> Lo 12235dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 12245dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 12253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12265dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 12273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 12293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1230edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1231c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getOperand(2).getValueType()) && 1232d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner "Register type must be legal!"); 12337310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // Legalize the incoming value (must be a legal type). 1234d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 1235f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner if (Node->getNumValues() == 1) { 12367310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) 12377310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = DAG.getNode(ISD::CopyToReg, MVT::Other, Tmp1, 12387310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Node->getOperand(1), Tmp2); 12397310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } else { 1240f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner assert(Node->getNumValues() == 2 && "Unknown CopyToReg"); 1241f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner if (Node->getNumOperands() == 4) 1242f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(3)); 12437310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 1244f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner (Node->getNumOperands() == 4 && Tmp3 != Node->getOperand(3))) { 12457310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner unsigned Reg = cast<RegisterSDNode>(Node->getOperand(1))->getReg(); 12467310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = DAG.getCopyToReg(Tmp1, Reg, Tmp2, Tmp3); 12477310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 12487310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner 12497310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // Since this produces two values, make sure to remember that we legalized 12507310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // both of them. 12517310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 12527310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 12537310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner return Result.getValue(Op.ResNo); 12547310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 12553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 12583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 12593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 12603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 2: // ret val 12613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 12623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 12633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 12648afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 12653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 12663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 12683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 12693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 12703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Lo, Hi); 1271edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 12723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 12748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 12758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 12768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 12773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 12803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 12813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); 12823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 12843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<SDOperand> NewValues; 12853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 12863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) 12873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(i).getValueType())) { 12883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 12894e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NewValues.push_back(LegalizeOp(Node->getOperand(i))); 12903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 12923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 12933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(i), Lo, Hi); 12943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Lo); 12953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Hi); 1296edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 12973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 12998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Can't promote multiple return value yet!"); 13003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); 13023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 130517c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng 130647f5beaaaf41ffa2db51da6f99314474be6aca7dChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 130747f5beaaaf41ffa2db51da6f99314474be6aca7dChris Lattner Node->getValueType(0))) { 130817c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng default: assert(0 && "This action is not supported yet!"); 130917c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng case TargetLowering::Custom: { 131017c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng SDOperand Tmp = TLI.LowerOperation(Result, DAG); 131117c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng if (Tmp.Val) { 131217c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng Result = LegalizeOp(Tmp); 131317c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng break; 131417c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng } 131517c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng // FALLTHROUGH if the target thinks it is legal. 131617c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng } 131717c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng case TargetLowering::Legal: 131817c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng // Nothing to do. 131917c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng break; 132017c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng } 13213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1322f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::STORE: { 13233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 13243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 13253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 13265d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 132703c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ 13285d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner if (CFP->getValueType(0) == MVT::f32) { 132900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1330cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(FloatToBits(CFP->getValue()), 1331cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i32), 1332cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 133352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 13345d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } else { 13355d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); 133600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1337cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(DoubleToBits(CFP->getValue()), 1338cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i64), 1339cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 134052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 13415d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 134284734ce8ef1a21eb347d4deca0bf32d59001f751Chris Lattner Node = Result.Val; 13435d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 13445d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner 13453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 13463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: { 13473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Val = LegalizeOp(Node->getOperand(1)); 13483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Val != Node->getOperand(1) || Tmp1 != Node->getOperand(0) || 13493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(2)) 135052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, 135152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 1352f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng 1353f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng MVT::ValueType VT = Result.Val->getOperand(1).getValueType(); 1354f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng switch (TLI.getOperationAction(Result.Val->getOpcode(), VT)) { 1355f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng default: assert(0 && "This action is not supported yet!"); 1356f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Custom: { 1357f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Tmp = TLI.LowerOperation(Result, DAG); 1358f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng if (Tmp.Val) { 1359f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = LegalizeOp(Tmp); 1360f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng break; 1361f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1362f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // FALLTHROUGH if the target thinks it is legal. 1363f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1364f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Legal: 1365f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // Nothing to do. 1366f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng break; 1367f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 13683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 137103c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Truncate the value and store the result. 137203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(1)); 137303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp3, Tmp2, 13742d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 13759fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getValueType(Node->getOperand(1).getValueType())); 137603c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 137703c8546ec57523970874917854a2fb77b1ff598eChris Lattner 13783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: 13793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 1380ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize; 13813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 13823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 13833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 13843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 13853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1386edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Lo = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Lo, Tmp2, 1387edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1388ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If this is a vector type, then we have to calculate the increment as 1389ab48be377298bd509427a29e174cf4e305138819Nate Begeman // the product of the element size in bytes, and the number of elements 1390ab48be377298bd509427a29e174cf4e305138819Nate Begeman // in the high half of the vector. 1391ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (MVT::Vector == Hi.getValueType()) { 1392ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElems = cast<ConstantSDNode>(Hi.getOperand(2))->getValue(); 1393ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Hi.getOperand(3))->getVT(); 1394ab48be377298bd509427a29e174cf4e305138819Nate Begeman IncrementSize = NumElems * MVT::getSizeInBits(EVT)/8; 1395ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 1396ab48be377298bd509427a29e174cf4e305138819Nate Begeman IncrementSize = MVT::getSizeInBits(Hi.getValueType())/8; 1397ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 13983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::ADD, Tmp2.getValueType(), Tmp2, 13993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 14003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Tmp2.getValueType()) && 14013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Pointers must be legal!"); 14022d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Again, claiming both parts of the store came form the same Instr 1403edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Hi, Tmp2, 1404edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1405ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1406ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner break; 14073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 14083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1409f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 141095762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 141195762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 14122c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 14132c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); 141495762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 141551b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth case ISD::READCYCLECOUNTER: 141651b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain 1417cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth if (Tmp1 != Node->getOperand(0)) { 1418cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth std::vector<MVT::ValueType> rtypes; 1419cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth std::vector<SDOperand> rvals; 1420cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rtypes.push_back(MVT::i64); 1421cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rtypes.push_back(MVT::Other); 1422cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rvals.push_back(Tmp1); 1423cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth Result = DAG.getNode(ISD::READCYCLECOUNTER, rtypes, rvals); 1424cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth } 142549c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth 142649c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // Since rdcc produce two values, make sure to remember that we legalized 142749c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // both of them. 142849c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth AddLegalizedOperand(SDOperand(Node, 0), Result); 142949c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 143049c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth return Result.getValue(Op.ResNo); 1431f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 1432f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::TRUNCSTORE: { 14330f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 14340f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 14350f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 14360f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 1437c26f7a033f5416f216ef08929cbc8cb8df509ef3Chris Lattner case Promote: 1438c26f7a033f5416f216ef08929cbc8cb8df509ef3Chris Lattner case Expand: 1439c26f7a033f5416f216ef08929cbc8cb8df509ef3Chris Lattner assert(0 && "Cannot handle illegal TRUNCSTORE yet!"); 14400f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Legal: 14410f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 144213d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 144313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // The only promote case we handle is TRUNCSTORE:i1 X into 144413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // -> TRUNCSTORE:i8 (and X, 1) 144513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner if (cast<VTSDNode>(Node->getOperand(4))->getVT() == MVT::i1 && 144613d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TLI.getOperationAction(ISD::TRUNCSTORE, MVT::i1) == 144713d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TargetLowering::Promote) { 144813d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // Promote the bool to a mask then store. 144913d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp2 = DAG.getNode(ISD::AND, Tmp2.getValueType(), Tmp2, 145013d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner DAG.getConstant(1, Tmp2.getValueType())); 145113d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 145213d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Node->getOperand(3), DAG.getValueType(MVT::i8)); 145313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 145413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } else if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 145513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp3 != Node->getOperand(2)) { 145645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 14579fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner Node->getOperand(3), Node->getOperand(4)); 145813d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } 1459f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng 1460f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng MVT::ValueType StVT = cast<VTSDNode>(Result.Val->getOperand(4))->getVT(); 1461f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng switch (TLI.getOperationAction(Result.Val->getOpcode(), StVT)) { 1462f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng default: assert(0 && "This action is not supported yet!"); 1463f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Custom: { 1464f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Tmp = TLI.LowerOperation(Result, DAG); 1465f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng if (Tmp.Val) { 1466f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = LegalizeOp(Tmp); 1467f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng break; 1468f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1469f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // FALLTHROUGH if the target thinks it is legal. 1470f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1471f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Legal: 1472f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // Nothing to do. 1473f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng break; 1474f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 14750f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 14760f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner } 14770f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 1478f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 14792ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 148047e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 148147e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 148247e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 148347e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 148447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 148547e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 148647e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 148747e9223e06390897c3834f8c527001df392570ffChris Lattner break; 148847e9223e06390897c3834f8c527001df392570ffChris Lattner } 14893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 14902ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 149155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 1492b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { 149355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 14949373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 14959373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 14969373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1.getOperand(0), Tmp1.getOperand(1), 14979373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 14989373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 14999373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 1500550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 1501550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 1502550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, MVT::i1); 15039373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1, 15049373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 15059373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 15069373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 1507e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 15089373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 15097df96d66729d1f33934de7b52553e5f071686041Evan Cheng case TargetLowering::Custom: { 15107df96d66729d1f33934de7b52553e5f071686041Evan Cheng SDOperand Tmp = 15117df96d66729d1f33934de7b52553e5f071686041Evan Cheng TLI.LowerOperation(DAG.getNode(ISD::SELECT, Node->getValueType(0), 15127df96d66729d1f33934de7b52553e5f071686041Evan Cheng Tmp1, Tmp2, Tmp3), DAG); 15137df96d66729d1f33934de7b52553e5f071686041Evan Cheng if (Tmp.Val) { 15147df96d66729d1f33934de7b52553e5f071686041Evan Cheng Result = LegalizeOp(Tmp); 15157df96d66729d1f33934de7b52553e5f071686041Evan Cheng break; 15167df96d66729d1f33934de7b52553e5f071686041Evan Cheng } 15177df96d66729d1f33934de7b52553e5f071686041Evan Cheng // FALLTHROUGH if the target thinks it is legal. 15187df96d66729d1f33934de7b52553e5f071686041Evan Cheng } 151955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 152055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 152155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 != Node->getOperand(2)) 152255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), 152355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp1, Tmp2, Tmp3); 152455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 152555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 152655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner MVT::ValueType NVT = 152755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 152855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 152955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (MVT::isInteger(Tmp2.getValueType())) { 153013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner ExtOp = ISD::ANY_EXTEND; 153155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::TRUNCATE; 153255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 153355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::FP_EXTEND; 153455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::FP_ROUND; 153555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 153655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 153755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp2 = DAG.getNode(ExtOp, NVT, Tmp2); 153855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 = DAG.getNode(ExtOp, NVT, Tmp3); 153955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 154055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2,Tmp3); 154155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(TruncOp, Node->getValueType(0), Result); 154255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 154355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 154455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 15453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 15469373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 15479373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 15489373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 15499373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 1550c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(0).getValueType())) { 155123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner // Everything is legal, see if we should expand this op or something. 155223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner switch (TLI.getOperationAction(ISD::SELECT_CC, 155323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0).getValueType())) { 155423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner default: assert(0 && "This action is not supported yet!"); 155523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Custom: { 155623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner SDOperand Tmp = 155723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner TLI.LowerOperation(DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), 155823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0), 155923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(1), Tmp3, Tmp4, 1560d7050a9c50211dd215cb3c2bc28b4fb6bfa4a116Chris Lattner Node->getOperand(4)), DAG); 156123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp.Val) { 156223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = LegalizeOp(Tmp); 156323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 156423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 156523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } // FALLTHROUGH if the target can't lower this operation after all. 156623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Legal: 156723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 156823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 156923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 157023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3)) { 15711ccf26a6392034a11827aeaa0d58d025ecb2b85aChris Lattner Result = DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), Tmp1,Tmp2, 157223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3, Tmp4, Node->getOperand(4)); 157323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 157423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 15759373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 15769373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 15779373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 15789373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp1 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 15799373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(0), // LHS 15809373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), // RHS 15819373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4))); 15827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 15837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 15847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 15857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 15867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 15877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, Tmp3.getValueType(), 15887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1.getOperand(0), Tmp1.getOperand(1), 15897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, Tmp1.getOperand(2)); 15907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 15917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getSelectCC(Tmp1, 15927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 15937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, ISD::SETNE); 15947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 15959373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 15969373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 15973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 15983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 15993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 16003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 16013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 16023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 16033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 16048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // LHS 16058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // RHS 16068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 16078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // If this is an FP compare, the operands have already been extended. 16088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(Node->getOperand(0).getValueType())) { 16098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner MVT::ValueType VT = Node->getOperand(0).getValueType(); 161071c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 16118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 16128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Otherwise, we have to insert explicit sign or zero extends. Note 16138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // that we could insert sign extends for ALL conditions, but zero extend 16148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // is cheaper on many machines (an AND instead of two shifts), so prefer 16158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // it. 16167cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 16178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner default: assert(0 && "Unknown integer comparison!"); 16188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETEQ: 16198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETNE: 16208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGE: 16218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGT: 16228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULE: 16238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULT: 16248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // ALL of these operations will work if we either sign or zero extend 16258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // the operands (including the unsigned comparisons!). Zero extend is 16268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // usually a simpler/cheaper operation, so prefer it. 162723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 162823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 16298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 16308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGE: 16318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGT: 16328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLT: 16338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLE: 163415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 163515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 163615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 163715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 16388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 16398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 16408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 16413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1642edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case Expand: 16433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 16443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LHSLo, LHSHi); 16453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RHSLo, RHSHi); 16467cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 16473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETEQ: 16483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETNE: 164908b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSLo == RHSHi) 165008b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 165108b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSCST->isAllOnesValue()) { 165208b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner // Comparison to -1. 165308b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Tmp1 = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 1654b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSLo; 1655edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 165608b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner } 165708b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner 16583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 16593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 16603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp2); 1661b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 16623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 16633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 16645b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 16655b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // X > -1, x < 0 16665b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Node->getOperand(1))) 16677cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner if ((cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETLT && 16685b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner CST->getValue() == 0) || // X < 0 16697cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner (cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETGT && 1670b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman (CST->isAllOnesValue()))) { // X > -1 1671b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp1 = LHSHi; 1672b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSHi; 1673b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1674b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 16755b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner 16763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: This generated code sucks. 16773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ISD::CondCode LowCC; 16787cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 16793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: assert(0 && "Unknown integer setcc!"); 16803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLT: 16813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 16823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGT: 16833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 16843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLE: 16853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 16863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGE: 16873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 16883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1689edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 16903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 16913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 16923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 16933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 16943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 16953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 16967cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp1 = DAG.getSetCC(Node->getValueType(0), LHSLo, RHSLo, LowCC); 16977cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getNode(ISD::SETCC, Node->getValueType(0), LHSHi, RHSHi, 16987cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 16997cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getSetCC(Node->getValueType(0), LHSHi, RHSHi, ISD::SETEQ); 1700b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1701b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result, Tmp1, Tmp2)); 170269a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 1703b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman return Result; 17043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 17053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1706b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman 17071ccf26a6392034a11827aeaa0d58d025ecb2b85aChris Lattner switch(TLI.getOperationAction(ISD::SETCC, 17081ccf26a6392034a11827aeaa0d58d025ecb2b85aChris Lattner Node->getOperand(0).getValueType())) { 1709b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman default: 1710b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman assert(0 && "Cannot handle this action for SETCC yet!"); 1711b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1712ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth case TargetLowering::Promote: { 1713ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // First step, figure out the appropriate operation to use. 1714ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Allow SETCC to not be supported for all legal data types 1715ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Mostly this targets FP 1716ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth MVT::ValueType NewInTy = Node->getOperand(0).getValueType(); 1717ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth MVT::ValueType OldVT = NewInTy; 1718ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1719ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Scan for the appropriate larger type to use. 1720ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth while (1) { 1721ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth NewInTy = (MVT::ValueType)(NewInTy+1); 1722ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1723ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(MVT::isInteger(NewInTy) == MVT::isInteger(OldVT) && 1724ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the integer world"); 1725ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(MVT::isFloatingPoint(NewInTy) == MVT::isFloatingPoint(OldVT) && 1726ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the floating point world"); 1727ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1728ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // If the target supports SETCC of this type, use it. 17291ccf26a6392034a11827aeaa0d58d025ecb2b85aChris Lattner if (TLI.isOperationLegal(ISD::SETCC, NewInTy)) 1730ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth break; 1731ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1732ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth if (MVT::isInteger(NewInTy)) 1733ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(0 && "Cannot promote Legal Integer SETCC yet"); 1734ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth else { 1735ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth Tmp1 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp1); 1736ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth Tmp2 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp2); 1737ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1738ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 17395e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 17405e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Node->getOperand(2)); 17415e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth break; 1742ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1743d5781fca4f8f98863560338d4f8d017389428119Evan Cheng case TargetLowering::Custom: { 1744d5781fca4f8f98863560338d4f8d017389428119Evan Cheng SDOperand Tmp = 1745d5781fca4f8f98863560338d4f8d017389428119Evan Cheng TLI.LowerOperation(DAG.getNode(ISD::SETCC, Node->getValueType(0), 1746d5781fca4f8f98863560338d4f8d017389428119Evan Cheng Tmp1, Tmp2, Node->getOperand(2)), DAG); 1747d5781fca4f8f98863560338d4f8d017389428119Evan Cheng if (Tmp.Val) { 1748d5781fca4f8f98863560338d4f8d017389428119Evan Cheng Result = LegalizeOp(Tmp); 1749d5781fca4f8f98863560338d4f8d017389428119Evan Cheng break; 1750d5781fca4f8f98863560338d4f8d017389428119Evan Cheng } 1751d5781fca4f8f98863560338d4f8d017389428119Evan Cheng // FALLTHROUGH if the target thinks it is legal. 1752d5781fca4f8f98863560338d4f8d017389428119Evan Cheng } 1753b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Legal: 1754b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1755b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 1756b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1757b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1758b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Expand: 1759b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // Expand a setcc node into a select_cc of the same condition, lhs, and 1760b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // rhs that selects between const 1 (true) and const 0 (false). 1761b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman MVT::ValueType VT = Node->getValueType(0); 1762b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SELECT_CC, VT, Tmp1, Tmp2, 1763b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman DAG.getConstant(1, VT), DAG.getConstant(0, VT), 1764b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1765b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(Result); 1766b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1767b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 17683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 17693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1770e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMSET: 1771e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMCPY: 1772e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMMOVE: { 1773deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Chain 1774e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Pointer 1775e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner 1776e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { // memset = ubyte 1777e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner switch (getTypeAction(Node->getOperand(2).getValueType())) { 1778e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand a byte!"); 1779e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1780deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 1781e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1782e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1783deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); 1784e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1785e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1786e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } else { 1787edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Tmp3 = LegalizeOp(Node->getOperand(2)); // memcpy/move = pointer, 1788e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1789272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1790272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp4; 1791272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(3).getValueType())) { 17926814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner case Expand: { 17936814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner // Length is too big, just take the lo-part of the length. 17946814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner SDOperand HiPart; 17956814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner ExpandOp(Node->getOperand(3), HiPart, Tmp4); 17966814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner break; 17976814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner } 1798e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1799e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = LegalizeOp(Node->getOperand(3)); 1800e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1801e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1802e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = PromoteOp(Node->getOperand(3)); 1803272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1804272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner } 1805272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1806272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp5; 1807272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(4).getValueType())) { // uint 1808272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 1809272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Legal: 1810272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner Tmp5 = LegalizeOp(Node->getOperand(4)); 1811272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1812272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Promote: 1813e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp5 = PromoteOp(Node->getOperand(4)); 1814e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1815e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 181655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 181755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 181855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 181907dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 182007dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 182107dffd6af673c73352150583150b242a93694f00Chris Lattner TLI.LowerOperation(DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, 182207dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp2, Tmp3, Tmp4, Tmp5), DAG); 182307dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 182407dffd6af673c73352150583150b242a93694f00Chris Lattner Result = LegalizeOp(Tmp); 182507dffd6af673c73352150583150b242a93694f00Chris Lattner break; 182607dffd6af673c73352150583150b242a93694f00Chris Lattner } 182707dffd6af673c73352150583150b242a93694f00Chris Lattner // FALLTHROUGH if the target thinks it is legal. 182807dffd6af673c73352150583150b242a93694f00Chris Lattner } 182955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 1830e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 1831e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || 1832e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp5 != Node->getOperand(4)) { 1833e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<SDOperand> Ops; 1834e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 1835e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 1836e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 1837e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 183855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 183955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: { 1840e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Otherwise, the target does not support this operation. Lower the 1841e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // operation to an explicit libcall as appropriate. 1842e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 1843e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner const Type *IntPtrTy = TLI.getTargetData().getIntPtrType(); 1844e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1845e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 18463bfbf4ea990930d153e58e153f319408341a94feReid Spencer const char *FnName = 0; 1847e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { 1848e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1849e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Extend the ubyte argument to be an int value for the call. 1850e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Tmp3); 1851e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, Type::IntTy)); 1852e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1853e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 1854e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = "memset"; 1855e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else if (Node->getOpcode() == ISD::MEMCPY || 1856e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Node->getOpcode() == ISD::MEMMOVE) { 1857e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1858e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, IntPtrTy)); 1859e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1860e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = Node->getOpcode() == ISD::MEMMOVE ? "memmove" : "memcpy"; 1861e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else { 1862e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner assert(0 && "Unknown op!"); 1863e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 186445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 1865e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 1866adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(Tmp1, Type::VoidTy, false, CallingConv::C, false, 1867e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner DAG.getExternalSymbol(FnName, IntPtr), Args, DAG); 186869a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner Result = LegalizeOp(CallResult.second); 186955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 187055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 1871e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 1872e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner break; 1873e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 187452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 187552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::READPORT: 187652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 187752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 18786d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 18793e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 18803e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 18813e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 18823e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 18833e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 18843e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 18853e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 188652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = SDOperand(Node, 0); 188752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // Since these produce two values, make sure to remember that we legalized 188852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // both of them. 188952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 189052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 189152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner return Result.getValue(Op.ResNo); 189252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::WRITEPORT: 189352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 189452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 189552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 189652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 189752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 != Node->getOperand(2)) 189852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 189952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner break; 190052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 19016d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::READIO: 19026d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 19036d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 19046d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 19056d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 19066d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 19076d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 19086d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 19093e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 19103e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 19113e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 19123e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 19133e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 19143e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 19153e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 19166d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = SDOperand(Node, 0); 19176d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 19186d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 19196d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a load from memory. 19206d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0), 19216d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), DAG.getSrcValue(NULL)); 19226d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 19236d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 19246d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 19256d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 19266d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Since these produce two values, make sure to remember that we legalized 19276d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // both of them. 19286d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 19296d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 19306d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner return Result.getValue(Op.ResNo); 19316d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 19326d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::WRITEIO: 19336d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 19346d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 19356d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 19366d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 19376d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 19386d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1).getValueType())) { 19396d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 19406d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 19416d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 19426d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 19436d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 != Node->getOperand(2)) 19446d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 19456d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 19466d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 19476d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a store to memory. 19486d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0), 19496d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), Node->getOperand(2), 19506d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getSrcValue(NULL)); 19516d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 19526d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 19536d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 19546d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 19556d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 195684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::ADD_PARTS: 19575b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SUB_PARTS: 19585b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 19595b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 19605b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 196184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 196284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 196384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 196484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 196584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 196684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 1967e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (Changed) { 1968e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 1969e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 1970e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 19712c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 197205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), 197305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Node->getValueType(0))) { 197405a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng default: assert(0 && "This action is not supported yet!"); 197505a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng case TargetLowering::Custom: { 197605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng SDOperand Tmp = TLI.LowerOperation(Result, DAG); 197705a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng if (Tmp.Val) { 197805a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng SDOperand Tmp2, RetVal; 197905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) { 198005a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Tmp2 = LegalizeOp(Tmp.getValue(i)); 198105a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng AddLegalizedOperand(SDOperand(Node, i), Tmp2); 198205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng if (i == Op.ResNo) 198305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng RetVal = Tmp; 198405a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 198505a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng return RetVal; 198605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 198705a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng // FALLTHROUGH if the target thinks it is legal. 198805a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 198905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng case TargetLowering::Legal: 199005a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng // Nothing to do. 199105a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng break; 199205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 199305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng 19942c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 19952c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 19962c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 19972c8086f4b9916b2d02842be5e375276023225fbaChris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 19982c8086f4b9916b2d02842be5e375276023225fbaChris Lattner return Result.getValue(Op.ResNo); 199984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 20002c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 20012c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 20023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 20033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 20043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 2005c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 2006c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 20073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 20083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 20093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 20103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 20113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 201203c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 201303c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 201403c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 201501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 201601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 201701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 201801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 20193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 2020f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth switch (getTypeAction(Node->getOperand(1).getValueType())) { 2021f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Expand: assert(0 && "Not possible"); 2022f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Legal: 2023f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 2024f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 2025f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Promote: 2026f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the RHS. 2027f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 2028f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth } 2029e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2030e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth case TargetLowering::Custom: { 2031e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, Tmp2); 2032e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth SDOperand Tmp = TLI.LowerOperation(Result, DAG); 2033e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth if (Tmp.Val) { 2034e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth Tmp = LegalizeOp(Tmp); // Relegalize input. 2035e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth AddLegalizedOperand(Op, Tmp); 2036e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth return Tmp; 203757030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth } //else it was considered legal and we fall through 2038e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth } 203957030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth case TargetLowering::Legal: 204057030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth if (Tmp1 != Node->getOperand(0) || 204157030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth Tmp2 != Node->getOperand(1)) 204257030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 204357030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth break; 2044e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth default: 2045e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth assert(0 && "Operation not supported"); 2046e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth } 20473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2048edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2049419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case ISD::BUILD_PAIR: { 2050419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman MVT::ValueType PairTy = Node->getValueType(0); 2051419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman // TODO: handle the case where the Lo and Hi operands are not of legal type 2052419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Lo 2053419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Hi 2054419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman switch (TLI.getOperationAction(ISD::BUILD_PAIR, PairTy)) { 2055419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Legal: 2056419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 2057419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = DAG.getNode(ISD::BUILD_PAIR, PairTy, Tmp1, Tmp2); 2058419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2059419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Promote: 2060419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Custom: 2061419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman assert(0 && "Cannot promote/custom this yet!"); 2062419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Expand: 2063419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, PairTy, Tmp1); 2064419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::ANY_EXTEND, PairTy, Tmp2); 2065419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::SHL, PairTy, Tmp2, 2066419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman DAG.getConstant(MVT::getSizeInBits(PairTy)/2, 2067419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman TLI.getShiftAmountTy())); 2068419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::OR, PairTy, Tmp1, Tmp2)); 2069419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2070419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 2071419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2072419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 2073419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman 2074c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 2075c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 207601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 2077c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 2078c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 2079c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2080e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth case TargetLowering::Custom: { 2081e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, Tmp2); 2082e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth SDOperand Tmp = TLI.LowerOperation(Result, DAG); 2083e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth if (Tmp.Val) { 2084e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth Tmp = LegalizeOp(Tmp); // Relegalize input. 2085e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth AddLegalizedOperand(Op, Tmp); 2086e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth return Tmp; 208757030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth } //else it was considered legal and we fall through 2088e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth } 208957030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth case TargetLowering::Legal: 209057030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth if (Tmp1 != Node->getOperand(0) || 209157030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth Tmp2 != Node->getOperand(1)) 209257030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 209357030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth Tmp2); 209457030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth break; 209557030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth case TargetLowering::Promote: 209657030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth assert(0 && "Cannot promote handle this yet!"); 20974c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner case TargetLowering::Expand: 20984c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner if (MVT::isInteger(Node->getValueType(0))) { 20994c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner MVT::ValueType VT = Node->getValueType(0); 21004c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner unsigned Opc = (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 21014c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(Opc, VT, Tmp1, Tmp2); 21024c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::MUL, VT, Result, Tmp2); 21034c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::SUB, VT, Tmp1, Result); 21044c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner } else { 21054c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner // Floating point mod -> fmod libcall. 21064c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner const char *FnName = Node->getValueType(0) == MVT::f32 ? "fmodf":"fmod"; 21074c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner SDOperand Dummy; 21084c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = ExpandLibCall(FnName, Node, Dummy); 2109c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 2110c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 2111c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 2112c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 21132c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 2114691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 2115691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 2116691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 2117691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 2118691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2119691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 2120691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth if (Tmp1 != Node->getOperand(0)) 2121691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2122691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2123691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 2124691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType OVT = Tmp1.getValueType(); 2125691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 2126edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 2127edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 2128691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2129691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 2130691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2131691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch(Node->getOpcode()) 2132691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth { 2133691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 2134691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 2135691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2136691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 2137691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 21387cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 21397cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), 21407cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ); 214100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 2142691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(OVT),NVT), Tmp1); 2143691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2144691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 2145691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 214600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 214700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 2148691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getSizeInBits(OVT), NVT)); 2149691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2150691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 2151691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2152691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 2153691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Custom: 2154691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth assert(0 && "Cannot custom handle this yet!"); 2155691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 2156ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth switch(Node->getOpcode()) 2157ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth { 2158ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth case ISD::CTPOP: { 2159e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner static const uint64_t mask[6] = { 2160e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 2161e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 2162e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 2163e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner }; 2164ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth MVT::ValueType VT = Tmp1.getValueType(); 2165e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner MVT::ValueType ShVT = TLI.getShiftAmountTy(); 2166e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner unsigned len = getSizeInBits(VT); 2167e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 2168ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 2169e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp2 = DAG.getConstant(mask[i], VT); 2170e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp3 = DAG.getConstant(1ULL << i, ShVT); 217100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::ADD, VT, 2172ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, Tmp1, Tmp2), 2173ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, 2174ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3), 2175ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp2)); 2176ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 2177ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Result = Tmp1; 2178ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 2179ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 218057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTLZ: { 218157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina /* for now, we do this: 21825c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 1); 21835c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 2); 21845c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner ... 21855c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>16); 218600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen x = x | (x >>32); // for 64-bit input 21875c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner return popcount(~x); 218800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 21895c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner but see also: http://www.hackersdelight.org/HDcode/nlz.cc */ 21905c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 219157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina MVT::ValueType ShVT = TLI.getShiftAmountTy(); 219257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina unsigned len = getSizeInBits(VT); 219357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 219457ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getConstant(1ULL << i, ShVT); 219500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::OR, VT, Tmp1, 219657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3)); 219757ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 219857ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getNode(ISD::XOR, VT, Tmp1, DAG.getConstant(~0ULL, VT)); 21995c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 220018aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 220157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 220257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTTZ: { 220300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen // for now, we use: { return popcount(~x & (x - 1)); } 2204d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // unless the target has ctlz but not ctpop, in which case we use: 2205d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // { return 32 - nlz(~x & (x-1)); } 2206d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // see also http://www.hackersdelight.org/HDcode/ntz.cc 22075c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 22085c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp2 = DAG.getConstant(~0ULL, VT); 220900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp3 = DAG.getNode(ISD::AND, VT, 22105c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::XOR, VT, Tmp1, Tmp2), 22115c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::SUB, VT, Tmp1, 22125c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getConstant(1, VT))); 2213d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // If ISD::CTLZ is legal and CTPOP isn't, then do that instead 2214c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::CTPOP, VT) && 2215c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::CTLZ, VT)) { 221600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = LegalizeOp(DAG.getNode(ISD::SUB, VT, 2217d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getConstant(getSizeInBits(VT), VT), 2218d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getNode(ISD::CTLZ, VT, Tmp3))); 2219d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } else { 2220d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 2221d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } 222218aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 222357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 2224ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth default: 2225ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth assert(0 && "Cannot expand this yet!"); 2226ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 2227ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 2228691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2229691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 2230691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 223100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 22322c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 22332c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 22342c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 2235da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2236da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2237da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 22382c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 22392c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 22402c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 22412c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 22422c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 22432c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 22442c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Promote: 22452c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Custom: 22462c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Cannot promote/custom handle this yet!"); 22472c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 2248f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 2249f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FNEG: { 22502c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 22512c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 225201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = LegalizeOp(DAG.getNode(ISD::FSUB, Node->getValueType(0), 22532c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2, Tmp1)); 2254f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 2255f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2256f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 22574af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 22584af6e0d7836126630f579b0a34f054321187f00bChris Lattner MVT::ValueType VT = Node->getValueType(0); 22594af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 22607cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, Tmp2, ISD::SETUGT); 22614af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp3 = DAG.getNode(ISD::FNEG, VT, Tmp1); 22624af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = DAG.getNode(ISD::SELECT, VT, Tmp2, Tmp1, Tmp3); 22634af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = LegalizeOp(Result); 2264f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 2265f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2266f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: 2267f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: 2268f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: { 2269f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner MVT::ValueType VT = Node->getValueType(0); 2270f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner const char *FnName = 0; 2271f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 2272f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: FnName = VT == MVT::f32 ? "sqrtf" : "sqrt"; break; 2273f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: FnName = VT == MVT::f32 ? "sinf" : "sin"; break; 2274f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: FnName = VT == MVT::f32 ? "cosf" : "cos"; break; 2275f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 2276f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 22772ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman SDOperand Dummy; 22782ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman Result = ExpandLibCall(FnName, Node, Dummy); 2279f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 2280f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2281f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: 22824af6e0d7836126630f579b0a34f054321187f00bChris Lattner assert(0 && "Unreachable!"); 22832c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 22842c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 22852c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 22862c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 228735481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 228835481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case ISD::BIT_CONVERT: 228935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner if (!isTypeLegal(Node->getOperand(0).getValueType())) 229035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Result = ExpandBIT_CONVERT(Node->getValueType(0), Node->getOperand(0)); 229135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner else { 229235481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner switch (TLI.getOperationAction(ISD::BIT_CONVERT, 229335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Node->getOperand(0).getValueType())) { 229435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner default: assert(0 && "Unknown operation action!"); 229535481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case TargetLowering::Expand: 229635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Result = ExpandBIT_CONVERT(Node->getValueType(0), Node->getOperand(0)); 229735481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 229835481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case TargetLowering::Legal: 229935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 230035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner if (Tmp1 != Node->getOperand(0)) 230135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Result = DAG.getNode(ISD::BIT_CONVERT, Node->getValueType(0), Tmp1); 230235481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 230335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner } 230435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner } 230535481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 23062c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 2307fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::SINT_TO_FP: 2308fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::UINT_TO_FP: { 2309fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP; 2310fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2311fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2312d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen switch (TLI.getOperationAction(Node->getOpcode(), 2313fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType())) { 2314fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner default: assert(0 && "Unknown operation action!"); 2315fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Expand: 23166269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = ExpandLegalINT_TO_FP(isSigned, 23176269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey LegalizeOp(Node->getOperand(0)), 23186269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Node->getValueType(0)); 2319fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 2320fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 2321fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Promote: 2322fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteLegalINT_TO_FP(LegalizeOp(Node->getOperand(0)), 2323fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), 2324fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner isSigned); 2325fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 2326fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 2327fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Legal: 2328fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 23295b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth case TargetLowering::Custom: { 23305b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); 23315b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth SDOperand Tmp = 23325b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 23335b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth Tmp = TLI.LowerOperation(Tmp, DAG); 23345b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth if (Tmp.Val) { 233569a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner Tmp = LegalizeOp(Tmp); // Relegalize input. 23365b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth AddLegalizedOperand(Op, Tmp); 23375b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth return Tmp; 23385b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } else { 23395b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth assert(0 && "Target Must Lower this"); 23405b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } 23415b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } 2342fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2343fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 2344fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2345fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2346fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2347fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2348fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2349fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, 2350fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), Node->getOperand(0)); 2351fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2352fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2353fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (isSigned) { 2354fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2355fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 2356fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result, DAG.getValueType(Node->getOperand(0).getValueType())); 2357fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SINT_TO_FP, Op.getValueType(), Result); 2358fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } else { 2359fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2360fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getZeroExtendInReg(Result, 2361fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType()); 2362fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::UINT_TO_FP, Op.getValueType(), Result); 2363fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2364fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2365fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2366fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2367fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2368fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::TRUNCATE: 2369fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2370fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2371fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2372fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2373fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2374fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2375fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2376fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 2377fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 2378fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // Since the result is legal, we should just be able to truncate the low 2379fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // part of the source. 2380fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Tmp1); 2381fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2382fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2383fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2384fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Op.getValueType(), Result); 2385fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2386fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2387fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2388d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 2389fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_SINT: 2390fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_UINT: 2391fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2392fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2393f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2394f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner 23951618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))){ 23961618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: assert(0 && "Unknown operation action!"); 23971618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Expand: 2398d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT) { 2399d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman SDOperand True, False; 2400d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType VT = Node->getOperand(0).getValueType(); 2401d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType NVT = Node->getValueType(0); 2402d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman unsigned ShiftAmt = MVT::getSizeInBits(Node->getValueType(0))-1; 2403d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getConstantFP((double)(1ULL << ShiftAmt), VT); 2404d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp3 = DAG.getSetCC(TLI.getSetCCResultTy(), 2405d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Node->getOperand(0), Tmp2, ISD::SETLT); 2406d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman True = DAG.getNode(ISD::FP_TO_SINT, NVT, Node->getOperand(0)); 2407d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::FP_TO_SINT, NVT, 240801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getNode(ISD::FSUB, VT, Node->getOperand(0), 2409d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2)); 2410d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::XOR, NVT, False, 2411d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getConstant(1ULL << ShiftAmt, NVT)); 2412d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, NVT, Tmp3, True, False)); 241369a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 24142d56e72f09337a1cab3ba199a9467c159296f3faNate Begeman return Result; 2415d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2416d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman assert(0 && "Do not know how to expand FP_TO_SINT yet!"); 2417d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 2418d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman break; 24191618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Promote: 2420f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = PromoteLegalFP_TO_INT(Tmp1, Node->getValueType(0), 24211618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner Node->getOpcode() == ISD::FP_TO_SINT); 24221618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner AddLegalizedOperand(Op, Result); 24231618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return Result; 242407dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 242507dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 242607dffd6af673c73352150583150b242a93694f00Chris Lattner DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 242707dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp = TLI.LowerOperation(Tmp, DAG); 242807dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 242969a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner Tmp = LegalizeOp(Tmp); 243007dffd6af673c73352150583150b242a93694f00Chris Lattner AddLegalizedOperand(Op, Tmp); 2431507f752f6ed28aa9f0ae680e95bfc93df4e9e2dcChris Lattner return Tmp; 243207dffd6af673c73352150583150b242a93694f00Chris Lattner } else { 243307dffd6af673c73352150583150b242a93694f00Chris Lattner // The target thinks this is legal afterall. 243407dffd6af673c73352150583150b242a93694f00Chris Lattner break; 243507dffd6af673c73352150583150b242a93694f00Chris Lattner } 243607dffd6af673c73352150583150b242a93694f00Chris Lattner } 24371618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 24381618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 24391618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 2440d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 2441fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2442fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2443fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2444fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2445fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2446fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2447fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2448fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2449fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2450fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2451fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2452d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 245313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 24543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 24553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 245603c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_EXTEND: 245703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_ROUND: 24583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 24593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 24603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 24613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 24623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 24633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2464b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner case Expand: 24652c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2466b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner 246703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Promote: 246803c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 246913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 247013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = PromoteOp(Node->getOperand(0)); 247113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 247213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 24731713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner case ISD::ZERO_EXTEND: 24741713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 247513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 247623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 247723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 247803c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 247903c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SIGN_EXTEND: 24801713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 248113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 24821713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 248315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 248415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 24851713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 248603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_EXTEND: 24871713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 24881713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner if (Result.getValueType() != Op.getValueType()) 24891713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner // Dynamically dead while we have only 2 FP types. 24901713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::FP_EXTEND, Op.getValueType(), Result); 24911713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 249203c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_ROUND: 2493f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 2494f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2495f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 249603c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 24973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 24983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 24990f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 250023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 25010f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 250215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 250345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 250445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 250545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 250655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 250755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 250855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 250955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0)) 251055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 25115f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner DAG.getValueType(ExtraVT)); 251255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 251355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 251445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 251523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 251645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 251745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 251845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned BitsDiff = MVT::getSizeInBits(Node->getValueType(0)) - 251945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::getSizeInBits(ExtraVT); 252027ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner SDOperand ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 252145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SHL, Node->getValueType(0), 252245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 252345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SRA, Node->getValueType(0), 252445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 252545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 252645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // The only way we can lower this is to turn it into a STORETRUNC, 252745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 252845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 252945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 253045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 253145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 253245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner const Type *Ty = MVT::getTypeForValueType(ExtraVT); 253345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned TySize = (unsigned)TLI.getTargetData().getTypeSize(Ty); 253445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 253545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 2536edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman int SSFI = 253745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 253845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 253945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, DAG.getEntryNode(), 254052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(0), StackSlot, 25419fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getSrcValue(NULL), DAG.getValueType(ExtraVT)); 25425f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 25435f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result, StackSlot, DAG.getSrcValue(NULL), 25445f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner ExtraVT); 254545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 254645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 254745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 254845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = LegalizeOp(Result); 254955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 255045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 25510f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 25523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 255345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 25543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 255545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 255645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 255745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 25583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 25593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 25603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 25618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// PromoteOp - Given an operation that produces a value in an invalid type, 25628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// promote it to compute the value into a larger type. The produced value will 25638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// have the correct bits for the low portion of the register, but no guarantee 25648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// is made about the top bits: it may be zero, sign-extended, or garbage. 256503c8546ec57523970874917854a2fb77b1ff598eChris LattnerSDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) { 256603c8546ec57523970874917854a2fb77b1ff598eChris Lattner MVT::ValueType VT = Op.getValueType(); 256771c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 256803c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(getTypeAction(VT) == Promote && 256903c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Caller should expand or legalize operands that are not promotable!"); 257003c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(NVT > VT && MVT::isInteger(NVT) == MVT::isInteger(VT) && 257103c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Cannot promote to smaller type!"); 257203c8546ec57523970874917854a2fb77b1ff598eChris Lattner 257303c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Tmp1, Tmp2, Tmp3; 257403c8546ec57523970874917854a2fb77b1ff598eChris Lattner 257503c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Result; 257603c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDNode *Node = Op.Val; 257703c8546ec57523970874917854a2fb77b1ff598eChris Lattner 25786fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op); 25796fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != PromotedNodes.end()) return I->second; 258045982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 25810f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // Promotion needs an optimization step to clean up after it, and is not 25820f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // careful to avoid operations the target does not support. Make sure that 25830f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // all generated operations are legalized in the next iteration. 25840f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner NeedsAnotherIteration = true; 25850f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 258603c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 2587d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2588d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 258903c8546ec57523970874917854a2fb77b1ff598eChris Lattner default: 259003c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 259103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(0 && "Do not know how to promote this operator!"); 259203c8546ec57523970874917854a2fb77b1ff598eChris Lattner abort(); 2593fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2594fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getNode(ISD::UNDEF, NVT); 2595fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 259603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::Constant: 2597ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner if (VT != MVT::i1) 2598ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND, NVT, Op); 2599ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner else 2600ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, NVT, Op); 260103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantSDNode>(Result) && "Didn't constant fold zext?"); 260203c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 260303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::ConstantFP: 260403c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::FP_EXTEND, NVT, Op); 260503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantFPSDNode>(Result) && "Didn't constant fold fp_extend?"); 260603c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2607ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner 260882fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner case ISD::SETCC: 2609c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(TLI.getSetCCResultTy()) && "SetCC type is not legal??"); 26107cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(),Node->getOperand(0), 26117cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(1), Node->getOperand(2)); 261282fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = LegalizeOp(Result); 261382fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner break; 261403c8546ec57523970874917854a2fb77b1ff598eChris Lattner 261503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 261603c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 261703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Legal: 261803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 261903c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.getValueType() >= NVT && 262003c8546ec57523970874917854a2fb77b1ff598eChris Lattner "This truncation doesn't make sense!"); 262103c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (Result.getValueType() > NVT) // Truncate to NVT instead of VT 262203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Result); 262303c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2624e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner case Promote: 2625e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // The truncation is not required, because we don't guarantee anything 2626e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // about high bits anyway. 2627e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner Result = PromoteOp(Node->getOperand(0)); 2628e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner break; 262903c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Expand: 263079e46acd35df36477029e9f534ab1a366a98df56Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 263179e46acd35df36477029e9f534ab1a366a98df56Nate Begeman // Truncate the low part of the expanded value to the result type 2632e21c305ed85b2be4a27784ba52471f6b68fdd255Chris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Tmp1); 263303c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 263403c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 26358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SIGN_EXTEND: 26368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::ZERO_EXTEND: 263713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 26388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 26398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Smaller reg should have been promoted!"); 26408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 26418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Just do extend all the way to the larger type. 26428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 26438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 26448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 26458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 26468b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Promote the reg if it's smaller. 26478b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 26488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The high bits are not guaranteed to be anything. Insert an extend. 26498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND) 2650595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 265115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 265213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner else if (Node->getOpcode() == ISD::ZERO_EXTEND) 265323993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 265423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 26558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 26568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 26578b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 265835481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case ISD::BIT_CONVERT: 265935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Result = ExpandBIT_CONVERT(Node->getValueType(0), Node->getOperand(0)); 266035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Result = PromoteOp(Result); 266135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 266235481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 26638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_EXTEND: 26648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Case not implemented. Dynamically dead with 2 FP types!"); 26658b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_ROUND: 26668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 26678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Cannot expand FP regs!"); 26688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: assert(0 && "Unreachable with 2 FP types!"); 26698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 26708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Do an FP_ROUND_INREG. 26718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 267215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 267315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 26748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 26758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 26768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 26778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 26788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SINT_TO_FP: 26798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UINT_TO_FP: 26808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 26818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 26828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 268377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 268477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 26858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 26868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 26878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 26888b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 26898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP) 26908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 269115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 269215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 26938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 269423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 269523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 269677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 269777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 26988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 26998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 270077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, NVT, 270177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOperand(0)); 270277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // Round if we cannot tolerate excess precision. 270377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (NoExcessFPPrecision) 270415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 270515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 270677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 27078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 27088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 27098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 27105e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner case ISD::SIGN_EXTEND_INREG: 27115e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Result = PromoteOp(Node->getOperand(0)); 27125e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 27135e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Node->getOperand(1)); 27145e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner break; 27158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_SINT: 27168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_UINT: 27178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 27188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 27198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 27208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 27218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 27228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input result is prerounded, so we don't have to do anything 27238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // special. 27248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 27258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 27268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 27278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "not implemented"); 27288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 2729d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // If we're promoting a UINT to a larger size, check to see if the new node 2730d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 2731d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // we can use that instead. This allows us to generate better code for 2732d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 2733d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // legal, such as PowerPC. 2734d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT && 2735c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) && 2736b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman (TLI.isOperationLegal(ISD::FP_TO_SINT, NVT) || 2737b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman TLI.getOperationAction(ISD::FP_TO_SINT, NVT)==TargetLowering::Custom)){ 2738d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(ISD::FP_TO_SINT, NVT, Tmp1); 2739d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2740d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2741d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 27428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 27438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 27442c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 27452c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 27462c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 27472c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(Tmp1.getValueType() == NVT); 27482c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 27492c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NOTE: we do not have to do any extra rounding here for 27502c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NoExcessFPPrecision, because we know the input will have the appropriate 27512c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // precision, and these operations don't modify precision at all. 27522c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 27532c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 2754da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2755da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2756da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 2757da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 2758da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner assert(Tmp1.getValueType() == NVT); 2759da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2760da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner if(NoExcessFPPrecision) 276115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 276215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 2763da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner break; 2764da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner 276503c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::AND: 276603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::OR: 276703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::XOR: 27680f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::ADD: 27698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SUB: 27700f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::MUL: 27710f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // The input may have strange things in the top bits of the registers, but 277201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. They may have weird bits going out, but 27730f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // that too is okay if they are integer operations. 27740f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 27750f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 27760f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 27770f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 277801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 277901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 278001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 278101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 278201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // The input may have strange things in the top bits of the registers, but 278301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. 278401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 278501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 278601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 278701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 278801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 278901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Floating point operations will give excess precision that we may not be 279001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // able to tolerate. If we DO allow excess precision, just leave it, 279101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // otherwise excise it. 27928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // FIXME: Why would we need to round FP ops more than integer ones? 27938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Is Round(Add(Add(A,B),C)) != Round(Add(Round(Add(A,B)), C)) 279401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 279515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 279615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 27970f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 27980f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 27998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SDIV: 28008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SREM: 28018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be sign extended. 28028b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 28038b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 28048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(NVT)) { 280515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 280615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 280715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 280815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 28098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 28108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 28118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 28128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 28138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 281415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 281515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 28168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 281701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 281801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 281901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // These operators require that their input be fp extended. 282001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 282101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 282201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 282301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 282401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 282501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 282601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 282701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getValueType(VT)); 282801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 28298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 28308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UDIV: 28318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UREM: 28328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be zero extended. 28338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 28348b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 28358b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(MVT::isInteger(NVT) && "Operators don't apply to FP!"); 283623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 283723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 28388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 28398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 28408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 28418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SHL: 28428b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 28438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 28448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SHL, NVT, Tmp1, Tmp2); 28458b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 28468b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRA: 28478b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly sign extended. 28488b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 284915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 285015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 28518b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 28528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRA, NVT, Tmp1, Tmp2); 28538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 28548b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRL: 28558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly zero extended. 28568b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 285723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 28588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 28598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRL, NVT, Tmp1, Tmp2); 28608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 286103c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::LOAD: 286203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 286303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2864ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Result = DAG.getExtLoad(ISD::EXTLOAD, NVT, Tmp1, Tmp2, 2865ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Node->getOperand(2), VT); 286603c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Remember that we legalized the chain. 286703c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 286803c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 28694c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::SEXTLOAD: 28704c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::ZEXTLOAD: 28714c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::EXTLOAD: 28724c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 28734c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 28748136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), NVT, Tmp1, Tmp2, 28758136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Node->getOperand(2), 28768136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner cast<VTSDNode>(Node->getOperand(3))->getVT()); 28774c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner // Remember that we legalized the chain. 28784c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 28794c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner break; 288003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SELECT: 288147e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 288247e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 288347e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 288447e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0));// Legalize the condition. 288547e9223e06390897c3834f8c527001df392570ffChris Lattner break; 288647e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 288747e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 288847e9223e06390897c3834f8c527001df392570ffChris Lattner break; 288947e9223e06390897c3834f8c527001df392570ffChris Lattner } 289003c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Legalize the op0 289103c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); // Legalize the op1 289203c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2, Tmp3); 289303c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 28949373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 28959373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2 = PromoteOp(Node->getOperand(2)); // True 28969373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = PromoteOp(Node->getOperand(3)); // False 28979373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 28989373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), Tmp2, Tmp3, 28999373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4)); 29009373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 2901d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 29028ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner case ISD::CALL: { 29038ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 29048ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 29058ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 29063d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 29073d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) 29083d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 29093d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 29108ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 29118ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner "Can only promote single result calls"); 29128ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner std::vector<MVT::ValueType> RetTyVTs; 29138ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.reserve(2); 29148ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(NVT); 29158ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner RetTyVTs.push_back(MVT::Other); 2916d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Tmp1, Tmp2, Ops, 2917d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 29188ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner Result = SDOperand(NC, 0); 29198ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner 29208ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner // Insert the new chain mapping. 29218ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 29228ac532c55eb7f8698466f25d1a8a01240c44ec7dChris Lattner break; 2923edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 2924fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2925fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2926fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2927fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = Node->getOperand(0); 2928fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Zero extend the argument 2929fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2930fecf095292991bdf9396fec474011446107f9813Andrew Lenharth // Perform the larger operation, then subtract if needed. 2931fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 2932fecf095292991bdf9396fec474011446107f9813Andrew Lenharth switch(Node->getOpcode()) 2933fecf095292991bdf9396fec474011446107f9813Andrew Lenharth { 2934fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 2935fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = Tmp1; 2936fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2937fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 2938fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 2939d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 29407cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), ISD::SETEQ); 294100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 2942fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(VT),NVT), Tmp1); 2943fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2944fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 2945fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 294600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 294700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 2948fecf095292991bdf9396fec474011446107f9813Andrew Lenharth getSizeInBits(VT), NVT)); 2949fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 2950fecf095292991bdf9396fec474011446107f9813Andrew Lenharth } 2951fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 295203c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 295303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 295403c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.Val && "Didn't set a result!"); 295503c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddPromotedOperand(Op, Result); 295603c8546ec57523970874917854a2fb77b1ff598eChris Lattner return Result; 295703c8546ec57523970874917854a2fb77b1ff598eChris Lattner} 29583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 295935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner/// ExpandBIT_CONVERT - Expand a BIT_CONVERT node into a store/load combination. 2960232348d66fcfe8f42f8b14cfacd2df3d00d2596eChris Lattner/// The resultant code need not be legal. Note that SrcOp is the input operand 2961232348d66fcfe8f42f8b14cfacd2df3d00d2596eChris Lattner/// to the BIT_CONVERT, not the BIT_CONVERT node itself. 296235481892da1e5634bf497c8a0cabb1bb5a8b8fefChris LattnerSDOperand SelectionDAGLegalize::ExpandBIT_CONVERT(MVT::ValueType DestVT, 296335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner SDOperand SrcOp) { 296435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Create the stack frame object. 296535481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner MachineFrameInfo *FrameInfo = DAG.getMachineFunction().getFrameInfo(); 296635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner unsigned ByteSize = MVT::getSizeInBits(DestVT)/8; 2967232348d66fcfe8f42f8b14cfacd2df3d00d2596eChris Lattner int FrameIdx = FrameInfo->CreateStackObject(ByteSize, ByteSize); 296835481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner SDOperand FIPtr = DAG.getFrameIndex(FrameIdx, TLI.getPointerTy()); 296935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 297035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Emit a store to the stack slot. 297135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner SDOperand Store = DAG.getNode(ISD::STORE, MVT::Other, DAG.getEntryNode(), 2972ed7b5babfbdc708c564266052ad3b0ce0a5726c5Chris Lattner SrcOp, FIPtr, DAG.getSrcValue(NULL)); 297335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Result is a load from the stack slot. 297435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner return DAG.getLoad(DestVT, Store, FIPtr, DAG.getSrcValue(0)); 297535481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner} 297635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 297784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// ExpandAddSub - Find a clever way to expand this add operation into 297884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// subcomponents. 29794759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattnervoid SelectionDAGLegalize:: 29804759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris LattnerExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 29814759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi) { 298284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner // Expand the subcomponents. 298384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 298484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(LHS, LHSL, LHSH); 298584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(RHS, RHSL, RHSH); 298684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 298784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 298884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSL); 298984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSH); 299084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSL); 299184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSH); 2992e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 2993e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 299484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Hi = Lo.getValue(1); 299584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner} 299684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 29975b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattnervoid SelectionDAGLegalize::ExpandShiftParts(unsigned NodeOp, 29985b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand Op, SDOperand Amt, 29995b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi) { 30005b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner // Expand the subcomponents. 30015b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand LHSL, LHSH; 30025b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandOp(Op, LHSL, LHSH); 30035b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 30045b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner std::vector<SDOperand> Ops; 30055b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSL); 30065b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSH); 30075b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(Amt); 3008cc0675a4be9a5133abd48ee272ff999ae48feabfChris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 3009e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 30105b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Hi = Lo.getValue(1); 30115b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner} 30125b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 30135b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 3014e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// ExpandShift - Try to find a clever way to expand this shift operation out to 3015e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// smaller elements. If we can't find a way that is more efficient than a 3016e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// libcall on this target, return false. Otherwise, return true with the 3017e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// low-parts expanded into Lo and Hi. 3018e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattnerbool SelectionDAGLegalize::ExpandShift(unsigned Opc, SDOperand Op,SDOperand Amt, 3019e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi) { 3020e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner assert((Opc == ISD::SHL || Opc == ISD::SRA || Opc == ISD::SRL) && 3021e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner "This is not a shift!"); 3022f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 3023e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(Op.getValueType()); 3024f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand ShAmt = LegalizeOp(Amt); 3025f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman MVT::ValueType ShTy = ShAmt.getValueType(); 3026f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned VTBits = MVT::getSizeInBits(Op.getValueType()); 3027f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned NVTBits = MVT::getSizeInBits(NVT); 3028f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 3029f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Handle the case when Amt is an immediate. Other cases are currently broken 3030f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and are disabled. 3031f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Amt.Val)) { 3032f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned Cst = CN->getValue(); 3033f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Expand the incoming operand to be shifted, so that we have its parts 3034f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand InL, InH; 3035f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman ExpandOp(Op, InL, InH); 3036f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman switch(Opc) { 3037f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SHL: 3038f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 3039f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 3040f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 3041f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 3042f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 3043f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst-NVTBits,ShTy)); 3044ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 3045ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = DAG.getConstant(0, NVT); 3046ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = InL; 3047f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 3048f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst, ShTy)); 3049f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::OR, NVT, 3050f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(Cst, ShTy)), 3051f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(NVTBits-Cst, ShTy))); 3052f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 3053f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 3054f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRL: 3055f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 3056f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 3057f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 3058f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 3059f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst-NVTBits,ShTy)); 3060f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 3061ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 3062ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 3063ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = DAG.getConstant(0, NVT); 3064f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 3065f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 3066f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 3067f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 3068f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst, ShTy)); 3069f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 3070f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 3071f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRA: 3072f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 3073edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 3074f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 3075f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 3076edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Lo = DAG.getNode(ISD::SRA, NVT, InH, 3077f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(Cst-NVTBits, ShTy)); 3078edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 3079f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 3080ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 3081ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 3082edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 3083ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner DAG.getConstant(NVTBits-1, ShTy)); 3084f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 3085f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 3086f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 3087f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 3088f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Cst, ShTy)); 3089f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 3090f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 3091f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 3092f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 3093f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // FIXME: The following code for expanding shifts using ISD::SELECT is buggy, 3094f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // so disable it for now. Currently targets are handling this via SHL_PARTS 3095f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and friends. 3096f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return false; 3097e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3098e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we have an efficient select operation (or if the selects will all fold 3099e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // away), lower to some complex code, otherwise just emit the libcall. 3100c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::SELECT, NVT) && !isa<ConstantSDNode>(Amt)) 3101e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return false; 3102e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3103e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand InL, InH; 3104e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ExpandOp(Op, InL, InH); 3105e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand NAmt = DAG.getNode(ISD::SUB, ShTy, // NAmt = 32-ShAmt 3106e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits, ShTy), ShAmt); 3107e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3108e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner // Compare the unmasked shift amount against 32. 31097cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand Cond = DAG.getSetCC(TLI.getSetCCResultTy(), ShAmt, 31107cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(NVTBits, ShTy), ISD::SETGE); 3111e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner 3112e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getShiftAmountFlavor() != TargetLowering::Mask) { 3113e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ShAmt = DAG.getNode(ISD::AND, ShTy, ShAmt, // ShAmt &= 31 3114e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 3115e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner NAmt = DAG.getNode(ISD::AND, ShTy, NAmt, // NAmt &= 31 3116e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 3117e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 3118e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3119e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (Opc == ISD::SHL) { 3120e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << Amt) | (Lo >> NAmt) 3121e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, ShAmt), 3122e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, NAmt)); 3123e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(ISD::SHL, NVT, InL, ShAmt); // T2 = Lo << Amt&31 3124edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3125e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 3126e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, DAG.getConstant(0, NVT), T2); 3127e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } else { 312877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand HiLoPart = DAG.getNode(ISD::SELECT, NVT, 31297cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getSetCC(TLI.getSetCCResultTy(), NAmt, 31307cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(32, ShTy), 31317cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ), 313277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(0, NVT), 313377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, NAmt)); 3134e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << NAmt) | (Lo >> Amt) 313577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiLoPart, 3136e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, ShAmt)); 3137e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(Opc, NVT, InH, ShAmt); // T2 = InH >> ShAmt&31 3138e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3139e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand HiPart; 314077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Opc == ISD::SRA) 314177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiPart = DAG.getNode(ISD::SRA, NVT, InH, 314277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 3143e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner else 3144e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner HiPart = DAG.getConstant(0, NVT); 3145e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 3146e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, HiPart, T2); 3147e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 3148e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return true; 3149e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner} 315077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 31519530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindLatestCallSeqStart - Scan up the dag to find the latest (highest 31529530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqStart operation and occurs later than 31539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// Found. 3154de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattnerstatic void FindLatestCallSeqStart(SDNode *Node, SDNode *&Found, 3155de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner std::set<SDNode*> &Visited) { 3156de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner if (Node->getNodeDepth() <= Found->getNodeDepth() || 3157de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner !Visited.insert(Node).second) return; 31582f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner 315916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_START, we already know this node occurs later 31609c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 316116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) { 31629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 31639c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 31649c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 31659c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 31669c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 31679c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(Node->getNumOperands() != 0 && 31689c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner "All leaves should have depth equal to the entry node!"); 3169829cb818065673a50101435f3c25e50ca82a02bfNate Begeman for (unsigned i = 0, e = Node->getNumOperands()-1; i != e; ++i) 3170de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner FindLatestCallSeqStart(Node->getOperand(i).Val, Found, Visited); 31719c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 31729c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 31739530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(Node->getNumOperands()-1).Val, 3174de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner Found, Visited); 31759c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 31769c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 31779c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 31789530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindEarliestCallSeqEnd - Scan down the dag to find the earliest (lowest 31799530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqEnd operation and occurs more recent 31809c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// than Found. 318182299e70977500209c951404e354510feffb8efaChris Lattnerstatic void FindEarliestCallSeqEnd(SDNode *Node, SDNode *&Found, 318282299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> &Visited) { 318382299e70977500209c951404e354510feffb8efaChris Lattner if ((Found && Node->getNodeDepth() >= Found->getNodeDepth()) || 318482299e70977500209c951404e354510feffb8efaChris Lattner !Visited.insert(Node).second) return; 31859c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 318616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_END, we already know this node occurs earlier 31879c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 318816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) { 31899c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 31909c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 31919c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 31929c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 31939c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 31949c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end(); 31959c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (UI == E) return; 31969c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (--E; UI != E; ++UI) 319782299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 31989c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 31999c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 320082299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 32019c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 32029c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 32039530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqEnd - Given a chained node that is part of a call sequence, 320416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_END node that terminates the call sequence. 32059530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqEnd(SDNode *Node) { 320616cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 32079c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return Node; 3208f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (Node->use_empty()) 32099530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return 0; // No CallSeqEnd 32109c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 32119c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand TheChain(Node, Node->getNumValues()-1); 32122789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner if (TheChain.getValueType() != MVT::Other) 32132789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner TheChain = SDOperand(Node, 0); 32141aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (TheChain.getValueType() != MVT::Other) 32151aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman return 0; 3216edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3217edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman for (SDNode::use_iterator UI = Node->use_begin(), 32182f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner E = Node->use_end(); UI != E; ++UI) { 3219edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 32209c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Make sure to only follow users of our token chain. 32219c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *User = *UI; 32229c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 32239c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (User->getOperand(i) == TheChain) 3224eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner if (SDNode *Result = FindCallSeqEnd(User)) 3225eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner return Result; 32269c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 32272f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner return 0; 32289c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 32299c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 32309530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqStart - Given a chained node that is part of a call sequence, 323116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_START node that initiates the call sequence. 32329530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqStart(SDNode *Node) { 32339530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(Node && "Didn't find callseq_start for a call??"); 323416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 32350d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 32360d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 32370d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner "Node doesn't have a token chain argument!"); 32389530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqStart(Node->getOperand(0).Val); 32390d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 32400d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 32410d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 32429c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// FindInputOutputChains - If we are replacing an operation with a call we need 32439c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// to find the call that occurs before and the call that occurs after it to 32440d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// properly serialize the calls in the block. The returned operand is the 32450d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// input chain value for the new call (e.g. the entry node or the previous 32460d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// call), and OutChain is set to be the chain node to update to point to the 32470d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// end of the call chain. 32489c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnerstatic SDOperand FindInputOutputChains(SDNode *OpNode, SDNode *&OutChain, 32499c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand Entry) { 32509530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqStart = Entry.Val; 32519530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqEnd = 0; 3252de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner std::set<SDNode*> Visited; 3253de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner FindLatestCallSeqStart(OpNode, LatestCallSeqStart, Visited); 3254de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner Visited.clear(); 32559530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner //std::cerr<<"Found node: "; LatestCallSeqStart->dump(); std::cerr <<"\n"; 3256edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 325716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // It is possible that no ISD::CALLSEQ_START was found because there is no 3258c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman // previous call in the function. LatestCallStackDown may in that case be 325916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // the entry node itself. Do not attempt to find a matching CALLSEQ_END 326016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // unless LatestCallStackDown is an CALLSEQ_START. 32611aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (LatestCallSeqStart->getOpcode() == ISD::CALLSEQ_START) { 32629530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = FindCallSeqEnd(LatestCallSeqStart); 32631aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman //std::cerr<<"Found end node: "; LatestCallSeqEnd->dump(); std::cerr <<"\n"; 32641aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } else { 32659530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = Entry.Val; 32661aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } 32679530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(LatestCallSeqEnd && "NULL return from FindCallSeqEnd"); 3268edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 32690d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Finally, find the first call that this must come before, first we find the 32709530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // CallSeqEnd that ends the call. 32710d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain = 0; 327282299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(OpNode, OutChain, Visited); 3273de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner Visited.clear(); 32749c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 32759530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // If we found one, translate from the adj up to the callseq_start. 32760d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain) 32779530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner OutChain = FindCallSeqStart(OutChain); 32789c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 32799530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return SDOperand(LatestCallSeqEnd, 0); 32809c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 32819c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 328200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen/// SpliceCallInto - Given the result chain of a libcall (CallResult), and a 3283b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattnervoid SelectionDAGLegalize::SpliceCallInto(const SDOperand &CallResult, 3284b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SDNode *OutChain) { 32850d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Nothing to splice it into? 32860d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain == 0) return; 32870d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 32880d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(OutChain->getOperand(0).getValueType() == MVT::Other); 32890d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner //OutChain->dump(); 32900d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 32910d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Form a token factor node merging the old inval and the new inval. 32920d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InToken = DAG.getNode(ISD::TokenFactor, MVT::Other, CallResult, 32930d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->getOperand(0)); 32940d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Change the node to refer to the new token. 32950d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->setAdjCallChain(InToken); 32960d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 32979c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 32989c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 329977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 330077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 330177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 330277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 330377e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize::ExpandLibCall(const char *Name, SDNode *Node, 330477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi) { 33059c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *OutChain; 33069c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand InChain = FindInputOutputChains(Node, OutChain, 33079c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner DAG.getEntryNode()); 3308f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (InChain.Val == 0) 3309f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner InChain = DAG.getEntryNode(); 33109c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 331177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 331277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 331377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner MVT::ValueType ArgVT = Node->getOperand(i).getValueType(); 331477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(ArgVT); 331577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Node->getOperand(i), ArgTy)); 331677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 331777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(Name, TLI.getPointerTy()); 3318edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 33190d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 332077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(Node->getValueType(0)); 33210d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallInfo = 3322adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, false, 3323adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 33240d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 332599c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SDOperand Result; 33260d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner switch (getTypeAction(CallInfo.first.getValueType())) { 332777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner default: assert(0 && "Unknown thing"); 332877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Legal: 332999c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner Result = CallInfo.first; 333099c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 333177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Promote: 333277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(0 && "Cannot promote this yet!"); 333377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Expand: 333499c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner ExpandOp(CallInfo.first, Result, Hi); 333599c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner CallInfo.second = LegalizeOp(CallInfo.second); 333699c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 333777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 333899c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner 333999c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SpliceCallInto(CallInfo.second, OutChain); 334099c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner NeedsAnotherIteration = true; 334199c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner return Result; 334277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 334377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 33449c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 334577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// ExpandIntToFP - Expand a [US]INT_TO_FP operation, assuming that the 334677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// destination type is legal. 334777e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize:: 334877e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) { 3349c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(DestTy) && "Destination type is not legal!"); 335077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(Source.getValueType()) == Expand && 335177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner "This is not an expansion!"); 335277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(Source.getValueType() == MVT::i64 && "Only handle expand from i64!"); 335377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 33540d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (!isSigned) { 3355e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(Source.getValueType() == MVT::i64 && 3356e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner "This only works for 64-bit -> FP"); 3357e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 3358e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // incoming integer is set. To handle this, we dynamically test to see if 3359e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // it is set, and, if so, add a fudge factor. 3360e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Lo, Hi; 3361e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner ExpandOp(Source, Lo, Hi); 3362e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 336366de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 336466de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // signed, then adjust the result if the sign bit is set. 336566de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner SDOperand SignedConv = ExpandIntToFP(true, DestTy, 336666de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), Lo, Hi)); 336766de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 33687cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Hi, 33697cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Hi.getValueType()), 33707cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 3371e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 3372e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 3373e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SignSet, Four, Zero); 3374383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner uint64_t FF = 0x5f800000ULL; 3375383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 3376383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 3377e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 33785839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 3379e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 3380e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand FudgeInReg; 3381e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner if (DestTy == MVT::f32) 338252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 338352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 3384e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner else { 3385e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(DestTy == MVT::f64 && "Unexpected conversion"); 33865f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 33875f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 3388e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 3389473a99073cc29f59809a0d5dfee11f5e9e6ad2b7Chris Lattner return DAG.getNode(ISD::FADD, DestTy, SignedConv, FudgeInReg); 339077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 33910d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 3392a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 3393a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, Source.getValueType())) { 3394a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 3395a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Legal: 3396a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Expand: 3397a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner break; // This case is handled below. 339807dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 339907dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand NV = TLI.LowerOperation(DAG.getNode(ISD::SINT_TO_FP, DestTy, 340007dffd6af673c73352150583150b242a93694f00Chris Lattner Source), DAG); 340107dffd6af673c73352150583150b242a93694f00Chris Lattner if (NV.Val) 340207dffd6af673c73352150583150b242a93694f00Chris Lattner return LegalizeOp(NV); 340307dffd6af673c73352150583150b242a93694f00Chris Lattner break; // The target decided this was legal after all 340407dffd6af673c73352150583150b242a93694f00Chris Lattner } 3405a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 3406a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 340713689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // Expand the source, then glue it back together for the call. We must expand 340813689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // the source in case it is shared (this pass of legalize must traverse it). 340913689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner SDOperand SrcLo, SrcHi; 341013689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner ExpandOp(Source, SrcLo, SrcHi); 341113689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner Source = DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), SrcLo, SrcHi); 341213689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 34130d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDNode *OutChain = 0; 34140d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InChain = FindInputOutputChains(Source.Val, OutChain, 34150d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner DAG.getEntryNode()); 34160d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner const char *FnName = 0; 34170d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (DestTy == MVT::f32) 34180d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdisf"; 34190d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner else { 34200d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(DestTy == MVT::f64 && "Unknown fp value type!"); 34210d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdidf"; 34220d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 34230d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 342477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(FnName, TLI.getPointerTy()); 342577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 342677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 342777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(Source.getValueType()); 342844d105b7faf5672a2af61a3f0fdfed0d437d5777Chris Lattner 342977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Source, ArgTy)); 343077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 343177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // We don't care about token chains for libcalls. We just use the entry 343277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // node as our input and ignore the output chain. This allows us to place 343377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // calls wherever we need them to satisfy data dependences. 343477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(DestTy); 34350d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 34360d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 3437adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, true, 3438adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 34390d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 3440b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallResult.second, OutChain); 34410d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallResult.first; 344277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 3443edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3444e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3445e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 34463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandOp - Expand the specified SDOperand into its two component pieces 34473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo&Hi. Note that the Op MUST be an expanded type. As a result of this, the 34483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// LegalizeNodes map is filled in for any results that are not expanded, the 34493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandedNodes map is filled in for any results that are expanded, and the 34503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo/Hi values are returned. 34513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){ 34523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = Op.getValueType(); 345371c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 34543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDNode *Node = Op.Val; 34553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(VT) == Expand && "Not an expanded type!"); 3456ab48be377298bd509427a29e174cf4e305138819Nate Begeman assert((MVT::isInteger(VT) || VT == MVT::Vector) && 3457ab48be377298bd509427a29e174cf4e305138819Nate Begeman "Cannot expand FP values!"); 3458ab48be377298bd509427a29e174cf4e305138819Nate Begeman assert(((MVT::isInteger(NVT) && NVT < VT) || VT == MVT::Vector) && 34593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand to FP value or to larger int value!"); 34603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 34616fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner // See if we already expanded it. 34626fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I 34636fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner = ExpandedNodes.find(Op); 34646fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != ExpandedNodes.end()) { 34656fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Lo = I->second.first; 34666fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Hi = I->second.second; 34676fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner return; 34683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 34693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 34704e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // Expanding to multiple registers needs to perform an optimization step, and 34714e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // is not careful to avoid operations the target does not support. Make sure 34724e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // that all generated operations are legalized in the next iteration. 34734e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NeedsAnotherIteration = true; 34743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 34753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 3476d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 3477d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 3478d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner default: 34793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 34803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to expand this operator!"); 34813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 3482fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 3483fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Lo = DAG.getNode(ISD::UNDEF, NVT); 3484fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Hi = DAG.getNode(ISD::UNDEF, NVT); 3485fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 34863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: { 34873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner uint64_t Cst = cast<ConstantSDNode>(Node)->getValue(); 34883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getConstant(Cst, NVT); 34893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT); 34903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 34913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3492cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman case ISD::ConstantVec: { 3493cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman unsigned NumElements = Node->getNumOperands(); 3494cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // If we only have two elements left in the constant vector, just break it 3495cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // apart into the two scalar constants it contains. Otherwise, bisect the 3496cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // ConstantVec, and return each half as a new ConstantVec. 3497cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // FIXME: this is hard coded as big endian, it may have to change to support 3498cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // SSE and Alpha MVI 3499cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman if (NumElements == 2) { 3500cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Hi = Node->getOperand(0); 3501cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Lo = Node->getOperand(1); 3502cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } else { 3503cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman NumElements /= 2; 3504cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman std::vector<SDOperand> LoOps, HiOps; 3505cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman for (unsigned I = 0, E = NumElements; I < E; ++I) { 3506cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman HiOps.push_back(Node->getOperand(I)); 3507cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman LoOps.push_back(Node->getOperand(I+NumElements)); 3508cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 3509cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Lo = DAG.getNode(ISD::ConstantVec, MVT::Vector, LoOps); 3510cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Hi = DAG.getNode(ISD::ConstantVec, MVT::Vector, HiOps); 3511cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 3512cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman break; 3513cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 35143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3515d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner case ISD::BUILD_PAIR: 3516d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // Legalize both operands. FIXME: in the future we should handle the case 3517d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // where the two elements are not legal. 3518d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 3519d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Lo = LegalizeOp(Node->getOperand(0)); 3520d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Hi = LegalizeOp(Node->getOperand(1)); 3521d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner break; 352258f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner 352358f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner case ISD::SIGN_EXTEND_INREG: 352458f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 352558f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner // Sign extend the lo-part. 352658f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, 352758f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner DAG.getConstant(MVT::getSizeInBits(NVT)-1, 352858f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner TLI.getShiftAmountTy())); 352958f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner // sext_inreg the low part if needed. 353058f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Lo, Node->getOperand(1)); 353158f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner break; 3532d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner 3533edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner case ISD::CTPOP: 3534edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 35359b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner Lo = DAG.getNode(ISD::ADD, NVT, // ctpop(HL) -> ctpop(H)+ctpop(L) 35369b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Lo), 35379b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Hi)); 3538edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getConstant(0, NVT); 3539edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner break; 3540edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 354139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTLZ: { 354239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // ctlz (HL) -> ctlz(H) != 32 ? ctlz(H) : (ctlz(L)+32) 35433becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 354439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 354539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 35467cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand TopNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), HLZ, BitsC, 35477cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 354839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LowPart = DAG.getNode(ISD::CTLZ, NVT, Lo); 354939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LowPart = DAG.getNode(ISD::ADD, NVT, LowPart, BitsC); 355039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 355139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, TopNotZero, HLZ, LowPart); 355239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 355339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 355439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 355539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 355639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTTZ: { 355739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // cttz (HL) -> cttz(L) != 32 ? cttz(L) : (cttz(H)+32) 35583becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 355939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 356039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LTZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 35617cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand BotNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), LTZ, BitsC, 35627cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 356339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HiPart = DAG.getNode(ISD::CTTZ, NVT, Hi); 356439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HiPart = DAG.getNode(ISD::ADD, NVT, HiPart, BitsC); 356539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 356639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, BotNotZero, LTZ, HiPart); 356739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 356839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 356939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 3570edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 35713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: { 35723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 35733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 35742d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Lo = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 35753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 35763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Increment the pointer to the other half. 357738d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner unsigned IncrementSize = MVT::getSizeInBits(Lo.getValueType())/8; 35783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 35793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 358000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen //Is this safe? declaring that the two parts of the split load 35812d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //are from the same instruction? 35822d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Hi = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 3583ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner 3584ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Build a factor node to remember that this load is independent of the 3585ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // other one. 3586ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 3587ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi.getValue(1)); 3588edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 35893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember that we legalized the chain. 3590ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner AddLegalizedOperand(Op.getValue(1), TF); 35913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 35923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 35933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 35943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3595ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VLOAD: { 3596ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3597ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 3598ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElements =cast<ConstantSDNode>(Node->getOperand(2))->getValue(); 3599ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3600ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3601ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If we only have two elements, turn into a pair of scalar loads. 3602ab48be377298bd509427a29e174cf4e305138819Nate Begeman // FIXME: handle case where a vector of two elements is fine, such as 3603ab48be377298bd509427a29e174cf4e305138819Nate Begeman // 2 x double on SSE2. 3604ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (NumElements == 2) { 3605ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getLoad(EVT, Ch, Ptr, Node->getOperand(4)); 3606ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Increment the pointer to the other half. 3607ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize = MVT::getSizeInBits(EVT)/8; 3608ab48be377298bd509427a29e174cf4e305138819Nate Begeman Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 3609ab48be377298bd509427a29e174cf4e305138819Nate Begeman getIntPtrConstant(IncrementSize)); 3610ab48be377298bd509427a29e174cf4e305138819Nate Begeman //Is this safe? declaring that the two parts of the split load 3611ab48be377298bd509427a29e174cf4e305138819Nate Begeman //are from the same instruction? 3612ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getLoad(EVT, Ch, Ptr, Node->getOperand(4)); 3613ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 3614ab48be377298bd509427a29e174cf4e305138819Nate Begeman NumElements /= 2; // Split the vector in half 3615ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getVecLoad(NumElements, EVT, Ch, Ptr, Node->getOperand(4)); 3616ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize = NumElements * MVT::getSizeInBits(EVT)/8; 3617ab48be377298bd509427a29e174cf4e305138819Nate Begeman Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 3618ab48be377298bd509427a29e174cf4e305138819Nate Begeman getIntPtrConstant(IncrementSize)); 3619ab48be377298bd509427a29e174cf4e305138819Nate Begeman //Is this safe? declaring that the two parts of the split load 3620ab48be377298bd509427a29e174cf4e305138819Nate Begeman //are from the same instruction? 3621ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getVecLoad(NumElements, EVT, Ch, Ptr, Node->getOperand(4)); 3622ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3623ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3624ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Build a factor node to remember that this load is independent of the 3625ab48be377298bd509427a29e174cf4e305138819Nate Begeman // other one. 3626ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 3627ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi.getValue(1)); 3628ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3629ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Remember that we legalized the chain. 3630ab48be377298bd509427a29e174cf4e305138819Nate Begeman AddLegalizedOperand(Op.getValue(1), TF); 3631ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (!TLI.isLittleEndian()) 3632ab48be377298bd509427a29e174cf4e305138819Nate Begeman std::swap(Lo, Hi); 3633ab48be377298bd509427a29e174cf4e305138819Nate Begeman break; 3634ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3635ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VADD: 3636ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VSUB: 3637ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VMUL: { 3638ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElements =cast<ConstantSDNode>(Node->getOperand(2))->getValue(); 3639ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3640ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand LL, LH, RL, RH; 3641ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3642ab48be377298bd509427a29e174cf4e305138819Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 3643ab48be377298bd509427a29e174cf4e305138819Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 3644ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3645ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If we only have two elements, turn into a pair of scalar loads. 3646ab48be377298bd509427a29e174cf4e305138819Nate Begeman // FIXME: handle case where a vector of two elements is fine, such as 3647ab48be377298bd509427a29e174cf4e305138819Nate Begeman // 2 x double on SSE2. 3648ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (NumElements == 2) { 3649ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned Opc = getScalarizedOpcode(Node->getOpcode(), EVT); 3650ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getNode(Opc, EVT, LL, RL); 3651ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getNode(Opc, EVT, LH, RH); 3652ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 3653ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getNode(Node->getOpcode(), MVT::Vector, LL, RL, LL.getOperand(2), 3654ab48be377298bd509427a29e174cf4e305138819Nate Begeman LL.getOperand(3)); 3655ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getNode(Node->getOpcode(), MVT::Vector, LH, RH, LH.getOperand(2), 3656ab48be377298bd509427a29e174cf4e305138819Nate Begeman LH.getOperand(3)); 3657ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3658ab48be377298bd509427a29e174cf4e305138819Nate Begeman break; 3659ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 3660d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner case ISD::TAILCALL: 36613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CALL: { 36623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 36633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Callee = LegalizeOp(Node->getOperand(1)); // Legalize the callee. 36643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 36653d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner bool Changed = false; 36663d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner std::vector<SDOperand> Ops; 36673d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner for (unsigned i = 2, e = Node->getNumOperands(); i != e; ++i) { 36683d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 36693d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 36703d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner } 36713d9dffc5863d0319aa9c5cb156045ae6778cba01Chris Lattner 36723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(Node->getNumValues() == 2 && Op.ResNo == 0 && 36733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Can only expand a call once so far, not i64 -> i16!"); 36743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 36753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<MVT::ValueType> RetTyVTs; 36763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.reserve(3); 36773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 36783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(NVT); 36793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner RetTyVTs.push_back(MVT::Other); 3680d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner SDNode *NC = DAG.getCall(RetTyVTs, Chain, Callee, Ops, 3681d71c04199c447de39a2cab240c2fb7f717973e20Chris Lattner Node->getOpcode() == ISD::TAILCALL); 36823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = SDOperand(NC, 0); 36833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = SDOperand(NC, 1); 36843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 36853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Insert the new chain mapping. 3686e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner AddLegalizedOperand(Op.getValue(1), Hi.getValue(2)); 36873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 36883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 36893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 36903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 36913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: { // Simple logical operators -> two trivial pieces. 36923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LL, LH, RL, RH; 36933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LL, LH); 36943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RL, RH); 36953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(Node->getOpcode(), NVT, LL, RL); 36963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(Node->getOpcode(), NVT, LH, RH); 36973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 36983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 36993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SELECT: { 37003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand C, LL, LH, RL, RH; 370147e9223e06390897c3834f8c527001df392570ffChris Lattner 370247e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 370347e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 370447e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 370547e9223e06390897c3834f8c527001df392570ffChris Lattner C = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 370647e9223e06390897c3834f8c527001df392570ffChris Lattner break; 370747e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 370847e9223e06390897c3834f8c527001df392570ffChris Lattner C = PromoteOp(Node->getOperand(0)); // Promote the condition. 370947e9223e06390897c3834f8c527001df392570ffChris Lattner break; 371047e9223e06390897c3834f8c527001df392570ffChris Lattner } 37113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), LL, LH); 37123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(2), RL, RH); 37133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, C, LL, RL); 37143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, C, LH, RH); 37153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 37163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 37179373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: { 37189373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand TL, TH, FL, FH; 37199373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(2), TL, TH); 37209373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(3), FL, FH); 37219373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Lo = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 37229373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TL, FL, Node->getOperand(4)); 37239373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Hi = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 37249373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TH, FH, Node->getOperand(4)); 3725e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Lo = LegalizeOp(Lo); 3726e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Hi = LegalizeOp(Hi); 37279373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 37289373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 3729144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::SEXTLOAD: { 3730144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 3731144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 3732144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3733144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 3734144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 3735144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 3736144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 3737144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::SEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 3738144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 37399ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 37409ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 37419ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 37429ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 3743144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is obtained by SRA'ing all but one of the bits of the lo 3744144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // part. 3745144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 3746144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 3747144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman TLI.getShiftAmountTy())); 3748144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 3749144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = LegalizeOp(Hi); 3750144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 3751144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 3752144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::ZEXTLOAD: { 3753144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 3754144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 3755144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3756144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 3757144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 3758144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 3759144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 3760144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 3761144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 37629ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 37639ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 37649ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 37659ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 3766144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is just a zero. 37679ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getConstant(0, NVT)); 37689ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = LegalizeOp(Lo); 37699ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner break; 37709ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner } 37719ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner case ISD::EXTLOAD: { 37729ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); 37739ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 37749ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 37759ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 37769ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner if (EVT == NVT) 37779ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 37789ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner else 37799ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getExtLoad(ISD::EXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 37809ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner EVT); 37819ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 37829ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 37839ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 37849ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 37859ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // The high part is undefined. 37869ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getNode(ISD::UNDEF, NVT)); 3787144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 3788144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 3789144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 379013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: { 379113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner SDOperand In; 379213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 379313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 379413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 379513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Promote: 379613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner In = PromoteOp(Node->getOperand(0)); 379713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 379813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 379913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner 380013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The low part is any extension of the input (which degenerates to a copy). 380113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Lo = DAG.getNode(ISD::ANY_EXTEND, NVT, In); 380213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The high part is undefined. 380313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); 380413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 380513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 38063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: { 380706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 380806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 380906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 381006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 381106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 381206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 381306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate sign_extend_inreg to get the value we want. 381406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), In, 381515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 381606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 381706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 381806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 38193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a sign extension of the input (which degenerates to 38203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 382106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, In); 3822edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 38233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is obtained by SRA'ing all but one of the bits of the lo 38243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // part. 38252dad454af674cb41a14a85ad6ce5c85c43959acdChris Lattner unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 382627ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 382727ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner TLI.getShiftAmountTy())); 38283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 38293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 383006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case ISD::ZERO_EXTEND: { 383106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 383206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 383306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 383406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 383506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 383606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 383706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate zero_extend_inreg to get the value we want. 383823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner In = DAG.getZeroExtendInReg(In, Node->getOperand(0).getValueType()); 383906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 384006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 384106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 38423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a zero extension of the input (which degenerates to 38433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 3844dea29e25c32d2651e2efaff67bc30803ea24d991Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, In); 3845edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 38463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is just a zero. 38473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(0, NVT); 38483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 384906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 385035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 385135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case ISD::BIT_CONVERT: { 385235481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner SDOperand Tmp = ExpandBIT_CONVERT(Node->getValueType(0), 385335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Node->getOperand(0)); 385435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner ExpandOp(Tmp, Lo, Hi); 385535481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 385635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner } 3857f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 3858308575be66ec3870d27b19df044fda18448feb41Chris Lattner case ISD::READCYCLECOUNTER: { 3859308575be66ec3870d27b19df044fda18448feb41Chris Lattner assert(TLI.getOperationAction(ISD::READCYCLECOUNTER, VT) == 3860308575be66ec3870d27b19df044fda18448feb41Chris Lattner TargetLowering::Custom && 3861308575be66ec3870d27b19df044fda18448feb41Chris Lattner "Must custom expand ReadCycleCounter"); 3862308575be66ec3870d27b19df044fda18448feb41Chris Lattner SDOperand T = TLI.LowerOperation(Op, DAG); 3863308575be66ec3870d27b19df044fda18448feb41Chris Lattner assert(T.Val && "Node must be custom expanded!"); 3864308575be66ec3870d27b19df044fda18448feb41Chris Lattner Lo = LegalizeOp(T.getValue(0)); 3865308575be66ec3870d27b19df044fda18448feb41Chris Lattner Hi = LegalizeOp(T.getValue(1)); 3866308575be66ec3870d27b19df044fda18448feb41Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), // Remember we legalized the chain. 3867308575be66ec3870d27b19df044fda18448feb41Chris Lattner LegalizeOp(T.getValue(2))); 3868f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth break; 3869308575be66ec3870d27b19df044fda18448feb41Chris Lattner } 3870f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 38714e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // These operators cannot be expanded directly, emit them as calls to 38724e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // library functions. 38734e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_SINT: 387480a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_SINT, VT) == TargetLowering::Custom) { 3875f20d183c2268553c738fefb014959ea924dd0555Chris Lattner SDOperand Op; 3876f20d183c2268553c738fefb014959ea924dd0555Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 3877f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Expand: assert(0 && "cannot expand FP!"); 3878f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Legal: Op = LegalizeOp(Node->getOperand(0)); break; 3879f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Promote: Op = PromoteOp(Node->getOperand(0)); break; 3880f20d183c2268553c738fefb014959ea924dd0555Chris Lattner } 3881d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3882f20d183c2268553c738fefb014959ea924dd0555Chris Lattner Op = TLI.LowerOperation(DAG.getNode(ISD::FP_TO_SINT, VT, Op), DAG); 3883f20d183c2268553c738fefb014959ea924dd0555Chris Lattner 388480a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 388580a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 388607dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 388707dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 388807dffd6af673c73352150583150b242a93694f00Chris Lattner break; 388907dffd6af673c73352150583150b242a93694f00Chris Lattner } 389080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3891d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 38924e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 389377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixsfdi", Node, Hi); 38944e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 389577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixdfdi", Node, Hi); 38964e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 3897d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 38984e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_UINT: 389980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_UINT, VT) == TargetLowering::Custom) { 390080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner SDOperand Op = DAG.getNode(ISD::FP_TO_UINT, VT, 390180a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner LegalizeOp(Node->getOperand(0))); 390280a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 390380a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 390407dffd6af673c73352150583150b242a93694f00Chris Lattner Op = TLI.LowerOperation(Op, DAG); 390507dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 390607dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 390707dffd6af673c73352150583150b242a93694f00Chris Lattner break; 390807dffd6af673c73352150583150b242a93694f00Chris Lattner } 390980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 3910d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 39114e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 391277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunssfdi", Node, Hi); 39134e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 391477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunsdfdi", Node, Hi); 39154e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 39164e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner 391705a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng case ISD::SHL: { 391850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 391950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SHL, VT) == TargetLowering::Custom) { 392050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SHL, VT, Node->getOperand(0), 392150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 392250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 392350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 392450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 392550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 392650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 392750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 392850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 392950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 393050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3931e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 393277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SHL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3933e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 39344759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 39354759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SHL_PARTS, use it. 393605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TargetLowering::LegalizeAction Action = 393705a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TLI.getOperationAction(ISD::SHL_PARTS, NVT); 393805a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) || 393905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Action == TargetLowering::Custom) { 39405b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SHL_PARTS, Node->getOperand(0), Node->getOperand(1), 39415b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 39424759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 39434759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 39444759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3945e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 394677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashldi3", Node, Hi); 3947e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 394805a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 3949e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 395005a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng case ISD::SRA: { 395150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 395250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRA, VT) == TargetLowering::Custom) { 395350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRA, VT, Node->getOperand(0), 395450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 395550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 395650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 395750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 395850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 395950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 396050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 396150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 396250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 396350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3964e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 396577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRA, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3966e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 39674759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 39684759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRA_PARTS, use it. 396905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TargetLowering::LegalizeAction Action = 397005a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TLI.getOperationAction(ISD::SRA_PARTS, NVT); 397105a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) || 397205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Action == TargetLowering::Custom) { 39735b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRA_PARTS, Node->getOperand(0), Node->getOperand(1), 39745b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 39754759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 39764759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 39774759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 3978e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 397977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashrdi3", Node, Hi); 3980e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 398105a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 398205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng 398305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng case ISD::SRL: { 398450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 398550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRL, VT) == TargetLowering::Custom) { 398650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRL, VT, Node->getOperand(0), 398750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner LegalizeOp(Node->getOperand(1))); 398850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 398950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 399050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 399150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 399250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 399350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 399450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 399550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 399650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 3997e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 399877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (ExpandShift(ISD::SRL, Node->getOperand(0), Node->getOperand(1), Lo, Hi)) 3999e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 40004759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 40014759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRL_PARTS, use it. 400205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TargetLowering::LegalizeAction Action = 400305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TLI.getOperationAction(ISD::SRL_PARTS, NVT); 400405a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) || 400505a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Action == TargetLowering::Custom) { 40065b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandShiftParts(ISD::SRL_PARTS, Node->getOperand(0), Node->getOperand(1), 40075b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Lo, Hi); 40084759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 40094759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 40104759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 4011e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 401277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__lshrdi3", Node, Hi); 4013e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 401405a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 4015e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 4016edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case ISD::ADD: 40174759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::ADD_PARTS, Node->getOperand(0), Node->getOperand(1), 40184759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 401984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 402084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::SUB: 40214759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::SUB_PARTS, Node->getOperand(0), Node->getOperand(1), 40224759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 402384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 4024c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MUL: { 4025c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::MULHU, NVT)) { 4026c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman SDOperand LL, LH, RL, RH; 4027c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 4028c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 402956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman unsigned SH = MVT::getSizeInBits(RH.getValueType())-1; 403056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // MULHS implicitly sign extends its inputs. Check to see if ExpandOp 403156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // extended the sign bit of the low half through the upper half, and if so 403256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // emit a MULHS instead of the alternate sequence that is valid for any 403356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // i64 x i64 multiply. 403456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman if (TLI.isOperationLegal(ISD::MULHS, NVT) && 403556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is RH an extension of the sign bit of RL? 403656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOpcode() == ISD::SRA && RH.getOperand(0) == RL && 403756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOperand(1).getOpcode() == ISD::Constant && 403856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(RH.getOperand(1))->getValue() == SH && 403956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is LH an extension of the sign bit of LL? 404056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOpcode() == ISD::SRA && LH.getOperand(0) == LL && 404156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOperand(1).getOpcode() == ISD::Constant && 404256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(LH.getOperand(1))->getValue() == SH) { 404356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHS, NVT, LL, RL); 404456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } else { 404556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 404656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 404756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 404856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 404956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 405056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } 4051c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 4052c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } else { 4053c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = ExpandLibCall("__muldi3" , Node, Hi); break; 4054c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 4055c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman break; 4056c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 405777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SDIV: Lo = ExpandLibCall("__divdi3" , Node, Hi); break; 405877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UDIV: Lo = ExpandLibCall("__udivdi3", Node, Hi); break; 405977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SREM: Lo = ExpandLibCall("__moddi3" , Node, Hi); break; 406077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UREM: Lo = ExpandLibCall("__umoddi3", Node, Hi); break; 40613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 40623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 406383397363348662e9352455ea1e6e88e7026300a4Chris Lattner // Make sure the resultant values have been legalized themselves, unless this 406483397363348662e9352455ea1e6e88e7026300a4Chris Lattner // is a type that requires multi-step expansion. 406583397363348662e9352455ea1e6e88e7026300a4Chris Lattner if (getTypeAction(NVT) != Expand && NVT != MVT::isVoid) { 406683397363348662e9352455ea1e6e88e7026300a4Chris Lattner Lo = LegalizeOp(Lo); 406783397363348662e9352455ea1e6e88e7026300a4Chris Lattner Hi = LegalizeOp(Hi); 406883397363348662e9352455ea1e6e88e7026300a4Chris Lattner } 406905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng 407005a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng // Remember in a map if the values will be reused later. 407105a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng bool isNew = 407205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng ExpandedNodes.insert(std::make_pair(Op, std::make_pair(Lo, Hi))).second; 407305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng assert(isNew && "Value already expanded?!?"); 40743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 40753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 40763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 40773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 40783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 40799c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnervoid SelectionDAG::Legalize() { 40803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 40813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 40829c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(*this).Run(); 40833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 40843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4085