LegalizeDAG.cpp revision 9c6b4b8c3a48aa420f6499ca6c1a356f74e100f8
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(); 630063e765345fd49df0f53b807e57ada7c2ded7e16Jim Laskey unsigned SrcFile = DebugInfo->RecordSource(DirName, FName); 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); 8266a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner 8276a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner // If this has a flag input, do legalize it. 8286a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner if (Node->getOperand(Node->getNumOperands()-1).getValueType() == MVT::Flag){ 8296a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(Node->getNumOperands()-1)); 8306a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner if (Tmp1 != Node->getOperand(Node->getNumOperands()-1)) 8316a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner Node->setAdjCallFlag(Tmp1); 8326a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner } 83327d404ccd1e86b7fffaf8037bf6b6dfb0b9d683bNate Begeman 83416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // Note that we do not create new CALLSEQ_DOWN/UP nodes here. These 83588de6e77bfadea8962b017f372658204ab71448cChris Lattner // nodes are treated specially and are mutated in place. This makes the dag 83688de6e77bfadea8962b017f372658204ab71448cChris Lattner // legalization process more efficient and also makes libcall insertion 83788de6e77bfadea8962b017f372658204ab71448cChris Lattner // easier. 8383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 839a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng case ISD::DYNAMIC_STACKALLOC: { 840fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 841fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 842fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 843fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 844adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Tmp3 != Node->getOperand(2)) { 845adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 846adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 847adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 848adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 849adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner } else 850513e52ec4e20048a8f491498d219a2669283f3bdChris Lattner Result = Op.getValue(0); 851fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 8525f652295c27826f26547cf5eb4096a59d86b56b8Chris Lattner Tmp1 = Result; 8535f652295c27826f26547cf5eb4096a59d86b56b8Chris Lattner Tmp2 = Result.getValue(1); 854a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), 855a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng Node->getValueType(0))) { 856a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng default: assert(0 && "This action is not supported yet!"); 857903d278a9b7398d8905c90832e587e0556c52789Chris Lattner case TargetLowering::Expand: { 858903d278a9b7398d8905c90832e587e0556c52789Chris Lattner unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore(); 859903d278a9b7398d8905c90832e587e0556c52789Chris Lattner assert(SPReg && "Target cannot require DYNAMIC_STACKALLOC expansion and" 860903d278a9b7398d8905c90832e587e0556c52789Chris Lattner " not tell us which reg is the stack pointer!"); 861903d278a9b7398d8905c90832e587e0556c52789Chris Lattner SDOperand Chain = Tmp1.getOperand(0); 862903d278a9b7398d8905c90832e587e0556c52789Chris Lattner SDOperand Size = Tmp2.getOperand(1); 863903d278a9b7398d8905c90832e587e0556c52789Chris Lattner SDOperand SP = DAG.getCopyFromReg(Chain, SPReg, Node->getValueType(0)); 864903d278a9b7398d8905c90832e587e0556c52789Chris Lattner Tmp1 = DAG.getNode(ISD::SUB, Node->getValueType(0), SP, Size); // Value 865903d278a9b7398d8905c90832e587e0556c52789Chris Lattner Tmp2 = DAG.getCopyToReg(SP.getValue(1), SPReg, Tmp1); // Output chain 866903d278a9b7398d8905c90832e587e0556c52789Chris Lattner break; 867903d278a9b7398d8905c90832e587e0556c52789Chris Lattner } 868903d278a9b7398d8905c90832e587e0556c52789Chris Lattner case TargetLowering::Custom: 8695f652295c27826f26547cf5eb4096a59d86b56b8Chris Lattner Tmp3 = TLI.LowerOperation(Tmp1, DAG); 8705f652295c27826f26547cf5eb4096a59d86b56b8Chris Lattner if (Tmp3.Val) { 8715f652295c27826f26547cf5eb4096a59d86b56b8Chris Lattner Tmp1 = LegalizeOp(Tmp3); 8725f652295c27826f26547cf5eb4096a59d86b56b8Chris Lattner Tmp2 = LegalizeOp(Tmp3.getValue(1)); 873a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng } 874903d278a9b7398d8905c90832e587e0556c52789Chris Lattner break; 875a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng case TargetLowering::Legal: 876903d278a9b7398d8905c90832e587e0556c52789Chris Lattner break; 877a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng } 878903d278a9b7398d8905c90832e587e0556c52789Chris Lattner // Since this op produce two values, make sure to remember that we 879903d278a9b7398d8905c90832e587e0556c52789Chris Lattner // legalized both of them. 880903d278a9b7398d8905c90832e587e0556c52789Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Tmp1); 881903d278a9b7398d8905c90832e587e0556c52789Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Tmp2); 882903d278a9b7398d8905c90832e587e0556c52789Chris Lattner return Op.ResNo ? Tmp2 : Tmp1; 883a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng } 884ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner case ISD::INLINEASM: 885ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize Chain. 886ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Tmp2 = Node->getOperand(Node->getNumOperands()-1); 887ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner if (Tmp2.getValueType() != MVT::Flag) // Legalize Flag if it exists. 888ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Tmp2 = Tmp3 = SDOperand(0, 0); 889ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner else 890ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Tmp3 = LegalizeOp(Tmp2); 891ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 892ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Tmp3) { 893ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner std::vector<SDOperand> Ops(Node->op_begin(), Node->op_end()); 894ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Ops[0] = Tmp1; 895ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Ops.back() = Tmp3; 896ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 897ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Result = DAG.getNode(ISD::INLINEASM, VTs, Ops); 898ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner } else { 899ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Result = SDOperand(Node, 0); 900ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner } 901ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 902ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // INLINE asm returns a chain and flag, make sure to add both to the map. 903ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 904ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 905ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner return Result.getValue(Op.ResNo); 906c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 907c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 908c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner if (Tmp1 != Node->getOperand(0)) 909c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); 910c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 911c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner 912c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 913c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 9147cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 91547e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 91647e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 91747e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 91847e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 91947e9223e06390897c3834f8c527001df392570ffChris Lattner break; 92047e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 92147e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 92247e9223e06390897c3834f8c527001df392570ffChris Lattner break; 92347e9223e06390897c3834f8c527001df392570ffChris Lattner } 9247cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 9257cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 9267cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 9277cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 9287cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 9297cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 9307cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 9317cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 9327cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 9337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 9347cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 935550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 936550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 937550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, MVT::i1); 938550b1e59c4eb5db020766012b1406fc56833251dChris Lattner 9397cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 9407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 9417cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 9427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 9437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 944e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 9457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 946898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng case TargetLowering::Custom: { 947898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng SDOperand Tmp = 948898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng TLI.LowerOperation(DAG.getNode(ISD::BRCOND, Node->getValueType(0), 949898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng Tmp1, Tmp2, Node->getOperand(2)), DAG); 950898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng if (Tmp.Val) { 951898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng Result = LegalizeOp(Tmp); 952898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng break; 953898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng } 954898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng // FALLTHROUGH if the target thinks it is legal. 955898101c15fa11a896deb4e2fcb73b4727e1dcc1fEvan Cheng } 9567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 9577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Basic block destination (Op#2) is always legal. 9587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 9597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 9607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 9617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 9637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 9647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 9657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 966181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner if (!isTypeLegal(Node->getOperand(2).getValueType())) { 9677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 9687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 9697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 9707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 9717cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 9727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 9737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 9747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 9757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 9767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Tmp2.getOperand(2), 9777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 9787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 9797cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 9807cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, 9817cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), 9827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2, DAG.getConstant(0, Tmp2.getValueType()), 9837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 9847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 985181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 986181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } 987181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner 988181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 989181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 990181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner 991181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner switch (TLI.getOperationAction(ISD::BR_CC, Tmp3.getValueType())) { 992181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner default: assert(0 && "Unexpected action for BR_CC!"); 993181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner case TargetLowering::Custom: { 994181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp4 = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 995181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp2, Tmp3, Node->getOperand(4)); 996181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp4 = TLI.LowerOperation(Tmp4, DAG); 997181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner if (Tmp4.Val) { 998181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Result = LegalizeOp(Tmp4); 999181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 1000181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } 1001181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } // FALLTHROUGH if the target doesn't want to lower this op after all. 1002181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner case TargetLowering::Legal: 1003181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 1004181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp3 != Node->getOperand(3)) { 1005181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), 1006181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner Tmp2, Tmp3, Node->getOperand(4)); 1007181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner } 1008181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 10097cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 1010c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 1011411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case ISD::BRCONDTWOWAY: 1012411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1013411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 1014411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 1015411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Legal: 1016411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 1017411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 1018411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case Promote: 1019411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the condition. 1020411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 1021411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 1022411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR 1023411e888c1b4155190c8cffe388631ee20693b309Chris Lattner // pair. 1024411e888c1b4155190c8cffe388631ee20693b309Chris Lattner switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { 1025411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Promote: 1026411e888c1b4155190c8cffe388631ee20693b309Chris Lattner default: assert(0 && "This action is not supported yet!"); 1027411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Legal: 1028411e888c1b4155190c8cffe388631ee20693b309Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 1029411e888c1b4155190c8cffe388631ee20693b309Chris Lattner std::vector<SDOperand> Ops; 1030411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp1); 1031411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Tmp2); 1032411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(2)); 1033411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Ops.push_back(Node->getOperand(3)); 1034411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); 1035411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 1036411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 1037411e888c1b4155190c8cffe388631ee20693b309Chris Lattner case TargetLowering::Expand: 10387cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If BRTWOWAY_CC is legal for this target, then simply expand this node 10397cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // to that. Otherwise, skip BRTWOWAY_CC and expand directly to a 10407cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // BRCOND/BR pair. 1041c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::BRTWOWAY_CC, MVT::Other)) { 10427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 10437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 10447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 10457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 10467cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 10477cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 10487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 10497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), Node->getOperand(3)); 10507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 10517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 10527cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 1053411e888c1b4155190c8cffe388631ee20693b309Chris Lattner Node->getOperand(2)); 10547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(3)); 10557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 1056e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 1057411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 1058411e888c1b4155190c8cffe388631ee20693b309Chris Lattner } 1059411e888c1b4155190c8cffe388631ee20693b309Chris Lattner break; 10607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BRTWOWAY_CC: 10617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1062c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(2).getValueType())) { 10637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS 10647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS 10657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 10667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3 != Node->getOperand(3)) { 10677cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Node->getOperand(1), Tmp2, Tmp3, 10687cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 10697cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 10707cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 10717cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 10727cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 10737cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2), // LHS 10747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(3), // RHS 10757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(1))); 10767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If this target does not support BRTWOWAY_CC, lower it to a BRCOND/BR 10777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // pair. 10787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman switch (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other)) { 10797cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 10807cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Legal: 10817cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 10827cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 10837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 10847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 10857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 10867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), 10877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 10887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 10897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 10907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, 10917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 10927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4), Node->getOperand(5)); 10937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 10947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 10957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 10967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, 10977cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(4)); 10987cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::BR, MVT::Other, Result, Node->getOperand(5)); 10997cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 11007cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 1101f9dee6a0473db4f3713bf40c7408fa30578ac141Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 11027cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 11037cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 1104f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::LOAD: { 11053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 11063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 11072d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 1108f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng MVT::ValueType VT = Node->getValueType(0); 1109f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 1110f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng default: assert(0 && "This action is not supported yet!"); 1111f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Custom: { 1112acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Op = DAG.getLoad(VT, Tmp1, Tmp2, Node->getOperand(2)); 1113f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Tmp = TLI.LowerOperation(Op, DAG); 1114f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng if (Tmp.Val) { 1115f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = LegalizeOp(Tmp); 1116acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Since loads produce two values, make sure to remember that we 1117acc398c195a697795bff3245943d104eb19192b9Nate Begeman // legalized both of them. 1118f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 0), Result); 1119f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 1120f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng return Result.getValue(Op.ResNo); 1121f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1122f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // FALLTHROUGH if the target thinks it is legal. 1123f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1124f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Legal: 1125f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng if (Tmp1 != Node->getOperand(0) || 1126f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Tmp2 != Node->getOperand(1)) 1127acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = DAG.getLoad(VT, Tmp1, Tmp2, Node->getOperand(2)); 1128f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng else 1129f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = SDOperand(Node, 0); 1130edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1131f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // Since loads produce two values, make sure to remember that we legalized 1132f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // both of them. 1133f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 0), Result); 1134f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 1135f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng return Result.getValue(Op.ResNo); 1136f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1137f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng assert(0 && "Unreachable"); 1138f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 11390f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::EXTLOAD: 11400f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::SEXTLOAD: 114101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case ISD::ZEXTLOAD: { 11420f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 11430f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 11440f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 11455f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner MVT::ValueType SrcVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 114601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), SrcVT)) { 114701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner default: assert(0 && "This action is not supported yet!"); 11481c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner case TargetLowering::Promote: 11491c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); 11505f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 11515f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), MVT::i8); 11521c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // Since loads produce two values, make sure to remember that we legalized 11531c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner // both of them. 11541c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 11551c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 11561c51c6ac13b5e68b099605021784c7f552dcce3cChris Lattner return Result.getValue(Op.ResNo); 1157edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1158f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Custom: { 1159f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Op = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 1160f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Tmp1, Tmp2, Node->getOperand(2), 1161f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SrcVT); 1162f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Tmp = TLI.LowerOperation(Op, DAG); 1163f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng if (Tmp.Val) { 1164f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = LegalizeOp(Tmp); 1165f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // Since loads produce two values, make sure to remember that we legalized 1166f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // both of them. 1167f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 0), Result); 1168f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 1169f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng return Result.getValue(Op.ResNo); 1170f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1171f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // FALLTHROUGH if the target thinks it is legal. 1172f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 117301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Legal: 117401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Tmp1 != Node->getOperand(0) || 117501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Tmp2 != Node->getOperand(1)) 11765f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), 11775f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 117801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner else 117901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner Result = SDOperand(Node, 0); 118001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner 118101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Since loads produce two values, make sure to remember that we legalized 118201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // both of them. 118301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 118401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 118501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(Op.ResNo); 118601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner case TargetLowering::Expand: 118769a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner // f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 11889d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 11899d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth SDOperand Load = DAG.getLoad(SrcVT, Tmp1, Tmp2, Node->getOperand(2)); 119031559081a4285f4b7282e765aea4ec8a8e1d396cAndrew Lenharth Result = DAG.getNode(ISD::FP_EXTEND, Node->getValueType(0), Load); 1191e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 119269a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner Load = LegalizeOp(Load); 119369a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 119469a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Load.getValue(1)); 11959d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth if (Op.ResNo) 11969d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Load.getValue(1); 11979d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth return Result; 11989d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 119901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(Node->getOpcode() != ISD::EXTLOAD && 120001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner "EXTLOAD should always be supported!"); 120101ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 120201ff7216dd7829d4094754086baf28aa2d7149acChris Lattner // zero/sign extend inreg. 12035f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 12045f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Tmp1, Tmp2, Node->getOperand(2), SrcVT); 120523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner SDOperand ValRes; 120623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SEXTLOAD) 120723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 120815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, DAG.getValueType(SrcVT)); 120923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner else 121023993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner ValRes = DAG.getZeroExtendInReg(Result, SrcVT); 1211e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 1212e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner ValRes = LegalizeOp(ValRes); // Relegalize new nodes. 121369a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 0), ValRes); 121469a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 121501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner if (Op.ResNo) 121601ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return Result.getValue(1); 121701ff7216dd7829d4094754086baf28aa2d7149acChris Lattner return ValRes; 121801ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 121901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner assert(0 && "Unreachable"); 122001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 12215dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case ISD::EXTRACT_ELEMENT: { 12225dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman MVT::ValueType OpTy = Node->getOperand(0).getValueType(); 12235dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman switch (getTypeAction(OpTy)) { 12245dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman default: 12255dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman assert(0 && "EXTRACT_ELEMENT action for type unimplemented!"); 12265dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 12275dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Legal: 12285dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) { 12295dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 1 -> Hi 12305dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::SRL, OpTy, Node->getOperand(0), 12315dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman DAG.getConstant(MVT::getSizeInBits(OpTy)/2, 12325dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman TLI.getShiftAmountTy())); 12335dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Result); 12345dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } else { 12355dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // 0 -> Lo 12365dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), 12375dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Node->getOperand(0)); 12385dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 12395dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = LegalizeOp(Result); 12405dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 12415dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case Expand: 12425dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman // Get both the low and high parts. 12435dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 12445dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) 12455dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp2; // 1 -> Hi 12465dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman else 12475dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman Result = Tmp1; // 0 -> Lo 12485dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman break; 12495dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 12503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12515dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 12523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 12543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1255edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1256c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(Node->getOperand(2).getValueType()) && 1257d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner "Register type must be legal!"); 12587310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // Legalize the incoming value (must be a legal type). 1259d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 1260f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner if (Node->getNumValues() == 1) { 12617310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) 12627310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = DAG.getNode(ISD::CopyToReg, MVT::Other, Tmp1, 12637310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Node->getOperand(1), Tmp2); 12647310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } else { 1265f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner assert(Node->getNumValues() == 2 && "Unknown CopyToReg"); 1266f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner if (Node->getNumOperands() == 4) 1267f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(3)); 12687310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || 1269f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner (Node->getNumOperands() == 4 && Tmp3 != Node->getOperand(3))) { 12707310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner unsigned Reg = cast<RegisterSDNode>(Node->getOperand(1))->getReg(); 12717310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = DAG.getCopyToReg(Tmp1, Reg, Tmp2, Tmp3); 12727310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 12737310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner 12747310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // Since this produces two values, make sure to remember that we legalized 12757310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // both of them. 12767310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 12777310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 12787310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner return Result.getValue(Op.ResNo); 12797310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 12803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 12823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 12833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 12843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 12853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 2: // ret val 12863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 12873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 12883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 12898afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 12903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 12913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 12933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 12943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 12953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Lo, Hi); 1296edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 12973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 12983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 12998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 13008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); 13018b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 13023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 13053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 13063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); 13073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 13093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::vector<SDOperand> NewValues; 13103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 13113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) 13123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(i).getValueType())) { 13133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 13144e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NewValues.push_back(LegalizeOp(Node->getOperand(i))); 13153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: { 13173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 13183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(i), Lo, Hi); 13193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Lo); 13203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Hi); 1321edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 13223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 13248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Can't promote multiple return value yet!"); 13253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); 13273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 133017c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng 133147f5beaaaf41ffa2db51da6f99314474be6aca7dChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 133247f5beaaaf41ffa2db51da6f99314474be6aca7dChris Lattner Node->getValueType(0))) { 133317c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng default: assert(0 && "This action is not supported yet!"); 133417c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng case TargetLowering::Custom: { 133517c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng SDOperand Tmp = TLI.LowerOperation(Result, DAG); 133617c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng if (Tmp.Val) { 133717c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng Result = LegalizeOp(Tmp); 133817c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng break; 133917c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng } 134017c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng // FALLTHROUGH if the target thinks it is legal. 134117c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng } 134217c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng case TargetLowering::Legal: 134317c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng // Nothing to do. 134417c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng break; 134517c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng } 13463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1347f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::STORE: { 13483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 13493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 13503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 13515d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 135203c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ 13535d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner if (CFP->getValueType(0) == MVT::f32) { 135400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1355cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(FloatToBits(CFP->getValue()), 1356cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i32), 1357cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 135852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 13595d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } else { 13605d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); 136100b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, 1362cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey DAG.getConstant(DoubleToBits(CFP->getValue()), 1363cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey MVT::i64), 1364cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Tmp2, 136552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 13665d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 13676a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner Result = LegalizeOp(Result); 13686a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner break; 13695d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner } 13705d2c6c784bdc3d572a553ed7aa48dcf27a45b1a3Chris Lattner 13713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 13723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: { 13733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Val = LegalizeOp(Node->getOperand(1)); 13743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Val != Node->getOperand(1) || Tmp1 != Node->getOperand(0) || 13753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 != Node->getOperand(2)) 137652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, 137752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(3)); 1378f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng 1379f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng MVT::ValueType VT = Result.Val->getOperand(1).getValueType(); 1380f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng switch (TLI.getOperationAction(Result.Val->getOpcode(), VT)) { 1381f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng default: assert(0 && "This action is not supported yet!"); 1382f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Custom: { 1383f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Tmp = TLI.LowerOperation(Result, DAG); 1384f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng if (Tmp.Val) { 1385f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = LegalizeOp(Tmp); 1386f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng break; 1387f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1388f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // FALLTHROUGH if the target thinks it is legal. 1389f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1390f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Legal: 1391f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // Nothing to do. 1392f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng break; 1393f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 13943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 13953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 139703c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Truncate the value and store the result. 139803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(1)); 139903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp3, Tmp2, 14002d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Node->getOperand(3), 14019fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getValueType(Node->getOperand(1).getValueType())); 140203c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 140303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 14043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Expand: 14053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Lo, Hi; 1406ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize; 14073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), Lo, Hi); 14083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 14093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 14103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 14113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1412edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Lo = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Lo, Tmp2, 1413edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1414ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If this is a vector type, then we have to calculate the increment as 1415ab48be377298bd509427a29e174cf4e305138819Nate Begeman // the product of the element size in bytes, and the number of elements 1416ab48be377298bd509427a29e174cf4e305138819Nate Begeman // in the high half of the vector. 1417ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (MVT::Vector == Hi.getValueType()) { 1418ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElems = cast<ConstantSDNode>(Hi.getOperand(2))->getValue(); 1419ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Hi.getOperand(3))->getVT(); 1420ab48be377298bd509427a29e174cf4e305138819Nate Begeman IncrementSize = NumElems * MVT::getSizeInBits(EVT)/8; 1421ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 1422ab48be377298bd509427a29e174cf4e305138819Nate Begeman IncrementSize = MVT::getSizeInBits(Hi.getValueType())/8; 1423ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 14243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::ADD, Tmp2.getValueType(), Tmp2, 14253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 14263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(isTypeLegal(Tmp2.getValueType()) && 14273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Pointers must be legal!"); 14282d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //Again, claiming both parts of the store came form the same Instr 1429edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Hi, Tmp2, 1430edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Node->getOperand(3)); 1431ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1432ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner break; 14333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 14343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1435f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 143695762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 143795762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 14382c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 14392c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); 144095762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 1441140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case ISD::STACKSAVE: 1442140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1443140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner if (Tmp1 != Node->getOperand(0)) { 1444140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner std::vector<MVT::ValueType> VTs; 1445140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner VTs.push_back(Node->getValueType(0)); 1446140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner VTs.push_back(MVT::Other); 1447140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner std::vector<SDOperand> Ops; 1448140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Ops.push_back(Tmp1); 1449140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Result = DAG.getNode(ISD::STACKSAVE, VTs, Ops); 1450140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 1451140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner 1452140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner switch (TLI.getOperationAction(ISD::STACKSAVE, MVT::Other)) { 1453140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner default: assert(0 && "This action is not supported yet!"); 1454140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case TargetLowering::Custom: { 1455140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner SDOperand Tmp = TLI.LowerOperation(Result, DAG); 1456140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner if (Tmp.Val) { 1457140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Result = LegalizeOp(Tmp); 1458140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner break; 1459140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 1460140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner // FALLTHROUGH if the target thinks it is legal. 1461140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 1462140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case TargetLowering::Legal: 1463140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner // Since stacksave produce two values, make sure to remember that we 1464140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner // legalized both of them. 1465140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 1466140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 1467140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return Result.getValue(Op.ResNo); 1468140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case TargetLowering::Expand: 14694f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner // Expand to CopyFromReg if the target set 14704f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner // StackPointerRegisterToSaveRestore. 14714f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner if (unsigned SP = TLI.getStackPointerRegisterToSaveRestore()) { 14728ff318b7fb6185e94403c0a902f1132141847ac5Andrew Lenharth Tmp1 = DAG.getCopyFromReg(Tmp1, SP, 14734f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner Node->getValueType(0)); 14744f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Tmp1); 14754f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Tmp1.getValue(1)); 14764f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner return Tmp1.getValue(Op.ResNo); 14774f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner } else { 14784f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner Tmp1 = DAG.getNode(ISD::UNDEF, Node->getValueType(0)); 14794f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Tmp1); 14804f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Node->getOperand(0)); 14814f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner return Op.ResNo ? Node->getOperand(0) : Tmp1; 14824f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner } 1483140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 1484140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner 1485140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case ISD::STACKRESTORE: 1486140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1487140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 1488140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1489140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Result = DAG.getNode(ISD::STACKRESTORE, MVT::Other, Tmp1, Tmp2); 1490140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner 1491140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner switch (TLI.getOperationAction(ISD::STACKRESTORE, MVT::Other)) { 1492140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner default: assert(0 && "This action is not supported yet!"); 1493140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case TargetLowering::Custom: { 1494140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner SDOperand Tmp = TLI.LowerOperation(Result, DAG); 1495140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner if (Tmp.Val) { 1496140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Result = LegalizeOp(Tmp); 1497140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner break; 1498140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 1499140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner // FALLTHROUGH if the target thinks it is legal. 1500140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 1501140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case TargetLowering::Legal: 1502140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner break; 1503140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case TargetLowering::Expand: 15044f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner // Expand to CopyToReg if the target set 15054f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner // StackPointerRegisterToSaveRestore. 15064f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner if (unsigned SP = TLI.getStackPointerRegisterToSaveRestore()) { 15074f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner Result = DAG.getCopyToReg(Tmp1, SP, Tmp2); 15084f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner } else { 15094f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner Result = Tmp1; 15104f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner } 1511140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner break; 1512140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 1513140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner break; 1514140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner 151551b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth case ISD::READCYCLECOUNTER: 151651b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain 1517cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth if (Tmp1 != Node->getOperand(0)) { 1518cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth std::vector<MVT::ValueType> rtypes; 1519cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth std::vector<SDOperand> rvals; 1520cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rtypes.push_back(MVT::i64); 1521cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rtypes.push_back(MVT::Other); 1522cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth rvals.push_back(Tmp1); 1523cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth Result = DAG.getNode(ISD::READCYCLECOUNTER, rtypes, rvals); 1524cde0f5cfe7b7e0a73708c0db29dcfc0d00294e98Andrew Lenharth } 152549c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth 152649c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // Since rdcc produce two values, make sure to remember that we legalized 152749c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // both of them. 152849c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth AddLegalizedOperand(SDOperand(Node, 0), Result); 152949c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 153049c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth return Result.getValue(Op.ResNo); 1531f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 1532f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::TRUNCSTORE: { 15330f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 15340f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the pointer. 15350f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 15360f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner switch (getTypeAction(Node->getOperand(1).getValueType())) { 1537c26f7a033f5416f216ef08929cbc8cb8df509ef3Chris Lattner case Promote: 1538c26f7a033f5416f216ef08929cbc8cb8df509ef3Chris Lattner case Expand: 1539c26f7a033f5416f216ef08929cbc8cb8df509ef3Chris Lattner assert(0 && "Cannot handle illegal TRUNCSTORE yet!"); 15400f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case Legal: 15410f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 154213d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 154313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // The only promote case we handle is TRUNCSTORE:i1 X into 154413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // -> TRUNCSTORE:i8 (and X, 1) 154513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner if (cast<VTSDNode>(Node->getOperand(4))->getVT() == MVT::i1 && 154613d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TLI.getOperationAction(ISD::TRUNCSTORE, MVT::i1) == 154713d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner TargetLowering::Promote) { 154813d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner // Promote the bool to a mask then store. 154913d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp2 = DAG.getNode(ISD::AND, Tmp2.getValueType(), Tmp2, 155013d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner DAG.getConstant(1, Tmp2.getValueType())); 155113d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 155213d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Node->getOperand(3), DAG.getValueType(MVT::i8)); 155313d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner 155413d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } else if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 155513d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner Tmp3 != Node->getOperand(2)) { 155645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, 15579fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner Node->getOperand(3), Node->getOperand(4)); 155813d58e71b7ab2857162b88860c56dce4c9cea3deChris Lattner } 1559f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng 1560f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng MVT::ValueType StVT = cast<VTSDNode>(Result.Val->getOperand(4))->getVT(); 1561f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng switch (TLI.getOperationAction(Result.Val->getOpcode(), StVT)) { 1562f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng default: assert(0 && "This action is not supported yet!"); 1563f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Custom: { 1564f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng SDOperand Tmp = TLI.LowerOperation(Result, DAG); 1565f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng if (Tmp.Val) { 1566f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng Result = LegalizeOp(Tmp); 1567f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng break; 1568f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1569f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // FALLTHROUGH if the target thinks it is legal. 1570f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1571f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case TargetLowering::Legal: 1572f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng // Nothing to do. 1573f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng break; 1574f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 15750f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 15760f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner } 15770f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 1578f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 15792ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 158047e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 158147e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 158247e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 158347e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 158447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 158547e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 158647e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 158747e9223e06390897c3834f8c527001df392570ffChris Lattner break; 158847e9223e06390897c3834f8c527001df392570ffChris Lattner } 15893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 15902ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 159155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 1592b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { 159355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 15949373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 15959373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 15969373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1.getOperand(0), Tmp1.getOperand(1), 15979373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 15989373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 15999373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 1600550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // Make sure the condition is either zero or one. It may have been 1601550b1e59c4eb5db020766012b1406fc56833251dChris Lattner // promoted from something else. 1602550b1e59c4eb5db020766012b1406fc56833251dChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, MVT::i1); 16039373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getSelectCC(Tmp1, 16049373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 16059373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 16069373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 1607e773673d8e0094bbff2f9ab2f2da9ecb5c4d0909Chris Lattner Result = LegalizeOp(Result); // Relegalize new nodes. 16089373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 16097df96d66729d1f33934de7b52553e5f071686041Evan Cheng case TargetLowering::Custom: { 16107df96d66729d1f33934de7b52553e5f071686041Evan Cheng SDOperand Tmp = 16117df96d66729d1f33934de7b52553e5f071686041Evan Cheng TLI.LowerOperation(DAG.getNode(ISD::SELECT, Node->getValueType(0), 16127df96d66729d1f33934de7b52553e5f071686041Evan Cheng Tmp1, Tmp2, Tmp3), DAG); 16137df96d66729d1f33934de7b52553e5f071686041Evan Cheng if (Tmp.Val) { 16147df96d66729d1f33934de7b52553e5f071686041Evan Cheng Result = LegalizeOp(Tmp); 16157df96d66729d1f33934de7b52553e5f071686041Evan Cheng break; 16167df96d66729d1f33934de7b52553e5f071686041Evan Cheng } 16177df96d66729d1f33934de7b52553e5f071686041Evan Cheng // FALLTHROUGH if the target thinks it is legal. 16187df96d66729d1f33934de7b52553e5f071686041Evan Cheng } 161955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 162055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 162155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 != Node->getOperand(2)) 162255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), 162355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp1, Tmp2, Tmp3); 162455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 162555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 162655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner MVT::ValueType NVT = 162755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 162855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 162955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (MVT::isInteger(Tmp2.getValueType())) { 163013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner ExtOp = ISD::ANY_EXTEND; 163155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::TRUNCATE; 163255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 163355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner ExtOp = ISD::FP_EXTEND; 163455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TruncOp = ISD::FP_ROUND; 163555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 163655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 163755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp2 = DAG.getNode(ExtOp, NVT, Tmp2); 163855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Tmp3 = DAG.getNode(ExtOp, NVT, Tmp3); 163955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 164055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2,Tmp3); 164155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(TruncOp, Node->getValueType(0), Result); 1642433f8acefb78f1c8a2cf79c12b101ce7c4b20202Evan Cheng Result = LegalizeOp(Result); 164355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 164455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 164555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 16463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 16479373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 16489373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 16499373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 16509373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 1651c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (isTypeLegal(Node->getOperand(0).getValueType())) { 165223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner // Everything is legal, see if we should expand this op or something. 165323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner switch (TLI.getOperationAction(ISD::SELECT_CC, 165423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0).getValueType())) { 165523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner default: assert(0 && "This action is not supported yet!"); 165623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Custom: { 165723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner SDOperand Tmp = 165823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner TLI.LowerOperation(DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), 165923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(0), 166023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Node->getOperand(1), Tmp3, Tmp4, 1661d7050a9c50211dd215cb3c2bc28b4fb6bfa4a116Chris Lattner Node->getOperand(4)), DAG); 166223004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp.Val) { 166323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Result = LegalizeOp(Tmp); 166423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 166523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 166623004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } // FALLTHROUGH if the target can't lower this operation after all. 166723004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner case TargetLowering::Legal: 166823004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 166923004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 167023004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 167123004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3)) { 16721ccf26a6392034a11827aeaa0d58d025ecb2b85aChris Lattner Result = DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), Tmp1,Tmp2, 167323004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner Tmp3, Tmp4, Node->getOperand(4)); 167423004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner } 167523004e5f21716671401e95e3be91d87dc7d4d68bChris Lattner break; 16769373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 16779373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 16789373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 16799373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp1 = LegalizeOp(DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), 16809373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(0), // LHS 16819373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), // RHS 16829373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4))); 16837cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // If we get a SETCC back from legalizing the SETCC node we just 16847cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // created, then use its LHS, RHS, and CC directly in creating a new 16857cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // node. Otherwise, select between the true and false value based on 16867cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // comparing the result of the legalized with zero. 16877cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 16887cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, Tmp3.getValueType(), 16897cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1.getOperand(0), Tmp1.getOperand(1), 16907cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, Tmp1.getOperand(2)); 16917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 16927cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Result = DAG.getSelectCC(Tmp1, 16937cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 16947cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp3, Tmp4, ISD::SETNE); 16957cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 16969373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 16979373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 16983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 16993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 17003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 17013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 17023e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 17033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 17043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Promote: 17058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // LHS 17068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // RHS 17078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 17088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // If this is an FP compare, the operands have already been extended. 17098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(Node->getOperand(0).getValueType())) { 17108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner MVT::ValueType VT = Node->getOperand(0).getValueType(); 171171c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 17128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 17138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Otherwise, we have to insert explicit sign or zero extends. Note 17148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // that we could insert sign extends for ALL conditions, but zero extend 17158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // is cheaper on many machines (an AND instead of two shifts), so prefer 17168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // it. 17177cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 17188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner default: assert(0 && "Unknown integer comparison!"); 17198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETEQ: 17208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETNE: 17218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGE: 17228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETUGT: 17238b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULE: 17248b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETULT: 17258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // ALL of these operations will work if we either sign or zero extend 17268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // the operands (including the unsigned comparisons!). Zero extend is 17278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // usually a simpler/cheaper operation, so prefer it. 172823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 172923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 17308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 17318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGE: 17328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETGT: 17338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLT: 17348b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SETLE: 173515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 173615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 173715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 173815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 17398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 17408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 17418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 17423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1743edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case Expand: 17443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 17453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LHSLo, LHSHi); 17463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RHSLo, RHSHi); 17477cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 17483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETEQ: 17493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETNE: 175008b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSLo == RHSHi) 175108b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 175208b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner if (RHSCST->isAllOnesValue()) { 175308b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner // Comparison to -1. 175408b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner Tmp1 = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 1755b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSLo; 1756edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman break; 175708b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner } 175808b698e38db5ab5db44c0472e2a7f4f780887629Chris Lattner 17593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 17603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 17613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp2); 1762b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 17633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 17643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 17655b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 17665b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner // X > -1, x < 0 17675b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Node->getOperand(1))) 17687cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner if ((cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETLT && 17695b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner CST->getValue() == 0) || // X < 0 17707cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner (cast<CondCodeSDNode>(Node->getOperand(2))->get() == ISD::SETGT && 1771b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman (CST->isAllOnesValue()))) { // X > -1 1772b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp1 = LHSHi; 1773b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Tmp2 = RHSHi; 1774b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1775b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 17765b95ed652fcfe578aa8af4e21318fca989164e21Chris Lattner 17773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // FIXME: This generated code sucks. 17783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ISD::CondCode LowCC; 17797cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner switch (cast<CondCodeSDNode>(Node->getOperand(2))->get()) { 17803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: assert(0 && "Unknown integer setcc!"); 17813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLT: 17823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 17833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGT: 17843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 17853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETLE: 17863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 17873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETGE: 17883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 17893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1790edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 17913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 17923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 17933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 17943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 17953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 17963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 17977cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp1 = DAG.getSetCC(Node->getValueType(0), LHSLo, RHSLo, LowCC); 17987cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getNode(ISD::SETCC, Node->getValueType(0), LHSHi, RHSHi, 17997cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(2)); 18007cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getSetCC(Node->getValueType(0), LHSHi, RHSHi, ISD::SETEQ); 1801b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1802b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result, Tmp1, Tmp2)); 180369a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 1804b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman return Result; 18053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 18063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1807b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman 18081ccf26a6392034a11827aeaa0d58d025ecb2b85aChris Lattner switch(TLI.getOperationAction(ISD::SETCC, 18091ccf26a6392034a11827aeaa0d58d025ecb2b85aChris Lattner Node->getOperand(0).getValueType())) { 1810b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman default: 1811b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman assert(0 && "Cannot handle this action for SETCC yet!"); 1812b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1813ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth case TargetLowering::Promote: { 1814ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // First step, figure out the appropriate operation to use. 1815ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Allow SETCC to not be supported for all legal data types 1816ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Mostly this targets FP 1817ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth MVT::ValueType NewInTy = Node->getOperand(0).getValueType(); 1818ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth MVT::ValueType OldVT = NewInTy; 1819ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1820ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Scan for the appropriate larger type to use. 1821ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth while (1) { 1822ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth NewInTy = (MVT::ValueType)(NewInTy+1); 1823ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1824ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(MVT::isInteger(NewInTy) == MVT::isInteger(OldVT) && 1825ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the integer world"); 1826ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(MVT::isFloatingPoint(NewInTy) == MVT::isFloatingPoint(OldVT) && 1827ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the floating point world"); 1828ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1829ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // If the target supports SETCC of this type, use it. 18301ccf26a6392034a11827aeaa0d58d025ecb2b85aChris Lattner if (TLI.isOperationLegal(ISD::SETCC, NewInTy)) 1831ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth break; 1832ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1833ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth if (MVT::isInteger(NewInTy)) 1834ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(0 && "Cannot promote Legal Integer SETCC yet"); 1835ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth else { 1836ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth Tmp1 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp1); 1837ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth Tmp2 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp2); 1838ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1839ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 18405e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 18415e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth Node->getOperand(2)); 1842433f8acefb78f1c8a2cf79c12b101ce7c4b20202Evan Cheng Result = LegalizeOp(Result); 18435e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth break; 1844ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1845d5781fca4f8f98863560338d4f8d017389428119Evan Cheng case TargetLowering::Custom: { 1846d5781fca4f8f98863560338d4f8d017389428119Evan Cheng SDOperand Tmp = 1847d5781fca4f8f98863560338d4f8d017389428119Evan Cheng TLI.LowerOperation(DAG.getNode(ISD::SETCC, Node->getValueType(0), 1848d5781fca4f8f98863560338d4f8d017389428119Evan Cheng Tmp1, Tmp2, Node->getOperand(2)), DAG); 1849d5781fca4f8f98863560338d4f8d017389428119Evan Cheng if (Tmp.Val) { 1850d5781fca4f8f98863560338d4f8d017389428119Evan Cheng Result = LegalizeOp(Tmp); 1851d5781fca4f8f98863560338d4f8d017389428119Evan Cheng break; 1852d5781fca4f8f98863560338d4f8d017389428119Evan Cheng } 1853d5781fca4f8f98863560338d4f8d017389428119Evan Cheng // FALLTHROUGH if the target thinks it is legal. 1854d5781fca4f8f98863560338d4f8d017389428119Evan Cheng } 1855b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Legal: 1856b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 1857b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, 1858b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1859b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1860b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Expand: 1861b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // Expand a setcc node into a select_cc of the same condition, lhs, and 1862b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // rhs that selects between const 1 (true) and const 0 (false). 1863b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman MVT::ValueType VT = Node->getValueType(0); 1864b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = DAG.getNode(ISD::SELECT_CC, VT, Tmp1, Tmp2, 1865b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman DAG.getConstant(1, VT), DAG.getConstant(0, VT), 1866b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Node->getOperand(2)); 1867b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman Result = LegalizeOp(Result); 1868b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1869b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 18703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 18713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1872e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMSET: 1873e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMCPY: 1874e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner case ISD::MEMMOVE: { 1875deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Chain 1876e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Pointer 1877e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner 1878e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { // memset = ubyte 1879e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner switch (getTypeAction(Node->getOperand(2).getValueType())) { 1880e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Expand: assert(0 && "Cannot expand a byte!"); 1881e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1882deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 1883e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1884e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1885deb692e756cd3826e4ecc6eaec3397177c8b89ceChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); 1886e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1887e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1888e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } else { 1889edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Tmp3 = LegalizeOp(Node->getOperand(2)); // memcpy/move = pointer, 1890e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 1891272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1892272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp4; 1893272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(3).getValueType())) { 18946814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner case Expand: { 18956814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner // Length is too big, just take the lo-part of the length. 18966814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner SDOperand HiPart; 18976814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner ExpandOp(Node->getOperand(3), HiPart, Tmp4); 18986814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner break; 18996814f1522dd7cdeb4674a9ad199f482a2e7aaea1Chris Lattner } 1900e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Legal: 1901e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = LegalizeOp(Node->getOperand(3)); 1902e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1903e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner case Promote: 1904e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp4 = PromoteOp(Node->getOperand(3)); 1905272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1906272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner } 1907272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner 1908272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner SDOperand Tmp5; 1909272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner switch (getTypeAction(Node->getOperand(4).getValueType())) { // uint 1910272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Expand: assert(0 && "Cannot expand this yet!"); 1911272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Legal: 1912272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner Tmp5 = LegalizeOp(Node->getOperand(4)); 1913272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner break; 1914272455b404eabe70ce9e033ba19ec1b6cfe603a5Chris Lattner case Promote: 1915e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner Tmp5 = PromoteOp(Node->getOperand(4)); 1916e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner break; 1917e560521f1af300a10717ca5c73d42df9ffb1b121Chris Lattner } 191855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 191955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 192055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 192107dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 192207dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 192307dffd6af673c73352150583150b242a93694f00Chris Lattner TLI.LowerOperation(DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, 192407dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp2, Tmp3, Tmp4, Tmp5), DAG); 192507dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 192607dffd6af673c73352150583150b242a93694f00Chris Lattner Result = LegalizeOp(Tmp); 192707dffd6af673c73352150583150b242a93694f00Chris Lattner break; 192807dffd6af673c73352150583150b242a93694f00Chris Lattner } 192907dffd6af673c73352150583150b242a93694f00Chris Lattner // FALLTHROUGH if the target thinks it is legal. 193007dffd6af673c73352150583150b242a93694f00Chris Lattner } 193155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 1932e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 1933e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || 1934e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp5 != Node->getOperand(4)) { 1935e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<SDOperand> Ops; 1936e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); 1937e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Ops.push_back(Tmp4); Ops.push_back(Tmp5); 1938e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); 1939e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 194055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 194155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: { 1942e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Otherwise, the target does not support this operation. Lower the 1943e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // operation to an explicit libcall as appropriate. 1944e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 1945e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner const Type *IntPtrTy = TLI.getTargetData().getIntPtrType(); 1946e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1947e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 19483bfbf4ea990930d153e58e153f319408341a94feReid Spencer const char *FnName = 0; 1949e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (Node->getOpcode() == ISD::MEMSET) { 1950e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1951e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner // Extend the ubyte argument to be an int value for the call. 1952e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Tmp3); 1953e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, Type::IntTy)); 1954e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1955e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner 1956e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = "memset"; 1957e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else if (Node->getOpcode() == ISD::MEMCPY || 1958e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Node->getOpcode() == ISD::MEMMOVE) { 1959e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp2, IntPtrTy)); 1960e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp3, IntPtrTy)); 1961e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner Args.push_back(std::make_pair(Tmp4, IntPtrTy)); 1962e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner FnName = Node->getOpcode() == ISD::MEMMOVE ? "memmove" : "memcpy"; 1963e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } else { 1964e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner assert(0 && "Unknown op!"); 1965e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 196645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 1967e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 1968adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(Tmp1, Type::VoidTy, false, CallingConv::C, false, 1969e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner DAG.getExternalSymbol(FnName, IntPtr), Args, DAG); 197069a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner Result = LegalizeOp(CallResult.second); 197155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 197255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 1973e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 1974e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner break; 1975e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner } 197652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 197752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::READPORT: 197852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 197952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 19806d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 19813e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 19823e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 19833e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 19843e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 19853e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 19863e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 19873e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 198852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = SDOperand(Node, 0); 198952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // Since these produce two values, make sure to remember that we legalized 199052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner // both of them. 199152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 199252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 199352d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner return Result.getValue(Op.ResNo); 199452d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner case ISD::WRITEPORT: 199552d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 199652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 199752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 199852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 199952d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Tmp3 != Node->getOperand(2)) 200052d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 200152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner break; 200252d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 20036d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::READIO: 20046d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 20056d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 20066d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 20076d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 20086d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 20096d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 20106d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 20113e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { 20123e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 20133e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner std::vector<SDOperand> Ops; 20143e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp1); 20153e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Ops.push_back(Tmp2); 20163e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner Result = DAG.getNode(ISD::READPORT, VTs, Ops); 20173e01136f9fc2e1db9207d278002e76e6175783e9Chris Lattner } else 20186d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = SDOperand(Node, 0); 20196d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 20206d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 20216d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a load from memory. 20226d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0), 20236d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), DAG.getSrcValue(NULL)); 20246d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 20256d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 20266d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 20276d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 20286d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Since these produce two values, make sure to remember that we legalized 20296d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // both of them. 20306d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 20316d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 20326d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner return Result.getValue(Op.ResNo); 20336d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 20346d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case ISD::WRITEIO: 20356d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 20366d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 20376d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 20386d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 20396d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), 20406d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1).getValueType())) { 20416d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Custom: 20426d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner default: assert(0 && "This action not implemented for this operation!"); 20436d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Legal: 20446d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || 20456d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Tmp3 != Node->getOperand(2)) 20466d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); 20476d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 20486d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner case TargetLowering::Expand: 20496d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner // Replace this with a store to memory. 20506d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0), 20516d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Node->getOperand(1), Node->getOperand(2), 20526d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner DAG.getSrcValue(NULL)); 20536d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner Result = LegalizeOp(Result); 20546d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 20556d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner } 20566d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner break; 20576d5b8e16462859333db9ad984f05ec2ed1f48f4aChris Lattner 205884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::ADD_PARTS: 20595b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SUB_PARTS: 20605b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 20615b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 20625b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 206384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 206484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 206584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 206684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 206784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 206884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 2069e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner if (Changed) { 2070e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); 2071e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Result = DAG.getNode(Node->getOpcode(), VTs, Ops); 2072e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner } 20732c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 207405a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), 207505a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Node->getValueType(0))) { 207605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng default: assert(0 && "This action is not supported yet!"); 207705a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng case TargetLowering::Custom: { 207805a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng SDOperand Tmp = TLI.LowerOperation(Result, DAG); 207905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng if (Tmp.Val) { 2080269f8c069105e13f3845a8dbc7796ac9a15dc882Chris Lattner SDOperand Tmp2, RetVal(0,0); 208105a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) { 208205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Tmp2 = LegalizeOp(Tmp.getValue(i)); 208305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng AddLegalizedOperand(SDOperand(Node, i), Tmp2); 208405a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng if (i == Op.ResNo) 208512f2274ba8c6af21e8b6c71ef872afe43a64b6d7Evan Cheng RetVal = Tmp2; 208605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 2087269f8c069105e13f3845a8dbc7796ac9a15dc882Chris Lattner assert(RetVal.Val && "Illegal result number"); 208805a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng return RetVal; 208905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 209005a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng // FALLTHROUGH if the target thinks it is legal. 209105a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 209205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng case TargetLowering::Legal: 209305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng // Nothing to do. 209405a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng break; 209505a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 209605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng 20972c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 20982c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 20992c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 21002c8086f4b9916b2d02842be5e375276023225fbaChris Lattner AddLegalizedOperand(SDOperand(Node, i), Result.getValue(i)); 21012c8086f4b9916b2d02842be5e375276023225fbaChris Lattner return Result.getValue(Op.ResNo); 210284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 21032c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 21042c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 21053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 21063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 21073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 2108c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 2109c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 21103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 21113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 21123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 21133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 21143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 211503c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 211603c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 211703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 211801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 211901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 212001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 212101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 21223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 2123f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth switch (getTypeAction(Node->getOperand(1).getValueType())) { 2124f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Expand: assert(0 && "Not possible"); 2125f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Legal: 2126f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 2127f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 2128f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth case Promote: 2129f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the RHS. 2130f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth break; 2131f2eb1396b8fe7b5b1c4bd5f27903209cfa4d20aeAndrew Lenharth } 2132e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2133e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth case TargetLowering::Custom: { 2134e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, Tmp2); 2135e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth SDOperand Tmp = TLI.LowerOperation(Result, DAG); 2136e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth if (Tmp.Val) { 2137e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth Tmp = LegalizeOp(Tmp); // Relegalize input. 2138e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth AddLegalizedOperand(Op, Tmp); 2139e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth return Tmp; 214057030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth } //else it was considered legal and we fall through 2141e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth } 214257030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth case TargetLowering::Legal: 214357030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth if (Tmp1 != Node->getOperand(0) || 214457030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth Tmp2 != Node->getOperand(1)) 214557030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 214657030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth break; 2147e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth default: 2148e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth assert(0 && "Operation not supported"); 2149e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth } 21503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2151edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2152419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case ISD::BUILD_PAIR: { 2153419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman MVT::ValueType PairTy = Node->getValueType(0); 2154419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman // TODO: handle the case where the Lo and Hi operands are not of legal type 2155419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Lo 2156419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Hi 2157419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman switch (TLI.getOperationAction(ISD::BUILD_PAIR, PairTy)) { 2158419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Legal: 2159419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 2160419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = DAG.getNode(ISD::BUILD_PAIR, PairTy, Tmp1, Tmp2); 2161419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2162419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Promote: 2163419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Custom: 2164419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman assert(0 && "Cannot promote/custom this yet!"); 2165419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Expand: 2166419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, PairTy, Tmp1); 2167419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::ANY_EXTEND, PairTy, Tmp2); 2168419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = DAG.getNode(ISD::SHL, PairTy, Tmp2, 2169419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman DAG.getConstant(MVT::getSizeInBits(PairTy)/2, 2170419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman TLI.getShiftAmountTy())); 2171419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::OR, PairTy, Tmp1, Tmp2)); 2172419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2173419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 2174419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2175419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 2176419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman 2177c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 2178c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 217901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 2180c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 2181c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 2182c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2183e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth case TargetLowering::Custom: { 2184c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); 2185e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth SDOperand Tmp = TLI.LowerOperation(Result, DAG); 2186e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth if (Tmp.Val) { 2187c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp = LegalizeOp(Tmp); // Relegalize input. 2188c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman AddLegalizedOperand(Op, Tmp); 2189c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman return Tmp; 219057030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth } //else it was considered legal and we fall through 2191e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth } 219257030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth case TargetLowering::Legal: 219357030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth if (Tmp1 != Node->getOperand(0) || 219457030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth Tmp2 != Node->getOperand(1)) 219557030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 219657030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth Tmp2); 219757030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth break; 219857030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth case TargetLowering::Promote: 219957030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth assert(0 && "Cannot promote handle this yet!"); 22004c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner case TargetLowering::Expand: 22014c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner if (MVT::isInteger(Node->getValueType(0))) { 22024c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner MVT::ValueType VT = Node->getValueType(0); 22034c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner unsigned Opc = (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 22044c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(Opc, VT, Tmp1, Tmp2); 22054c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::MUL, VT, Result, Tmp2); 22064c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner Result = DAG.getNode(ISD::SUB, VT, Tmp1, Result); 22074c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner } else { 22084c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner // Floating point mod -> fmod libcall. 22094c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner const char *FnName = Node->getValueType(0) == MVT::f32 ? "fmodf":"fmod"; 22104c64dd7977bc676399df0d5d2bf8016a3242780eChris Lattner SDOperand Dummy; 22119c6b4b8c3a48aa420f6499ca6c1a356f74e100f8Chris Lattner Result = ExpandLibCall(FnName, Node, Dummy); 2212c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 2213c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 2214c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 2215c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 22162c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 2217acc398c195a697795bff3245943d104eb19192b9Nate Begeman case ISD::VAARG: { 2218acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 2219acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2220acc398c195a697795bff3245943d104eb19192b9Nate Begeman 2221acc398c195a697795bff3245943d104eb19192b9Nate Begeman MVT::ValueType VT = Node->getValueType(0); 2222acc398c195a697795bff3245943d104eb19192b9Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 2223acc398c195a697795bff3245943d104eb19192b9Nate Begeman default: assert(0 && "This action is not supported yet!"); 2224acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Custom: { 2225acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Op = DAG.getVAArg(VT, Tmp1, Tmp2, Node->getOperand(2)); 2226acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Tmp = TLI.LowerOperation(Op, DAG); 2227acc398c195a697795bff3245943d104eb19192b9Nate Begeman if (Tmp.Val) { 2228acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = LegalizeOp(Tmp); 2229acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2230acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2231acc398c195a697795bff3245943d104eb19192b9Nate Begeman // FALLTHROUGH if the target thinks it is legal. 2232acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2233acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Legal: 2234acc398c195a697795bff3245943d104eb19192b9Nate Begeman if (Tmp1 != Node->getOperand(0) || 2235acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 != Node->getOperand(1)) 2236acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = DAG.getVAArg(VT, Tmp1, Tmp2, Node->getOperand(2)); 2237acc398c195a697795bff3245943d104eb19192b9Nate Begeman else 2238acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = SDOperand(Node, 0); 2239acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2240acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Expand: { 2241acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand VAList = DAG.getLoad(TLI.getPointerTy(), Tmp1, Tmp2, 2242acc398c195a697795bff3245943d104eb19192b9Nate Begeman Node->getOperand(2)); 2243acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Increment the pointer, VAList, to the next vaarg 2244acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp3 = DAG.getNode(ISD::ADD, TLI.getPointerTy(), VAList, 2245acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getConstant(MVT::getSizeInBits(VT)/8, 2246acc398c195a697795bff3245943d104eb19192b9Nate Begeman TLI.getPointerTy())); 2247acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Store the incremented VAList to the legalized pointer 2248acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp3 = DAG.getNode(ISD::STORE, MVT::Other, VAList.getValue(1), Tmp3, Tmp2, 2249acc398c195a697795bff3245943d104eb19192b9Nate Begeman Node->getOperand(2)); 2250acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Load the actual argument out of the pointer VAList 2251acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = DAG.getLoad(VT, Tmp3, VAList, DAG.getSrcValue(0)); 2252acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = LegalizeOp(Result); 2253acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2254acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2255acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2256acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Since VAARG produces two values, make sure to remember that we 2257acc398c195a697795bff3245943d104eb19192b9Nate Begeman // legalized both of them. 2258acc398c195a697795bff3245943d104eb19192b9Nate Begeman AddLegalizedOperand(SDOperand(Node, 0), Result); 2259acc398c195a697795bff3245943d104eb19192b9Nate Begeman AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); 2260acc398c195a697795bff3245943d104eb19192b9Nate Begeman return Result.getValue(Op.ResNo); 2261acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2262acc398c195a697795bff3245943d104eb19192b9Nate Begeman 2263acc398c195a697795bff3245943d104eb19192b9Nate Begeman case ISD::VACOPY: 2264acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 2265acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the dest pointer. 2266acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the source pointer. 2267acc398c195a697795bff3245943d104eb19192b9Nate Begeman 2268acc398c195a697795bff3245943d104eb19192b9Nate Begeman switch (TLI.getOperationAction(ISD::VACOPY, MVT::Other)) { 2269acc398c195a697795bff3245943d104eb19192b9Nate Begeman default: assert(0 && "This action is not supported yet!"); 2270acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Custom: { 2271acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Op = DAG.getNode(ISD::VACOPY, MVT::Other, Tmp1, Tmp2, Tmp3, 2272acc398c195a697795bff3245943d104eb19192b9Nate Begeman Node->getOperand(3), Node->getOperand(4)); 2273acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Tmp = TLI.LowerOperation(Op, DAG); 2274acc398c195a697795bff3245943d104eb19192b9Nate Begeman if (Tmp.Val) { 2275acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = LegalizeOp(Tmp); 2276acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2277acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2278acc398c195a697795bff3245943d104eb19192b9Nate Begeman // FALLTHROUGH if the target thinks it is legal. 2279acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2280acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Legal: 2281acc398c195a697795bff3245943d104eb19192b9Nate Begeman if (Tmp1 != Node->getOperand(0) || 2282acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 != Node->getOperand(1) || 2283acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp3 != Node->getOperand(2)) 2284acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = DAG.getNode(ISD::VACOPY, MVT::Other, Tmp1, Tmp2, Tmp3, 2285acc398c195a697795bff3245943d104eb19192b9Nate Begeman Node->getOperand(3), Node->getOperand(4)); 2286acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2287acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Expand: 2288acc398c195a697795bff3245943d104eb19192b9Nate Begeman // This defaults to loading a pointer from the input and storing it to the 2289acc398c195a697795bff3245943d104eb19192b9Nate Begeman // output, returning the chain. 2290acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp4 = DAG.getLoad(TLI.getPointerTy(), Tmp1, Tmp3, Node->getOperand(3)); 2291acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp4.getValue(1), Tmp4, Tmp2, 2292acc398c195a697795bff3245943d104eb19192b9Nate Begeman Node->getOperand(4)); 2293acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = LegalizeOp(Result); 2294acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2295acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2296acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2297acc398c195a697795bff3245943d104eb19192b9Nate Begeman 2298acc398c195a697795bff3245943d104eb19192b9Nate Begeman case ISD::VAEND: 2299acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 2300acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2301acc398c195a697795bff3245943d104eb19192b9Nate Begeman 2302acc398c195a697795bff3245943d104eb19192b9Nate Begeman switch (TLI.getOperationAction(ISD::VAEND, MVT::Other)) { 2303acc398c195a697795bff3245943d104eb19192b9Nate Begeman default: assert(0 && "This action is not supported yet!"); 2304acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Custom: { 2305acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Op = DAG.getNode(ISD::VAEND, MVT::Other, Tmp1, Tmp2, 2306acc398c195a697795bff3245943d104eb19192b9Nate Begeman Node->getOperand(2)); 2307acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Tmp = TLI.LowerOperation(Op, DAG); 2308acc398c195a697795bff3245943d104eb19192b9Nate Begeman if (Tmp.Val) { 2309acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = LegalizeOp(Tmp); 2310acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2311acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2312acc398c195a697795bff3245943d104eb19192b9Nate Begeman // FALLTHROUGH if the target thinks it is legal. 2313acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2314acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Legal: 2315acc398c195a697795bff3245943d104eb19192b9Nate Begeman if (Tmp1 != Node->getOperand(0) || 2316acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 != Node->getOperand(1)) 2317acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = DAG.getNode(ISD::VAEND, MVT::Other, Tmp1, Tmp2, 2318acc398c195a697795bff3245943d104eb19192b9Nate Begeman Node->getOperand(2)); 2319acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2320acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Expand: 2321acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = Tmp1; // Default to a no-op, return the chain 2322acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2323acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2324acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2325acc398c195a697795bff3245943d104eb19192b9Nate Begeman 2326acc398c195a697795bff3245943d104eb19192b9Nate Begeman case ISD::VASTART: 2327acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 2328acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2329acc398c195a697795bff3245943d104eb19192b9Nate Begeman 2330acc398c195a697795bff3245943d104eb19192b9Nate Begeman switch (TLI.getOperationAction(ISD::VASTART, MVT::Other)) { 2331acc398c195a697795bff3245943d104eb19192b9Nate Begeman default: assert(0 && "This action is not supported yet!"); 2332acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Custom: { 2333acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Op = DAG.getNode(ISD::VASTART, MVT::Other, Tmp1, Tmp2, 2334acc398c195a697795bff3245943d104eb19192b9Nate Begeman Node->getOperand(2)); 2335acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Tmp = TLI.LowerOperation(Op, DAG); 2336acc398c195a697795bff3245943d104eb19192b9Nate Begeman if (Tmp.Val) { 2337acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = LegalizeOp(Tmp); 2338acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2339acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2340acc398c195a697795bff3245943d104eb19192b9Nate Begeman // FALLTHROUGH if the target thinks it is legal. 2341acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2342acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Legal: 2343acc398c195a697795bff3245943d104eb19192b9Nate Begeman if (Tmp1 != Node->getOperand(0) || 2344acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 != Node->getOperand(1)) 2345acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = DAG.getNode(ISD::VASTART, MVT::Other, Tmp1, Tmp2, 2346acc398c195a697795bff3245943d104eb19192b9Nate Begeman Node->getOperand(2)); 2347acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2348acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2349acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2350acc398c195a697795bff3245943d104eb19192b9Nate Begeman 235135ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman case ISD::ROTL: 235235ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman case ISD::ROTR: 235335ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 235435ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 235535ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 235635ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman case TargetLowering::Custom: 235735ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman case TargetLowering::Promote: 235835ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman case TargetLowering::Expand: 235935ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman assert(0 && "Cannot handle this yet!"); 236035ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman case TargetLowering::Legal: 236135ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman if (Tmp1 != Node->getOperand(0) || 236235ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman Tmp2 != Node->getOperand(1)) 236335ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 236435ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman Tmp2); 236535ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman break; 236635ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman } 236735ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman break; 236835ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman 2369d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case ISD::BSWAP: 2370d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 2371d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2372d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case TargetLowering::Legal: 2373d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman if (Tmp1 != Node->getOperand(0)) 2374d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2375d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman break; 2376d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case TargetLowering::Promote: { 2377d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman MVT::ValueType OVT = Tmp1.getValueType(); 2378d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 2379d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman unsigned DiffBits = getSizeInBits(NVT) - getSizeInBits(OVT); 2380d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman 2381d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2382d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp1 = DAG.getNode(ISD::BSWAP, NVT, Tmp1); 2383d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Result = DAG.getNode(ISD::SRL, NVT, Tmp1, 2384d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman DAG.getConstant(DiffBits, TLI.getShiftAmountTy())); 2385433f8acefb78f1c8a2cf79c12b101ce7c4b20202Evan Cheng Result = LegalizeOp(Result); 2386d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman break; 2387d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman } 2388d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case TargetLowering::Custom: 2389d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman assert(0 && "Cannot custom legalize this yet!"); 2390d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case TargetLowering::Expand: { 2391d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman MVT::ValueType VT = Tmp1.getValueType(); 2392d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman switch (VT) { 2393d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman default: assert(0 && "Unhandled Expand type in BSWAP!"); abort(); 2394d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case MVT::i16: 2395d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp2 = DAG.getNode(ISD::SHL, VT, Tmp1, 2396d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman DAG.getConstant(8, TLI.getShiftAmountTy())); 2397d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp1 = DAG.getNode(ISD::SRL, VT, Tmp1, 2398d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman DAG.getConstant(8, TLI.getShiftAmountTy())); 2399d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Result = DAG.getNode(ISD::OR, VT, Tmp1, Tmp2); 2400d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman break; 2401d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case MVT::i32: 2402d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp4 = DAG.getNode(ISD::SHL, VT, Tmp1, 2403d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman DAG.getConstant(24, TLI.getShiftAmountTy())); 2404d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp3 = DAG.getNode(ISD::SHL, VT, Tmp1, 2405d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman DAG.getConstant(8, TLI.getShiftAmountTy())); 2406d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp2 = DAG.getNode(ISD::SRL, VT, Tmp1, 2407d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman DAG.getConstant(8, TLI.getShiftAmountTy())); 2408d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp1 = DAG.getNode(ISD::SRL, VT, Tmp1, 2409d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman DAG.getConstant(24, TLI.getShiftAmountTy())); 2410d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp3 = DAG.getNode(ISD::AND, VT, Tmp3, DAG.getConstant(0xFF0000, VT)); 2411d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp2 = DAG.getNode(ISD::AND, VT, Tmp2, DAG.getConstant(0xFF00, VT)); 2412d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp4 = DAG.getNode(ISD::OR, VT, Tmp4, Tmp3); 2413d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp2 = DAG.getNode(ISD::OR, VT, Tmp2, Tmp1); 2414d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Result = DAG.getNode(ISD::OR, VT, Tmp4, Tmp2); 2415d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman break; 2416c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman case MVT::i64: { 2417c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman SDOperand Tmp5, Tmp6, Tmp7, Tmp8; 2418c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp8 = DAG.getNode(ISD::SHL, VT, Tmp1, 2419c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(56, TLI.getShiftAmountTy())); 2420c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp7 = DAG.getNode(ISD::SHL, VT, Tmp1, 2421c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(40, TLI.getShiftAmountTy())); 2422c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp6 = DAG.getNode(ISD::SHL, VT, Tmp1, 2423c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(24, TLI.getShiftAmountTy())); 2424c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp5 = DAG.getNode(ISD::SHL, VT, Tmp1, 2425c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(8, TLI.getShiftAmountTy())); 2426c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp4 = DAG.getNode(ISD::SRL, VT, Tmp1, 2427c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(8, TLI.getShiftAmountTy())); 2428c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp3 = DAG.getNode(ISD::SRL, VT, Tmp1, 2429c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(24, TLI.getShiftAmountTy())); 2430c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp2 = DAG.getNode(ISD::SRL, VT, Tmp1, 2431c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(40, TLI.getShiftAmountTy())); 2432c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp1 = DAG.getNode(ISD::SRL, VT, Tmp1, 2433c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(56, TLI.getShiftAmountTy())); 2434c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp7 = DAG.getNode(ISD::AND, VT, Tmp7, 2435c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(0x00FF000000000000ULL, VT)); 2436c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp6 = DAG.getNode(ISD::AND, VT, Tmp7, 2437c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(0x0000FF0000000000ULL, VT)); 2438c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp5 = DAG.getNode(ISD::AND, VT, Tmp7, 2439c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(0x000000FF00000000ULL, VT)); 2440c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp4 = DAG.getNode(ISD::AND, VT, Tmp7, 2441c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(0x00000000FF000000ULL, VT)); 2442c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp3 = DAG.getNode(ISD::AND, VT, Tmp7, 2443c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(0x0000000000FF0000ULL, VT)); 2444c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp2 = DAG.getNode(ISD::AND, VT, Tmp7, 2445c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman DAG.getConstant(0x000000000000FF00ULL, VT)); 2446c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp8 = DAG.getNode(ISD::OR, VT, Tmp8, Tmp7); 2447c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp6 = DAG.getNode(ISD::OR, VT, Tmp6, Tmp5); 2448c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp4 = DAG.getNode(ISD::OR, VT, Tmp4, Tmp3); 2449c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp2 = DAG.getNode(ISD::OR, VT, Tmp2, Tmp1); 2450c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp8 = DAG.getNode(ISD::OR, VT, Tmp8, Tmp6); 2451c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Tmp4 = DAG.getNode(ISD::OR, VT, Tmp4, Tmp2); 2452c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman Result = DAG.getNode(ISD::OR, VT, Tmp8, Tmp4); 2453c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman break; 2454c02d98e335703d8aa51b42d9b22a1fa2ac5d6c33Nate Begeman } 2455d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman } 2456433f8acefb78f1c8a2cf79c12b101ce7c4b20202Evan Cheng Result = LegalizeOp(Result); 2457d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman break; 2458d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman } 2459d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman } 2460d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman break; 2461d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman 2462691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 2463691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 2464691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 2465691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 2466691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2467691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 2468691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth if (Tmp1 != Node->getOperand(0)) 2469691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2470691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2471691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 2472691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType OVT = Tmp1.getValueType(); 2473691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth MVT::ValueType NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 2474edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 2475edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 2476691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 2477691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 2478691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2479691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch(Node->getOpcode()) 2480691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth { 2481691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 2482691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 2483691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2484691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 2485691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 24867cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 24877cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), 24887cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ); 248900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 2490691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth DAG.getConstant(getSizeInBits(OVT),NVT), Tmp1); 2491691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2492691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 2493691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 249400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 249500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 2496691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getSizeInBits(OVT), NVT)); 2497691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2498691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 2499433f8acefb78f1c8a2cf79c12b101ce7c4b20202Evan Cheng Result = LegalizeOp(Result); 2500691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2501691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 2502691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Custom: 2503691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth assert(0 && "Cannot custom handle this yet!"); 2504691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 2505ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth switch(Node->getOpcode()) 2506ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth { 2507ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth case ISD::CTPOP: { 2508e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner static const uint64_t mask[6] = { 2509e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 2510e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 2511e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 2512e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner }; 2513ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth MVT::ValueType VT = Tmp1.getValueType(); 2514e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner MVT::ValueType ShVT = TLI.getShiftAmountTy(); 2515e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner unsigned len = getSizeInBits(VT); 2516e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 2517ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 2518e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp2 = DAG.getConstant(mask[i], VT); 2519e3ef0a8b9f79d77116e888ffe51730c8279b7363Chris Lattner Tmp3 = DAG.getConstant(1ULL << i, ShVT); 252000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::ADD, VT, 2521ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, Tmp1, Tmp2), 2522ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::AND, VT, 2523ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3), 2524ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth Tmp2)); 2525ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 2526433f8acefb78f1c8a2cf79c12b101ce7c4b20202Evan Cheng Result = LegalizeOp(Tmp1); 2527ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 2528ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 252957ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTLZ: { 253057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina /* for now, we do this: 25315c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 1); 25325c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >> 2); 25335c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner ... 25345c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner x = x | (x >>16); 253500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen x = x | (x >>32); // for 64-bit input 25365c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner return popcount(~x); 253700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 25385c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner but see also: http://www.hackersdelight.org/HDcode/nlz.cc */ 25395c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 254057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina MVT::ValueType ShVT = TLI.getShiftAmountTy(); 254157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina unsigned len = getSizeInBits(VT); 254257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 254357ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getConstant(1ULL << i, ShVT); 254400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp1 = DAG.getNode(ISD::OR, VT, Tmp1, 254557ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina DAG.getNode(ISD::SRL, VT, Tmp1, Tmp3)); 254657ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 254757ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina Tmp3 = DAG.getNode(ISD::XOR, VT, Tmp1, DAG.getConstant(~0ULL, VT)); 25485c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 254918aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 255057ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 255157ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina case ISD::CTTZ: { 255200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen // for now, we use: { return popcount(~x & (x - 1)); } 2553d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // unless the target has ctlz but not ctpop, in which case we use: 2554d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // { return 32 - nlz(~x & (x-1)); } 2555d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // see also http://www.hackersdelight.org/HDcode/ntz.cc 25565c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner MVT::ValueType VT = Tmp1.getValueType(); 25575c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner Tmp2 = DAG.getConstant(~0ULL, VT); 255800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Tmp3 = DAG.getNode(ISD::AND, VT, 25595c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::XOR, VT, Tmp1, Tmp2), 25605c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getNode(ISD::SUB, VT, Tmp1, 25615c33c9a166c2d68d64c68d8097598d09d9af6c20Chris Lattner DAG.getConstant(1, VT))); 2562d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman // If ISD::CTLZ is legal and CTPOP isn't, then do that instead 2563c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::CTPOP, VT) && 2564c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner TLI.isOperationLegal(ISD::CTLZ, VT)) { 256500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = LegalizeOp(DAG.getNode(ISD::SUB, VT, 2566d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getConstant(getSizeInBits(VT), VT), 2567d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman DAG.getNode(ISD::CTLZ, VT, Tmp3))); 2568d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } else { 2569d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman Result = LegalizeOp(DAG.getNode(ISD::CTPOP, VT, Tmp3)); 2570d7c4a4a6c048d4174b8795598f50fd76c30731edNate Begeman } 257118aa680a96c49cf9e28b52f5ab3f2c4f98793636Chris Lattner break; 257257ff7e5f6479b43828406a6723b7dde6f673f48cDuraid Madina } 2573ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth default: 2574ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth assert(0 && "Cannot expand this yet!"); 2575ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth break; 2576ded10bfb46aeacf02acec0018a0b970c1f932a32Andrew Lenharth } 2577691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 2578691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 2579691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 258000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 25812c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 25822c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 25832c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 2584da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 2585da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 2586da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 25872c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 25882c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 25892c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 25902c8086f4b9916b2d02842be5e375276023225fbaChris Lattner if (Tmp1 != Node->getOperand(0)) 25912c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 25922c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 25932c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Promote: 25942c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Custom: 25952c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Cannot promote/custom handle this yet!"); 25962c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 2597f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 2598f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FNEG: { 25992c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 26002c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 260101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = LegalizeOp(DAG.getNode(ISD::FSUB, Node->getValueType(0), 26022c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2, Tmp1)); 2603f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 2604f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2605f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 26064af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 26074af6e0d7836126630f579b0a34f054321187f00bChris Lattner MVT::ValueType VT = Node->getValueType(0); 26084af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 26097cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, Tmp2, ISD::SETUGT); 26104af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp3 = DAG.getNode(ISD::FNEG, VT, Tmp1); 26114af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = DAG.getNode(ISD::SELECT, VT, Tmp2, Tmp1, Tmp3); 26124af6e0d7836126630f579b0a34f054321187f00bChris Lattner Result = LegalizeOp(Result); 2613f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 2614f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2615f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: 2616f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: 2617f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: { 2618f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner MVT::ValueType VT = Node->getValueType(0); 2619f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner const char *FnName = 0; 2620f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 2621f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSQRT: FnName = VT == MVT::f32 ? "sqrtf" : "sqrt"; break; 2622f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FSIN: FnName = VT == MVT::f32 ? "sinf" : "sin"; break; 2623f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FCOS: FnName = VT == MVT::f32 ? "cosf" : "cos"; break; 2624f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 2625f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 26262ac4fc032050ff1e0f06bd8e27126e979406effbNate Begeman SDOperand Dummy; 26279c6b4b8c3a48aa420f6499ca6c1a356f74e100f8Chris Lattner Result = ExpandLibCall(FnName, Node, Dummy); 2628f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 2629f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2630f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: 26314af6e0d7836126630f579b0a34f054321187f00bChris Lattner assert(0 && "Unreachable!"); 26322c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 26332c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 26342c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 26352c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 263635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 263735481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case ISD::BIT_CONVERT: 263867993f7b974cd17e4372a6b7b9f9cad5ed174df1Chris Lattner if (!isTypeLegal(Node->getOperand(0).getValueType())) { 263935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Result = ExpandBIT_CONVERT(Node->getValueType(0), Node->getOperand(0)); 264067993f7b974cd17e4372a6b7b9f9cad5ed174df1Chris Lattner Result = LegalizeOp(Result); 264167993f7b974cd17e4372a6b7b9f9cad5ed174df1Chris Lattner } else { 264235481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner switch (TLI.getOperationAction(ISD::BIT_CONVERT, 264335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Node->getOperand(0).getValueType())) { 264435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner default: assert(0 && "Unknown operation action!"); 264535481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case TargetLowering::Expand: 264635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Result = ExpandBIT_CONVERT(Node->getValueType(0), Node->getOperand(0)); 264767993f7b974cd17e4372a6b7b9f9cad5ed174df1Chris Lattner Result = LegalizeOp(Result); 264835481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 264935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case TargetLowering::Legal: 265035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 265135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner if (Tmp1 != Node->getOperand(0)) 265235481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Result = DAG.getNode(ISD::BIT_CONVERT, Node->getValueType(0), Tmp1); 265335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 265435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner } 265535481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner } 265635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 26572c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 2658fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::SINT_TO_FP: 2659fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::UINT_TO_FP: { 2660fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP; 2661fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2662fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2663d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen switch (TLI.getOperationAction(Node->getOpcode(), 2664fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType())) { 2665fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner default: assert(0 && "Unknown operation action!"); 2666fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Expand: 26676269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Result = ExpandLegalINT_TO_FP(isSigned, 26686269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey LegalizeOp(Node->getOperand(0)), 26696269ed125fc492d81dc5e3f48482816fc9d47f49Jim Laskey Node->getValueType(0)); 2670fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 2671fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 2672fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Promote: 2673fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteLegalINT_TO_FP(LegalizeOp(Node->getOperand(0)), 2674fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), 2675fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner isSigned); 2676fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner AddLegalizedOperand(Op, Result); 2677fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner return Result; 2678fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case TargetLowering::Legal: 2679fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 26805b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth case TargetLowering::Custom: { 26815b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); 26825b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth SDOperand Tmp = 26835b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 26845b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth Tmp = TLI.LowerOperation(Tmp, DAG); 26855b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth if (Tmp.Val) { 268669a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner Tmp = LegalizeOp(Tmp); // Relegalize input. 26875b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth AddLegalizedOperand(Op, Tmp); 26885b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth return Tmp; 26895b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } else { 26905b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth assert(0 && "Target Must Lower this"); 26915b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } 26925b5b8c27556e5dc8792e37436e4ddd7ab157192dAndrew Lenharth } 2693fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2694fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 2695fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2696fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2697fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2698fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2699fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2700fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, 2701fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getValueType(0), Node->getOperand(0)); 2702fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2703fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2704fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (isSigned) { 2705fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2706fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 2707fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result, DAG.getValueType(Node->getOperand(0).getValueType())); 2708fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::SINT_TO_FP, Op.getValueType(), Result); 2709fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } else { 2710fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2711fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getZeroExtendInReg(Result, 2712fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Node->getOperand(0).getValueType()); 2713fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::UINT_TO_FP, Op.getValueType(), Result); 2714fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2715fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2716fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2717fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2718fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2719fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::TRUNCATE: 2720fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2721fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2722fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2723fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2724fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2725fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2726fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2727fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 2728fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner 2729fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // Since the result is legal, we should just be able to truncate the low 2730fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner // part of the source. 2731fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Node->getValueType(0), Tmp1); 2732fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2733fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2734fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2735fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, Op.getValueType(), Result); 2736fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2737fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2738fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2739d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 2740fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_SINT: 2741fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_UINT: 2742fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 2743fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Legal: 2744f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 2745f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner 27461618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))){ 27471618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner default: assert(0 && "Unknown operation action!"); 27481618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Expand: 2749d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT) { 2750d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman SDOperand True, False; 2751d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType VT = Node->getOperand(0).getValueType(); 2752d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman MVT::ValueType NVT = Node->getValueType(0); 2753d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman unsigned ShiftAmt = MVT::getSizeInBits(Node->getValueType(0))-1; 2754d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getConstantFP((double)(1ULL << ShiftAmt), VT); 2755d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp3 = DAG.getSetCC(TLI.getSetCCResultTy(), 2756d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Node->getOperand(0), Tmp2, ISD::SETLT); 2757d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman True = DAG.getNode(ISD::FP_TO_SINT, NVT, Node->getOperand(0)); 2758d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::FP_TO_SINT, NVT, 275901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getNode(ISD::FSUB, VT, Node->getOperand(0), 2760d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2)); 2761d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman False = DAG.getNode(ISD::XOR, NVT, False, 2762d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman DAG.getConstant(1ULL << ShiftAmt, NVT)); 2763d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = LegalizeOp(DAG.getNode(ISD::SELECT, NVT, Tmp3, True, False)); 276469a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner AddLegalizedOperand(SDOperand(Node, 0), Result); 27652d56e72f09337a1cab3ba199a9467c159296f3faNate Begeman return Result; 2766d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 2767d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman assert(0 && "Do not know how to expand FP_TO_SINT yet!"); 2768d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 2769d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman break; 27701618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Promote: 2771f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner Result = PromoteLegalFP_TO_INT(Tmp1, Node->getValueType(0), 27721618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner Node->getOpcode() == ISD::FP_TO_SINT); 27731618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner AddLegalizedOperand(Op, Result); 27741618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner return Result; 277507dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 277607dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand Tmp = 277707dffd6af673c73352150583150b242a93694f00Chris Lattner DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 277807dffd6af673c73352150583150b242a93694f00Chris Lattner Tmp = TLI.LowerOperation(Tmp, DAG); 277907dffd6af673c73352150583150b242a93694f00Chris Lattner if (Tmp.Val) { 278069a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner Tmp = LegalizeOp(Tmp); 278107dffd6af673c73352150583150b242a93694f00Chris Lattner AddLegalizedOperand(Op, Tmp); 2782507f752f6ed28aa9f0ae680e95bfc93df4e9e2dcChris Lattner return Tmp; 278307dffd6af673c73352150583150b242a93694f00Chris Lattner } else { 278407dffd6af673c73352150583150b242a93694f00Chris Lattner // The target thinks this is legal afterall. 278507dffd6af673c73352150583150b242a93694f00Chris Lattner break; 278607dffd6af673c73352150583150b242a93694f00Chris Lattner } 278707dffd6af673c73352150583150b242a93694f00Chris Lattner } 27881618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner case TargetLowering::Legal: 27891618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner break; 27901618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 2791d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 2792fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner if (Tmp1 != Node->getOperand(0)) 2793fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 2794fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2795fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Expand: 2796fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2797fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case Promote: 2798fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = PromoteOp(Node->getOperand(0)); 2799fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2800fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2801fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 2802fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 2803d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 280413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 28053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 28063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 280703c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_EXTEND: 280803c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::FP_ROUND: 28093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 28103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case Legal: 28113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 28123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (Tmp1 != Node->getOperand(0)) 28133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1); 28143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2815b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner case Expand: 28162c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(0 && "Shouldn't need to expand other operators here!"); 2817b00a6425de1ef8668b63f29927c38da8a19ce904Chris Lattner 281803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Promote: 281903c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 282013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 282113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = PromoteOp(Node->getOperand(0)); 282213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 282313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 28241713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner case ISD::ZERO_EXTEND: 28251713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 282613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 282723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 282823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 282903c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 283003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SIGN_EXTEND: 28311713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 283213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Result = DAG.getNode(ISD::ANY_EXTEND, Op.getValueType(), Result); 28331713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 283415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 283515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 28361713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 283703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_EXTEND: 28381713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = PromoteOp(Node->getOperand(0)); 28391713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner if (Result.getValueType() != Op.getValueType()) 28401713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner // Dynamically dead while we have only 2 FP types. 28411713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner Result = DAG.getNode(ISD::FP_EXTEND, Op.getValueType(), Result); 28421713e73b8ac53f045150cb2a7d7ba9781dc35ef8Chris Lattner break; 284303c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::FP_ROUND: 2844f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = PromoteOp(Node->getOperand(0)); 2845f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner Result = DAG.getNode(Node->getOpcode(), Op.getValueType(), Result); 2846f8161d83f0201a32a33a0c875eb43df81d8586abChris Lattner break; 284703c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 28483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 28493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 28500f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 285123993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 28520f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 285315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 285445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 285545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 285645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 285755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 285855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 285955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 286055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner if (Tmp1 != Node->getOperand(0)) 286155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, 28625f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner DAG.getValueType(ExtraVT)); 286355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 286455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 286545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 286623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 286745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 286845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 286945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned BitsDiff = MVT::getSizeInBits(Node->getValueType(0)) - 287045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MVT::getSizeInBits(ExtraVT); 287127ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner SDOperand ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 287245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SHL, Node->getValueType(0), 287345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 287445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::SRA, Node->getValueType(0), 287545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 287645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 287745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // The only way we can lower this is to turn it into a STORETRUNC, 287845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 287945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 288045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 288145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 288245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 288345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner const Type *Ty = MVT::getTypeForValueType(ExtraVT); 288445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned TySize = (unsigned)TLI.getTargetData().getTypeSize(Ty); 288545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 288645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 2887edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman int SSFI = 288845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 288945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 289045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, DAG.getEntryNode(), 289152d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner Node->getOperand(0), StackSlot, 28929fadb4c1c0a6d223aa468f9f72f8c2562dc66839Chris Lattner DAG.getSrcValue(NULL), DAG.getValueType(ExtraVT)); 28935f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result = DAG.getExtLoad(ISD::EXTLOAD, Node->getValueType(0), 28945f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner Result, StackSlot, DAG.getSrcValue(NULL), 28955f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner ExtraVT); 289645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 289745b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 289845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 289945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result = LegalizeOp(Result); 290055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 290145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 29020f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 29033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 290445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 29053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 290645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 290745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 290845982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 29093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 29103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 29113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 29128b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// PromoteOp - Given an operation that produces a value in an invalid type, 29138b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// promote it to compute the value into a larger type. The produced value will 29148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// have the correct bits for the low portion of the register, but no guarantee 29158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner/// is made about the top bits: it may be zero, sign-extended, or garbage. 291603c8546ec57523970874917854a2fb77b1ff598eChris LattnerSDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) { 291703c8546ec57523970874917854a2fb77b1ff598eChris Lattner MVT::ValueType VT = Op.getValueType(); 291871c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 291903c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(getTypeAction(VT) == Promote && 292003c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Caller should expand or legalize operands that are not promotable!"); 292103c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(NVT > VT && MVT::isInteger(NVT) == MVT::isInteger(VT) && 292203c8546ec57523970874917854a2fb77b1ff598eChris Lattner "Cannot promote to smaller type!"); 292303c8546ec57523970874917854a2fb77b1ff598eChris Lattner 292403c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Tmp1, Tmp2, Tmp3; 292503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 292603c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDOperand Result; 292703c8546ec57523970874917854a2fb77b1ff598eChris Lattner SDNode *Node = Op.Val; 292803c8546ec57523970874917854a2fb77b1ff598eChris Lattner 29296fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op); 29306fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != PromotedNodes.end()) return I->second; 293145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner 29320f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // Promotion needs an optimization step to clean up after it, and is not 29330f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // careful to avoid operations the target does not support. Make sure that 29340f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // all generated operations are legalized in the next iteration. 29350f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner NeedsAnotherIteration = true; 29360f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 293703c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (Node->getOpcode()) { 2938d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner case ISD::CopyFromReg: 2939d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner assert(0 && "CopyFromReg must be legal!"); 294003c8546ec57523970874917854a2fb77b1ff598eChris Lattner default: 294103c8546ec57523970874917854a2fb77b1ff598eChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 294203c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(0 && "Do not know how to promote this operator!"); 294303c8546ec57523970874917854a2fb77b1ff598eChris Lattner abort(); 2944fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 2945fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getNode(ISD::UNDEF, NVT); 2946fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 294703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::Constant: 2948ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner if (VT != MVT::i1) 2949ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND, NVT, Op); 2950ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner else 2951ec176e30d655f96d75b49e620a849008bf0f63a2Chris Lattner Result = DAG.getNode(ISD::ZERO_EXTEND, NVT, Op); 295203c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantSDNode>(Result) && "Didn't constant fold zext?"); 295303c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 295403c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::ConstantFP: 295503c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::FP_EXTEND, NVT, Op); 295603c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(isa<ConstantFPSDNode>(Result) && "Didn't constant fold fp_extend?"); 295703c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2958ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner 295982fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner case ISD::SETCC: 2960c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(TLI.getSetCCResultTy()) && "SetCC type is not legal??"); 29617cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Result = DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(),Node->getOperand(0), 29627cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner Node->getOperand(1), Node->getOperand(2)); 296382fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner Result = LegalizeOp(Result); 296482fbfb6984c1feb7d44a077ac2dc031f4a950005Chris Lattner break; 296503c8546ec57523970874917854a2fb77b1ff598eChris Lattner 296603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::TRUNCATE: 296703c8546ec57523970874917854a2fb77b1ff598eChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 296803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Legal: 296903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 297003c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.getValueType() >= NVT && 297103c8546ec57523970874917854a2fb77b1ff598eChris Lattner "This truncation doesn't make sense!"); 297203c8546ec57523970874917854a2fb77b1ff598eChris Lattner if (Result.getValueType() > NVT) // Truncate to NVT instead of VT 297303c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Result); 297403c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 2975e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner case Promote: 2976e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // The truncation is not required, because we don't guarantee anything 2977e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner // about high bits anyway. 2978e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner Result = PromoteOp(Node->getOperand(0)); 2979e76ad6de40b5e4c0399257b0438914c8c85ceaa1Chris Lattner break; 298003c8546ec57523970874917854a2fb77b1ff598eChris Lattner case Expand: 298179e46acd35df36477029e9f534ab1a366a98df56Nate Begeman ExpandOp(Node->getOperand(0), Tmp1, Tmp2); 298279e46acd35df36477029e9f534ab1a366a98df56Nate Begeman // Truncate the low part of the expanded value to the result type 2983e21c305ed85b2be4a27784ba52471f6b68fdd255Chris Lattner Result = DAG.getNode(ISD::TRUNCATE, NVT, Tmp1); 298403c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 298503c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 29868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SIGN_EXTEND: 29878b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::ZERO_EXTEND: 298813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 29898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 29908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Smaller reg should have been promoted!"); 29918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 29928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Just do extend all the way to the larger type. 29938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 29948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 29958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 29968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 29978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Promote the reg if it's smaller. 29988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 29998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The high bits are not guaranteed to be anything. Insert an extend. 30008b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND) 3001595dc5408ad809b9a9a417db275c43242e54b8dcChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 300215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 300313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner else if (Node->getOpcode() == ISD::ZERO_EXTEND) 300423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 300523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 30068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 30078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 30088b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 300935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case ISD::BIT_CONVERT: 301035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Result = ExpandBIT_CONVERT(Node->getValueType(0), Node->getOperand(0)); 301135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Result = PromoteOp(Result); 301235481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 301335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 30148b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_EXTEND: 30158b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "Case not implemented. Dynamically dead with 2 FP types!"); 30168b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_ROUND: 30178b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 30188b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: assert(0 && "BUG: Cannot expand FP regs!"); 30198b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: assert(0 && "Unreachable with 2 FP types!"); 30208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 30218b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Input is legal? Do an FP_ROUND_INREG. 30228b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 302315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 302415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 30258b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 30268b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 30278b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 30288b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 30298b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SINT_TO_FP: 30308b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UINT_TO_FP: 30318b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 30328b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 30338b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = LegalizeOp(Node->getOperand(0)); 303477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 303577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 30368b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 30378b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 30388b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 30398b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = PromoteOp(Node->getOperand(0)); 30408b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (Node->getOpcode() == ISD::SINT_TO_FP) 30418b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, Result.getValueType(), 304215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result, 304315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 30448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner else 304523993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Result = DAG.getZeroExtendInReg(Result, 304623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Node->getOperand(0).getValueType()); 304777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // No extra round required here. 304877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Result); 30498b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 30508b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 305177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Result = ExpandIntToFP(Node->getOpcode() == ISD::SINT_TO_FP, NVT, 305277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Node->getOperand(0)); 305377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // Round if we cannot tolerate excess precision. 305477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (NoExcessFPPrecision) 305515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 305615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 305777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner break; 30588b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 30598b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 30608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 30615e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner case ISD::SIGN_EXTEND_INREG: 30625e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Result = PromoteOp(Node->getOperand(0)); 30635e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Result, 30645e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner Node->getOperand(1)); 30655e3c5b4e13d45d631cddf42176b380f64fde918fChris Lattner break; 30668b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_SINT: 30678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::FP_TO_UINT: 30688b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 30698b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Legal: 30708b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 30718b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 30728b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Promote: 30738b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input result is prerounded, so we don't have to do anything 30748b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // special. 30758b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 30768b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 30778b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case Expand: 30788b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(0 && "not implemented"); 30798b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 3080d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // If we're promoting a UINT to a larger size, check to see if the new node 3081d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 3082d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // we can use that instead. This allows us to generate better code for 3083d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 3084d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman // legal, such as PowerPC. 3085d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman if (Node->getOpcode() == ISD::FP_TO_UINT && 3086c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) && 3087b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman (TLI.isOperationLegal(ISD::FP_TO_SINT, NVT) || 3088b7f6ef12f682c7068ca7513e088177a0d1046b35Nate Begeman TLI.getOperationAction(ISD::FP_TO_SINT, NVT)==TargetLowering::Custom)){ 3089d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(ISD::FP_TO_SINT, NVT, Tmp1); 3090d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } else { 3091d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 3092d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman } 30938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 30948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 30952c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 30962c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 30972c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 30982c8086f4b9916b2d02842be5e375276023225fbaChris Lattner assert(Tmp1.getValueType() == NVT); 30992c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 31002c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NOTE: we do not have to do any extra rounding here for 31012c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // NoExcessFPPrecision, because we know the input will have the appropriate 31022c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // precision, and these operations don't modify precision at all. 31032c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 31042c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 3105da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 3106da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 3107da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 3108da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 3109da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner assert(Tmp1.getValueType() == NVT); 3110da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 3111da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner if(NoExcessFPPrecision) 311215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 311315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 3114da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner break; 3115da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner 311603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::AND: 311703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::OR: 311803c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::XOR: 31190f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::ADD: 31208b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SUB: 31210f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::MUL: 31220f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // The input may have strange things in the top bits of the registers, but 312301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. They may have weird bits going out, but 31240f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner // that too is okay if they are integer operations. 31250f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 31260f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 31270f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 31280f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 312901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 313001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 313101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 313201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 313301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // The input may have strange things in the top bits of the registers, but 313401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // these operations don't care. 313501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 313601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 313701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner assert(Tmp1.getValueType() == NVT && Tmp2.getValueType() == NVT); 313801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 313901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 314001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Floating point operations will give excess precision that we may not be 314101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // able to tolerate. If we DO allow excess precision, just leave it, 314201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // otherwise excise it. 31438b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // FIXME: Why would we need to round FP ops more than integer ones? 31448b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Is Round(Add(Add(A,B),C)) != Round(Add(Round(Add(A,B)), C)) 314501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 314615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 314715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 31480f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 31490f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner 31508b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SDIV: 31518b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SREM: 31528b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be sign extended. 31538b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 31548b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 31558b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isInteger(NVT)) { 315615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 315715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 315815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp2 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp2, 315915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 31608b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner } 31618b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 31628b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 31638b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 31648b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner if (MVT::isFloatingPoint(NVT) && NoExcessFPPrecision) 316515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 316615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 31678b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 316801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 316901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 317001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // These operators require that their input be fp extended. 317101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 317201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 317301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 317401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner 317501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner // Perform FP_ROUND: this is probably overly pessimistic. 317601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (NoExcessFPPrecision) 317701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner Result = DAG.getNode(ISD::FP_ROUND_INREG, NVT, Result, 317801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner DAG.getValueType(VT)); 317901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner break; 31808b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 31818b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UDIV: 31828b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::UREM: 31838b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // These operators require that their input be zero extended. 31848b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 31858b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); 31868b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner assert(MVT::isInteger(NVT) && "Operators don't apply to FP!"); 318723993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 318823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp2 = DAG.getZeroExtendInReg(Tmp2, VT); 31898b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(Node->getOpcode(), NVT, Tmp1, Tmp2); 31908b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 31918b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner 31928b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SHL: 31938b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 31948b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 31958b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SHL, NVT, Tmp1, Tmp2); 31968b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 31978b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRA: 31988b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly sign extended. 31998b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 320015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner Tmp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Tmp1, 320115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(VT)); 32028b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 32038b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRA, NVT, Tmp1, Tmp2); 32048b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 32058b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner case ISD::SRL: 32068b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner // The input value must be properly zero extended. 32078b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); 320823993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner Tmp1 = DAG.getZeroExtendInReg(Tmp1, VT); 32098b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 32108b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner Result = DAG.getNode(ISD::SRL, NVT, Tmp1, Tmp2); 32118b6fa22e722e1de7522aae51d6cdd0f552d489daChris Lattner break; 32120aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman 32130aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman case ISD::VAARG: 32140aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 32150aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 32160aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman if (TLI.getOperationAction(ISD::VAARG, VT) == TargetLowering::Custom) { 32170aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman Tmp3 = DAG.getVAArg(VT, Tmp1, Tmp2, Node->getOperand(2)); 32180aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman Result = TLI.CustomPromoteOperation(Tmp3, DAG); 32190aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman } else { 32200aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman SDOperand VAList = DAG.getLoad(TLI.getPointerTy(), Tmp1, Tmp2, 32210aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman Node->getOperand(2)); 32220aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman // Increment the pointer, VAList, to the next vaarg 32230aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman Tmp3 = DAG.getNode(ISD::ADD, TLI.getPointerTy(), VAList, 32240aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman DAG.getConstant(MVT::getSizeInBits(VT)/8, 32250aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman TLI.getPointerTy())); 32260aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman // Store the incremented VAList to the legalized pointer 32270aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman Tmp3 = DAG.getNode(ISD::STORE, MVT::Other, VAList.getValue(1), Tmp3, Tmp2, 32280aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman Node->getOperand(2)); 32290aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman // Load the actual argument out of the pointer VAList 32300aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman Result = DAG.getExtLoad(ISD::EXTLOAD, NVT, Tmp3, VAList, 32310aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman DAG.getSrcValue(0), VT); 32320aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman } 32330aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman // Remember that we legalized the chain. 32340aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 32350aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman break; 32360aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman 323703c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::LOAD: 323803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 323903c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 3240ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Result = DAG.getExtLoad(ISD::EXTLOAD, NVT, Tmp1, Tmp2, 3241ded4963ab98c424a8e83f4dc0e63203754ca353bNate Begeman Node->getOperand(2), VT); 324203c8546ec57523970874917854a2fb77b1ff598eChris Lattner // Remember that we legalized the chain. 324303c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 324403c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 32454c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::SEXTLOAD: 32464c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::ZEXTLOAD: 32474c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner case ISD::EXTLOAD: 32484c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 32494c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 32508136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Result = DAG.getExtLoad(Node->getOpcode(), NVT, Tmp1, Tmp2, 32518136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner Node->getOperand(2), 32528136cdae60eaa30cea91f288f25564a417b19a84Chris Lattner cast<VTSDNode>(Node->getOperand(3))->getVT()); 32534c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner // Remember that we legalized the chain. 32544c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 32554c8f8f0481b26818d7810a6a585e7ecf52973e93Chris Lattner break; 325603c8546ec57523970874917854a2fb77b1ff598eChris Lattner case ISD::SELECT: 325747e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 325847e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 325947e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 326047e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0));// Legalize the condition. 326147e9223e06390897c3834f8c527001df392570ffChris Lattner break; 326247e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 326347e9223e06390897c3834f8c527001df392570ffChris Lattner Tmp1 = PromoteOp(Node->getOperand(0)); // Promote the condition. 326447e9223e06390897c3834f8c527001df392570ffChris Lattner break; 326547e9223e06390897c3834f8c527001df392570ffChris Lattner } 326603c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp2 = PromoteOp(Node->getOperand(1)); // Legalize the op0 326703c8546ec57523970874917854a2fb77b1ff598eChris Lattner Tmp3 = PromoteOp(Node->getOperand(2)); // Legalize the op1 326803c8546ec57523970874917854a2fb77b1ff598eChris Lattner Result = DAG.getNode(ISD::SELECT, NVT, Tmp1, Tmp2, Tmp3); 326903c8546ec57523970874917854a2fb77b1ff598eChris Lattner break; 32709373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: 32719373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2 = PromoteOp(Node->getOperand(2)); // True 32729373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = PromoteOp(Node->getOperand(3)); // False 32739373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Result = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 32749373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), Tmp2, Tmp3, 32759373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(4)); 32769373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 3277d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case ISD::BSWAP: 3278d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp1 = Node->getOperand(0); 3279d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 3280d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp1 = DAG.getNode(ISD::BSWAP, NVT, Tmp1); 3281d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Result = DAG.getNode(ISD::SRL, NVT, Tmp1, 3282d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman DAG.getConstant(getSizeInBits(NVT) - getSizeInBits(VT), 3283d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman TLI.getShiftAmountTy())); 3284d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman break; 3285fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 3286fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 3287fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 3288fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = Node->getOperand(0); 3289fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Zero extend the argument 3290fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, NVT, Tmp1); 3291fecf095292991bdf9396fec474011446107f9813Andrew Lenharth // Perform the larger operation, then subtract if needed. 3292fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Tmp1 = DAG.getNode(Node->getOpcode(), NVT, Tmp1); 3293fecf095292991bdf9396fec474011446107f9813Andrew Lenharth switch(Node->getOpcode()) 3294fecf095292991bdf9396fec474011446107f9813Andrew Lenharth { 3295fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTPOP: 3296fecf095292991bdf9396fec474011446107f9813Andrew Lenharth Result = Tmp1; 3297fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 3298fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTTZ: 3299fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 3300d2558e3e4af2930730e2314868afd09ba005e282Nate Begeman Tmp2 = DAG.getSetCC(TLI.getSetCCResultTy(), Tmp1, 33017cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(getSizeInBits(NVT), NVT), ISD::SETEQ); 330200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SELECT, NVT, Tmp2, 3303fecf095292991bdf9396fec474011446107f9813Andrew Lenharth DAG.getConstant(getSizeInBits(VT),NVT), Tmp1); 3304fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 3305fecf095292991bdf9396fec474011446107f9813Andrew Lenharth case ISD::CTLZ: 3306fecf095292991bdf9396fec474011446107f9813Andrew Lenharth //Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 330700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen Result = DAG.getNode(ISD::SUB, NVT, Tmp1, 330800b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.getConstant(getSizeInBits(NVT) - 3309fecf095292991bdf9396fec474011446107f9813Andrew Lenharth getSizeInBits(VT), NVT)); 3310fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 3311fecf095292991bdf9396fec474011446107f9813Andrew Lenharth } 3312fecf095292991bdf9396fec474011446107f9813Andrew Lenharth break; 331303c8546ec57523970874917854a2fb77b1ff598eChris Lattner } 331403c8546ec57523970874917854a2fb77b1ff598eChris Lattner 331503c8546ec57523970874917854a2fb77b1ff598eChris Lattner assert(Result.Val && "Didn't set a result!"); 331603c8546ec57523970874917854a2fb77b1ff598eChris Lattner AddPromotedOperand(Op, Result); 331703c8546ec57523970874917854a2fb77b1ff598eChris Lattner return Result; 331803c8546ec57523970874917854a2fb77b1ff598eChris Lattner} 33193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 332035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner/// ExpandBIT_CONVERT - Expand a BIT_CONVERT node into a store/load combination. 3321232348d66fcfe8f42f8b14cfacd2df3d00d2596eChris Lattner/// The resultant code need not be legal. Note that SrcOp is the input operand 3322232348d66fcfe8f42f8b14cfacd2df3d00d2596eChris Lattner/// to the BIT_CONVERT, not the BIT_CONVERT node itself. 332335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris LattnerSDOperand SelectionDAGLegalize::ExpandBIT_CONVERT(MVT::ValueType DestVT, 332435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner SDOperand SrcOp) { 332535481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Create the stack frame object. 332635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner MachineFrameInfo *FrameInfo = DAG.getMachineFunction().getFrameInfo(); 332735481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner unsigned ByteSize = MVT::getSizeInBits(DestVT)/8; 3328232348d66fcfe8f42f8b14cfacd2df3d00d2596eChris Lattner int FrameIdx = FrameInfo->CreateStackObject(ByteSize, ByteSize); 332935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner SDOperand FIPtr = DAG.getFrameIndex(FrameIdx, TLI.getPointerTy()); 333035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 333135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Emit a store to the stack slot. 333235481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner SDOperand Store = DAG.getNode(ISD::STORE, MVT::Other, DAG.getEntryNode(), 3333ed7b5babfbdc708c564266052ad3b0ce0a5726c5Chris Lattner SrcOp, FIPtr, DAG.getSrcValue(NULL)); 333435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Result is a load from the stack slot. 333535481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner return DAG.getLoad(DestVT, Store, FIPtr, DAG.getSrcValue(0)); 333635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner} 333735481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 333884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// ExpandAddSub - Find a clever way to expand this add operation into 333984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner/// subcomponents. 33404759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattnervoid SelectionDAGLegalize:: 33414759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris LattnerExpandByParts(unsigned NodeOp, SDOperand LHS, SDOperand RHS, 33424759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner SDOperand &Lo, SDOperand &Hi) { 334384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner // Expand the subcomponents. 334484f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 334584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(LHS, LHSL, LHSH); 334684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner ExpandOp(RHS, RHSL, RHSH); 334784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 334884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner std::vector<SDOperand> Ops; 334984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSL); 335084f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LHSH); 335184f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSL); 335284f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(RHSH); 3353e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 3354e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 335584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Hi = Lo.getValue(1); 335684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner} 335784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner 33585b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattnervoid SelectionDAGLegalize::ExpandShiftParts(unsigned NodeOp, 33595b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand Op, SDOperand Amt, 33605b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand &Lo, SDOperand &Hi) { 33615b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner // Expand the subcomponents. 33625b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner SDOperand LHSL, LHSH; 33635b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner ExpandOp(Op, LHSL, LHSH); 33645b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 33655b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner std::vector<SDOperand> Ops; 33665b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSL); 33675b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(LHSH); 33685b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Ops.push_back(Amt); 3369cc0675a4be9a5133abd48ee272ff999ae48feabfChris Lattner std::vector<MVT::ValueType> VTs(2, LHSL.getValueType()); 3370e89083a9300dc463e3b79eabe2b9913d85338d28Chris Lattner Lo = DAG.getNode(NodeOp, VTs, Ops); 33715b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner Hi = Lo.getValue(1); 33725b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner} 33735b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 33745b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner 3375e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// ExpandShift - Try to find a clever way to expand this shift operation out to 3376e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// smaller elements. If we can't find a way that is more efficient than a 3377e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// libcall on this target, return false. Otherwise, return true with the 3378e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner/// low-parts expanded into Lo and Hi. 3379e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattnerbool SelectionDAGLegalize::ExpandShift(unsigned Opc, SDOperand Op,SDOperand Amt, 3380e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand &Lo, SDOperand &Hi) { 3381e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner assert((Opc == ISD::SHL || Opc == ISD::SRA || Opc == ISD::SRL) && 3382e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner "This is not a shift!"); 3383f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 3384e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(Op.getValueType()); 3385f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand ShAmt = LegalizeOp(Amt); 3386f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman MVT::ValueType ShTy = ShAmt.getValueType(); 3387f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned VTBits = MVT::getSizeInBits(Op.getValueType()); 3388f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned NVTBits = MVT::getSizeInBits(NVT); 3389f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman 3390f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Handle the case when Amt is an immediate. Other cases are currently broken 3391f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and are disabled. 3392f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Amt.Val)) { 3393f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman unsigned Cst = CN->getValue(); 3394f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // Expand the incoming operand to be shifted, so that we have its parts 3395f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman SDOperand InL, InH; 3396f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman ExpandOp(Op, InL, InH); 3397f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman switch(Opc) { 3398f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SHL: 3399f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 3400f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 3401f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 3402f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 3403f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 3404f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst-NVTBits,ShTy)); 3405ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 3406ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = DAG.getConstant(0, NVT); 3407ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = InL; 3408f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 3409f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Cst, ShTy)); 3410f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::OR, NVT, 3411f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(Cst, ShTy)), 3412f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(NVTBits-Cst, ShTy))); 3413f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 3414f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 3415f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRL: 3416f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 3417f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getConstant(0, NVT); 3418f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 3419f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 3420f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst-NVTBits,ShTy)); 3421f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getConstant(0, NVT); 3422ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 3423ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 3424ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Hi = DAG.getConstant(0, NVT); 3425f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 3426f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 3427f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 3428f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 3429f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Cst, ShTy)); 3430f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 3431f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 3432f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman case ISD::SRA: 3433f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman if (Cst > VTBits) { 3434edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 3435f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 3436f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else if (Cst > NVTBits) { 3437edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Lo = DAG.getNode(ISD::SRA, NVT, InH, 3438f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(Cst-NVTBits, ShTy)); 3439edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 3440f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getConstant(NVTBits-1, ShTy)); 3441ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner } else if (Cst == NVTBits) { 3442ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner Lo = InH; 3443edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Hi = DAG.getNode(ISD::SRA, NVT, InH, 3444ee27f57a6a4dd7fa9259b3604f563907da1f65efChris Lattner DAG.getConstant(NVTBits-1, ShTy)); 3445f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } else { 3446f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Lo = DAG.getNode(ISD::OR, NVT, 3447f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SRL, NVT, InL, DAG.getConstant(Cst, ShTy)), 3448f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman DAG.getNode(ISD::SHL, NVT, InH, DAG.getConstant(NVTBits-Cst, ShTy))); 3449f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Cst, ShTy)); 3450f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 3451f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return true; 3452f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 3453f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman } 3454f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // FIXME: The following code for expanding shifts using ISD::SELECT is buggy, 3455f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // so disable it for now. Currently targets are handling this via SHL_PARTS 3456f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman // and friends. 3457f1fe32e337cf825a27a57bb3e9fb847bc91a26ceNate Begeman return false; 3458e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3459e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we have an efficient select operation (or if the selects will all fold 3460e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // away), lower to some complex code, otherwise just emit the libcall. 3461c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (!TLI.isOperationLegal(ISD::SELECT, NVT) && !isa<ConstantSDNode>(Amt)) 3462e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return false; 3463e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3464e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand InL, InH; 3465e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ExpandOp(Op, InL, InH); 3466e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand NAmt = DAG.getNode(ISD::SUB, ShTy, // NAmt = 32-ShAmt 3467e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits, ShTy), ShAmt); 3468e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3469e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner // Compare the unmasked shift amount against 32. 34707cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand Cond = DAG.getSetCC(TLI.getSetCCResultTy(), ShAmt, 34717cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(NVTBits, ShTy), ISD::SETGE); 3472e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner 3473e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (TLI.getShiftAmountFlavor() != TargetLowering::Mask) { 3474e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner ShAmt = DAG.getNode(ISD::AND, ShTy, ShAmt, // ShAmt &= 31 3475e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 3476e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner NAmt = DAG.getNode(ISD::AND, ShTy, NAmt, // NAmt &= 31 3477e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 3478e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 3479e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3480e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner if (Opc == ISD::SHL) { 3481e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << Amt) | (Lo >> NAmt) 3482e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, ShAmt), 3483e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, NAmt)); 3484e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(ISD::SHL, NVT, InL, ShAmt); // T2 = Lo << Amt&31 3485edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3486e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 3487e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, DAG.getConstant(0, NVT), T2); 3488e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } else { 348977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand HiLoPart = DAG.getNode(ISD::SELECT, NVT, 34907cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getSetCC(TLI.getSetCCResultTy(), NAmt, 34917cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(32, ShTy), 34927cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ), 349377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(0, NVT), 349477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, NAmt)); 3495e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand T1 = DAG.getNode(ISD::OR, NVT,// T1 = (Hi << NAmt) | (Lo >> Amt) 349677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiLoPart, 3497e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, ShAmt)); 3498e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner SDOperand T2 = DAG.getNode(Opc, NVT, InH, ShAmt); // T2 = InH >> ShAmt&31 3499e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3500e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner SDOperand HiPart; 350177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner if (Opc == ISD::SRA) 350277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner HiPart = DAG.getNode(ISD::SRA, NVT, InH, 350377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 3504e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner else 3505e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner HiPart = DAG.getConstant(0, NVT); 3506e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, Cond, T2, T1); 3507e5544f851a2a3f7b06339b132e60ad2f2d53e7b8Chris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, Cond, HiPart, T2); 3508e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner } 3509e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner return true; 3510e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner} 351177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 35129530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindLatestCallSeqStart - Scan up the dag to find the latest (highest 35139530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqStart operation and occurs later than 35149c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// Found. 3515de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattnerstatic void FindLatestCallSeqStart(SDNode *Node, SDNode *&Found, 3516de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner std::set<SDNode*> &Visited) { 3517a68d204843fc8b9606e7760fcddd20b99e8e340dChris Lattner if (Node->getNodeDepth() <= Found->getNodeDepth() || 3518de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner !Visited.insert(Node).second) return; 35192f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner 352016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_START, we already know this node occurs later 35219c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 352216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) { 35239c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 35249c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 35259c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 35269c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 35279c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 35289c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner assert(Node->getNumOperands() != 0 && 35299c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner "All leaves should have depth equal to the entry node!"); 3530829cb818065673a50101435f3c25e50ca82a02bfNate Begeman for (unsigned i = 0, e = Node->getNumOperands()-1; i != e; ++i) 3531de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner FindLatestCallSeqStart(Node->getOperand(i).Val, Found, Visited); 35329c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 35339c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 35349530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner FindLatestCallSeqStart(Node->getOperand(Node->getNumOperands()-1).Val, 3535de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner Found, Visited); 35369c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 35379c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 35389c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 35399530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindEarliestCallSeqEnd - Scan down the dag to find the earliest (lowest 35409530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// NodeDepth) node that is an CallSeqEnd operation and occurs more recent 35419c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// than Found. 354282299e70977500209c951404e354510feffb8efaChris Lattnerstatic void FindEarliestCallSeqEnd(SDNode *Node, SDNode *&Found, 354382299e70977500209c951404e354510feffb8efaChris Lattner std::set<SDNode*> &Visited) { 3544a68d204843fc8b9606e7760fcddd20b99e8e340dChris Lattner if ((Found && Node->getNodeDepth() >= Found->getNodeDepth()) || 354582299e70977500209c951404e354510feffb8efaChris Lattner !Visited.insert(Node).second) return; 35469c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 354716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // If we found an CALLSEQ_END, we already know this node occurs earlier 35489c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // than the Found node. Just remember this node and return. 354916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) { 35509c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner Found = Node; 35519c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return; 35529c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 35539c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 35549c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Otherwise, scan the operands of Node to see if any of them is a call. 35559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end(); 35569c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (UI == E) return; 35579c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (--E; UI != E; ++UI) 355882299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 35599c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 35609c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Tail recurse for the last iteration. 356182299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(*UI, Found, Visited); 35629c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 35639c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 35649530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqEnd - Given a chained node that is part of a call sequence, 356516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_END node that terminates the call sequence. 35669530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqEnd(SDNode *Node) { 356716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 35689c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner return Node; 3569f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (Node->use_empty()) 35709530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return 0; // No CallSeqEnd 35719c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 3572c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner // The chain is usually at the end. 35739c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand TheChain(Node, Node->getNumValues()-1); 3574c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner if (TheChain.getValueType() != MVT::Other) { 3575c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner // Sometimes it's at the beginning. 35762789bde57f4245f4418a2d8d54e7f372b71f0a7dChris Lattner TheChain = SDOperand(Node, 0); 3577c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner if (TheChain.getValueType() != MVT::Other) { 3578c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner // Otherwise, hunt for it. 3579c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner for (unsigned i = 1, e = Node->getNumValues(); i != e; ++i) 3580c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner if (Node->getValueType(i) == MVT::Other) { 3581c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner TheChain = SDOperand(Node, i); 3582c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner break; 3583c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner } 3584c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner 3585c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner // Otherwise, we walked into a node without a chain. 3586c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner if (TheChain.getValueType() != MVT::Other) 3587c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner return 0; 3588c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner } 3589c0ab5226cc92b8d33104374a21896b8331f3fee1Chris Lattner } 3590edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3591edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman for (SDNode::use_iterator UI = Node->use_begin(), 35922f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner E = Node->use_end(); UI != E; ++UI) { 3593edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 35949c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner // Make sure to only follow users of our token chain. 35959c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *User = *UI; 35969c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 35979c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner if (User->getOperand(i) == TheChain) 3598eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner if (SDNode *Result = FindCallSeqEnd(User)) 3599eb516e7f0aa3223eab7967f4c0f8132d82efd841Chris Lattner return Result; 36009c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner } 36012f4eca30d11d634ac2a26eed4d80f8bc9584a4b3Chris Lattner return 0; 36029c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 36039c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 36049530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner/// FindCallSeqStart - Given a chained node that is part of a call sequence, 360516cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner/// find the CALLSEQ_START node that initiates the call sequence. 36069530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattnerstatic SDNode *FindCallSeqStart(SDNode *Node) { 36079530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(Node && "Didn't find callseq_start for a call??"); 360816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 36090d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 36100d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 36110d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner "Node doesn't have a token chain argument!"); 36129530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return FindCallSeqStart(Node->getOperand(0).Val); 36130d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 36140d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 36150d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 36169c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// FindInputOutputChains - If we are replacing an operation with a call we need 36179c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner/// to find the call that occurs before and the call that occurs after it to 36180d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// properly serialize the calls in the block. The returned operand is the 36190d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// input chain value for the new call (e.g. the entry node or the previous 36200d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// call), and OutChain is set to be the chain node to update to point to the 36210d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner/// end of the call chain. 36229c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnerstatic SDOperand FindInputOutputChains(SDNode *OpNode, SDNode *&OutChain, 36239c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand Entry) { 36249530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqStart = Entry.Val; 36259530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner SDNode *LatestCallSeqEnd = 0; 3626de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner std::set<SDNode*> Visited; 3627de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner FindLatestCallSeqStart(OpNode, LatestCallSeqStart, Visited); 3628de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner Visited.clear(); 36299530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner //std::cerr<<"Found node: "; LatestCallSeqStart->dump(); std::cerr <<"\n"; 3630edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 363116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // It is possible that no ISD::CALLSEQ_START was found because there is no 3632c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman // previous call in the function. LatestCallStackDown may in that case be 363316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // the entry node itself. Do not attempt to find a matching CALLSEQ_END 363416cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // unless LatestCallStackDown is an CALLSEQ_START. 36351aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman if (LatestCallSeqStart->getOpcode() == ISD::CALLSEQ_START) { 36369530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = FindCallSeqEnd(LatestCallSeqStart); 36371aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman //std::cerr<<"Found end node: "; LatestCallSeqEnd->dump(); std::cerr <<"\n"; 36381aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } else { 36399530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner LatestCallSeqEnd = Entry.Val; 36401aa1972c63fb6b940b11250f7c12bcb368026014Nate Begeman } 36419530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner assert(LatestCallSeqEnd && "NULL return from FindCallSeqEnd"); 3642edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 36430d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Finally, find the first call that this must come before, first we find the 36449530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // CallSeqEnd that ends the call. 36450d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain = 0; 364682299e70977500209c951404e354510feffb8efaChris Lattner FindEarliestCallSeqEnd(OpNode, OutChain, Visited); 3647de387ce81024f9be0ca523e9487b1aafeb95fa22Chris Lattner Visited.clear(); 36489c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 36499530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner // If we found one, translate from the adj up to the callseq_start. 36500d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain) 36519530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner OutChain = FindCallSeqStart(OutChain); 36529c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 36539530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfaChris Lattner return SDOperand(LatestCallSeqEnd, 0); 36549c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner} 36559c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 365600b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen/// SpliceCallInto - Given the result chain of a libcall (CallResult), and a 3657b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattnervoid SelectionDAGLegalize::SpliceCallInto(const SDOperand &CallResult, 3658b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SDNode *OutChain) { 36590d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Nothing to splice it into? 36600d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (OutChain == 0) return; 36610d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 36620d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(OutChain->getOperand(0).getValueType() == MVT::Other); 36630d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner //OutChain->dump(); 36640d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 36650d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Form a token factor node merging the old inval and the new inval. 36660d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InToken = DAG.getNode(ISD::TokenFactor, MVT::Other, CallResult, 36670d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->getOperand(0)); 36680d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Change the node to refer to the new token. 36690d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner OutChain->setAdjCallChain(InToken); 36700d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner} 36719c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 36729c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 367377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 367477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 367577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 367677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 367777e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize::ExpandLibCall(const char *Name, SDNode *Node, 367877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand &Hi) { 36799c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDNode *OutChain; 36809c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SDOperand InChain = FindInputOutputChains(Node, OutChain, 36819c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner DAG.getEntryNode()); 3682f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner if (InChain.Val == 0) 3683f4b457987fca50a1dc86e1a60dad2cff2b060945Chris Lattner InChain = DAG.getEntryNode(); 36849c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 368577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 368677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 368777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner MVT::ValueType ArgVT = Node->getOperand(i).getValueType(); 368877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(ArgVT); 368977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Node->getOperand(i), ArgTy)); 369077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 369177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(Name, TLI.getPointerTy()); 3692edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 36930d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 369477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(Node->getValueType(0)); 36950d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallInfo = 3696adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, false, 3697adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 36980d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 369999c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SDOperand Result; 37000d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner switch (getTypeAction(CallInfo.first.getValueType())) { 370177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner default: assert(0 && "Unknown thing"); 370277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Legal: 37039c6b4b8c3a48aa420f6499ca6c1a356f74e100f8Chris Lattner // If the result is legal, make sure that we relegalize the inserted result. 37049c6b4b8c3a48aa420f6499ca6c1a356f74e100f8Chris Lattner Result = LegalizeOp(CallInfo.first); 370599c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 370677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Promote: 370777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(0 && "Cannot promote this yet!"); 370877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case Expand: 370999c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner ExpandOp(CallInfo.first, Result, Hi); 371099c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner break; 371177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 37129c6b4b8c3a48aa420f6499ca6c1a356f74e100f8Chris Lattner 37139c6b4b8c3a48aa420f6499ca6c1a356f74e100f8Chris Lattner CallInfo.second = LegalizeOp(CallInfo.second); 371499c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner SpliceCallInto(CallInfo.second, OutChain); 371599c25b86aa85b0093f24b2394a5aa37f66294b2bChris Lattner return Result; 371677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 371777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 37189c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 371977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// ExpandIntToFP - Expand a [US]INT_TO_FP operation, assuming that the 372077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner/// destination type is legal. 372177e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerSDOperand SelectionDAGLegalize:: 372277e77a6aa0ab25a812947aed477220dd11220a18Chris LattnerExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) { 3723c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner assert(isTypeLegal(DestTy) && "Destination type is not legal!"); 372477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(getTypeAction(Source.getValueType()) == Expand && 372577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner "This is not an expansion!"); 372677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner assert(Source.getValueType() == MVT::i64 && "Only handle expand from i64!"); 372777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 37280d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (!isSigned) { 3729e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(Source.getValueType() == MVT::i64 && 3730e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner "This only works for 64-bit -> FP"); 3731e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 3732e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // incoming integer is set. To handle this, we dynamically test to see if 3733e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner // it is set, and, if so, add a fudge factor. 3734e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Lo, Hi; 3735e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner ExpandOp(Source, Lo, Hi); 3736e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 373766de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 373866de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner // signed, then adjust the result if the sign bit is set. 373966de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner SDOperand SignedConv = ExpandIntToFP(true, DestTy, 374066de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), Lo, Hi)); 374166de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 37427cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultTy(), Hi, 37437cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner DAG.getConstant(0, Hi.getValueType()), 37447cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETLT); 3745e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand Zero = getIntPtrConstant(0), Four = getIntPtrConstant(4); 3746e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 3747e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SignSet, Four, Zero); 3748383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner uint64_t FF = 0x5f800000ULL; 3749383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 3750383203b0036b8fdeef8119975fdbbd528b760adbChris Lattner static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); 3751e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 37525839bf2b3bd22689d9dd0e9de66c2dce71d130aeChris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 3753e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 3754e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner SDOperand FudgeInReg; 3755e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner if (DestTy == MVT::f32) 375652d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, 375752d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner DAG.getSrcValue(NULL)); 3758e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner else { 3759e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner assert(DestTy == MVT::f64 && "Unexpected conversion"); 37605f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), 37615f056bf4b862a7c31388a68711dd3b3ed5de2be8Chris Lattner CPIdx, DAG.getSrcValue(NULL), MVT::f32); 3762e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 3763473a99073cc29f59809a0d5dfee11f5e9e6ad2b7Chris Lattner return DAG.getNode(ISD::FADD, DestTy, SignedConv, FudgeInReg); 376477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 37650d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 3766a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 3767a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, Source.getValueType())) { 3768a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 3769a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Legal: 3770a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner case TargetLowering::Expand: 3771a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner break; // This case is handled below. 377207dffd6af673c73352150583150b242a93694f00Chris Lattner case TargetLowering::Custom: { 377307dffd6af673c73352150583150b242a93694f00Chris Lattner SDOperand NV = TLI.LowerOperation(DAG.getNode(ISD::SINT_TO_FP, DestTy, 377407dffd6af673c73352150583150b242a93694f00Chris Lattner Source), DAG); 377507dffd6af673c73352150583150b242a93694f00Chris Lattner if (NV.Val) 377607dffd6af673c73352150583150b242a93694f00Chris Lattner return LegalizeOp(NV); 377707dffd6af673c73352150583150b242a93694f00Chris Lattner break; // The target decided this was legal after all 377807dffd6af673c73352150583150b242a93694f00Chris Lattner } 3779a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 3780a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 378113689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // Expand the source, then glue it back together for the call. We must expand 378213689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner // the source in case it is shared (this pass of legalize must traverse it). 378313689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner SDOperand SrcLo, SrcHi; 378413689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner ExpandOp(Source, SrcLo, SrcHi); 378513689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner Source = DAG.getNode(ISD::BUILD_PAIR, Source.getValueType(), SrcLo, SrcHi); 378613689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 37870d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDNode *OutChain = 0; 37880d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner SDOperand InChain = FindInputOutputChains(Source.Val, OutChain, 37890d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner DAG.getEntryNode()); 37900d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner const char *FnName = 0; 37910d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner if (DestTy == MVT::f32) 37920d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdisf"; 37930d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner else { 37940d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner assert(DestTy == MVT::f64 && "Unknown fp value type!"); 37950d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner FnName = "__floatdidf"; 37960d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 37970d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 379877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner SDOperand Callee = DAG.getExternalSymbol(FnName, TLI.getPointerTy()); 379977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 380077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 380177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *ArgTy = MVT::getTypeForValueType(Source.getValueType()); 380244d105b7faf5672a2af61a3f0fdfed0d437d5777Chris Lattner 380377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Args.push_back(std::make_pair(Source, ArgTy)); 380477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 380577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // We don't care about token chains for libcalls. We just use the entry 380677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // node as our input and ignore the output chain. This allows us to place 380777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner // calls wherever we need them to satisfy data dependences. 380877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner const Type *RetTy = MVT::getTypeForValueType(DestTy); 38090d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 38100d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner std::pair<SDOperand,SDOperand> CallResult = 3811adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(InChain, RetTy, false, CallingConv::C, true, 3812adf6a965a321372c640845407195594835921eb4Chris Lattner Callee, Args, DAG); 38130d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 3814b9fa3bc8f39bf1e8df48b85eae4563032dd20bfcChris Lattner SpliceCallInto(CallResult.second, OutChain); 38150d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner return CallResult.first; 381677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 3817edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3818e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 3819e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 38203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandOp - Expand the specified SDOperand into its two component pieces 38213e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo&Hi. Note that the Op MUST be an expanded type. As a result of this, the 38223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// LegalizeNodes map is filled in for any results that are not expanded, the 38233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// ExpandedNodes map is filled in for any results that are expanded, and the 38243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// Lo/Hi values are returned. 38253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){ 38263e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner MVT::ValueType VT = Op.getValueType(); 382771c42a0190300a8903aaea80467b88f15f327ea9Chris Lattner MVT::ValueType NVT = TLI.getTypeToTransformTo(VT); 38283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDNode *Node = Op.Val; 38293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(getTypeAction(VT) == Expand && "Not an expanded type!"); 3830ab48be377298bd509427a29e174cf4e305138819Nate Begeman assert((MVT::isInteger(VT) || VT == MVT::Vector) && 3831ab48be377298bd509427a29e174cf4e305138819Nate Begeman "Cannot expand FP values!"); 3832ab48be377298bd509427a29e174cf4e305138819Nate Begeman assert(((MVT::isInteger(NVT) && NVT < VT) || VT == MVT::Vector) && 38333e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Cannot expand to FP value or to larger int value!"); 38343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 38356fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner // See if we already expanded it. 38366fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner std::map<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I 38376fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner = ExpandedNodes.find(Op); 38386fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner if (I != ExpandedNodes.end()) { 38396fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Lo = I->second.first; 38406fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner Hi = I->second.second; 38416fdcb250d5692235813b30274cdfcd0e76377f00Chris Lattner return; 38423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 38433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 38444e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // Expanding to multiple registers needs to perform an optimization step, and 38454e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // is not careful to avoid operations the target does not support. Make sure 38464e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // that all generated operations are legalized in the next iteration. 38474e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner NeedsAnotherIteration = true; 38483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 38493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 3850348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner case ISD::CopyFromReg: 3851348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner assert(0 && "CopyFromReg must be legal!"); 3852348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner default: 38533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::cerr << "NODE: "; Node->dump(); std::cerr << "\n"; 38543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to expand this operator!"); 38553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 3856fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: 3857fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Lo = DAG.getNode(ISD::UNDEF, NVT); 3858fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Hi = DAG.getNode(ISD::UNDEF, NVT); 3859fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 38603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::Constant: { 38613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner uint64_t Cst = cast<ConstantSDNode>(Node)->getValue(); 38623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getConstant(Cst, NVT); 38633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT); 38643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 38653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3866cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman case ISD::ConstantVec: { 3867cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman unsigned NumElements = Node->getNumOperands(); 3868cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // If we only have two elements left in the constant vector, just break it 3869cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // apart into the two scalar constants it contains. Otherwise, bisect the 3870cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // ConstantVec, and return each half as a new ConstantVec. 3871cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // FIXME: this is hard coded as big endian, it may have to change to support 3872cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // SSE and Alpha MVI 3873cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman if (NumElements == 2) { 3874cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Hi = Node->getOperand(0); 3875cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Lo = Node->getOperand(1); 3876cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } else { 3877cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman NumElements /= 2; 3878cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman std::vector<SDOperand> LoOps, HiOps; 3879cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman for (unsigned I = 0, E = NumElements; I < E; ++I) { 3880cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman HiOps.push_back(Node->getOperand(I)); 3881cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman LoOps.push_back(Node->getOperand(I+NumElements)); 3882cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 3883cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Lo = DAG.getNode(ISD::ConstantVec, MVT::Vector, LoOps); 3884cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman Hi = DAG.getNode(ISD::ConstantVec, MVT::Vector, HiOps); 3885cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 3886cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman break; 3887cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 38883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3889d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner case ISD::BUILD_PAIR: 3890d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // Legalize both operands. FIXME: in the future we should handle the case 3891d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner // where the two elements are not legal. 3892d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner assert(isTypeLegal(NVT) && "Cannot expand this multiple times yet!"); 3893d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Lo = LegalizeOp(Node->getOperand(0)); 3894d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner Hi = LegalizeOp(Node->getOperand(1)); 3895d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner break; 389658f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner 389758f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner case ISD::SIGN_EXTEND_INREG: 389858f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 389958f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner // Sign extend the lo-part. 390058f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, 390158f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner DAG.getConstant(MVT::getSizeInBits(NVT)-1, 390258f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner TLI.getShiftAmountTy())); 390358f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner // sext_inreg the low part if needed. 390458f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Lo, Node->getOperand(1)); 390558f7963b8b3cb8894623a7d7663cc54005fea8f9Chris Lattner break; 3906d4e50bb2e23b8f9ddde629a28dab3bcdaf0633e4Chris Lattner 3907d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case ISD::BSWAP: { 3908d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman ExpandOp(Node->getOperand(0), Lo, Hi); 3909d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman SDOperand TempLo = DAG.getNode(ISD::BSWAP, NVT, Hi); 3910d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Hi = DAG.getNode(ISD::BSWAP, NVT, Lo); 3911d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Lo = TempLo; 3912d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman break; 3913d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman } 3914d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman 3915edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner case ISD::CTPOP: 3916edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 39179b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner Lo = DAG.getNode(ISD::ADD, NVT, // ctpop(HL) -> ctpop(H)+ctpop(L) 39189b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Lo), 39199b583b49103f21888ac3de3f7941a98a63a23aeaChris Lattner DAG.getNode(ISD::CTPOP, NVT, Hi)); 3920edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner Hi = DAG.getConstant(0, NVT); 3921edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner break; 3922edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 392339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTLZ: { 392439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // ctlz (HL) -> ctlz(H) != 32 ? ctlz(H) : (ctlz(L)+32) 39253becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 392639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 392739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 39287cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand TopNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), HLZ, BitsC, 39297cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 393039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LowPart = DAG.getNode(ISD::CTLZ, NVT, Lo); 393139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner LowPart = DAG.getNode(ISD::ADD, NVT, LowPart, BitsC); 393239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 393339a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, TopNotZero, HLZ, LowPart); 393439a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 393539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 393639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 393739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 393839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner case ISD::CTTZ: { 393939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner // cttz (HL) -> cttz(L) != 32 ? cttz(L) : (cttz(H)+32) 39403becf2026bec881a60cbbe0031d8c51f4d6d4e28Chris Lattner ExpandOp(Node->getOperand(0), Lo, Hi); 394139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand BitsC = DAG.getConstant(MVT::getSizeInBits(NVT), NVT); 394239a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand LTZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 39437cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner SDOperand BotNotZero = DAG.getSetCC(TLI.getSetCCResultTy(), LTZ, BitsC, 39447cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETNE); 394539a8f336305a492fc6d2625f39f08968185616d2Chris Lattner SDOperand HiPart = DAG.getNode(ISD::CTTZ, NVT, Hi); 394639a8f336305a492fc6d2625f39f08968185616d2Chris Lattner HiPart = DAG.getNode(ISD::ADD, NVT, HiPart, BitsC); 394739a8f336305a492fc6d2625f39f08968185616d2Chris Lattner 394839a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, BotNotZero, LTZ, HiPart); 394939a8f336305a492fc6d2625f39f08968185616d2Chris Lattner Hi = DAG.getConstant(0, NVT); 395039a8f336305a492fc6d2625f39f08968185616d2Chris Lattner break; 395139a8f336305a492fc6d2625f39f08968185616d2Chris Lattner } 3952edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 3953acc398c195a697795bff3245943d104eb19192b9Nate Begeman case ISD::VAARG: { 3954acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3955acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 3956acc398c195a697795bff3245943d104eb19192b9Nate Begeman Lo = DAG.getVAArg(NVT, Ch, Ptr, Node->getOperand(2)); 3957acc398c195a697795bff3245943d104eb19192b9Nate Begeman Hi = DAG.getVAArg(NVT, Lo.getValue(1), Ptr, Node->getOperand(2)); 3958acc398c195a697795bff3245943d104eb19192b9Nate Begeman 3959acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Remember that we legalized the chain. 3960acc398c195a697795bff3245943d104eb19192b9Nate Begeman AddLegalizedOperand(Op.getValue(1), Hi.getValue(1)); 3961acc398c195a697795bff3245943d104eb19192b9Nate Begeman if (!TLI.isLittleEndian()) 3962acc398c195a697795bff3245943d104eb19192b9Nate Begeman std::swap(Lo, Hi); 3963acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3964acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 3965acc398c195a697795bff3245943d104eb19192b9Nate Begeman 39663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::LOAD: { 39673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 39683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 39692d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Lo = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 39703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 39713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Increment the pointer to the other half. 397238d6be5d49e61e4be9bb12ee3cedf2a4fcddb8f3Chris Lattner unsigned IncrementSize = MVT::getSizeInBits(Lo.getValueType())/8; 39733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 39743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner getIntPtrConstant(IncrementSize)); 397500b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen //Is this safe? declaring that the two parts of the split load 39762d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth //are from the same instruction? 39772d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth Hi = DAG.getLoad(NVT, Ch, Ptr, Node->getOperand(2)); 3978ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner 3979ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // Build a factor node to remember that this load is independent of the 3980ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner // other one. 3981ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 3982ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner Hi.getValue(1)); 3983edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 39843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remember that we legalized the chain. 3985ec39a45bdb1eca0cfe77be6a05cc43e16f2338ebChris Lattner AddLegalizedOperand(Op.getValue(1), TF); 39863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner if (!TLI.isLittleEndian()) 39873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner std::swap(Lo, Hi); 39883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 39893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 3990ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VLOAD: { 3991ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand Ch = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3992ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 3993ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElements =cast<ConstantSDNode>(Node->getOperand(2))->getValue(); 3994ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 3995ab48be377298bd509427a29e174cf4e305138819Nate Begeman 3996ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If we only have two elements, turn into a pair of scalar loads. 3997ab48be377298bd509427a29e174cf4e305138819Nate Begeman // FIXME: handle case where a vector of two elements is fine, such as 3998ab48be377298bd509427a29e174cf4e305138819Nate Begeman // 2 x double on SSE2. 3999ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (NumElements == 2) { 4000ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getLoad(EVT, Ch, Ptr, Node->getOperand(4)); 4001ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Increment the pointer to the other half. 4002ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize = MVT::getSizeInBits(EVT)/8; 4003ab48be377298bd509427a29e174cf4e305138819Nate Begeman Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 4004ab48be377298bd509427a29e174cf4e305138819Nate Begeman getIntPtrConstant(IncrementSize)); 4005ab48be377298bd509427a29e174cf4e305138819Nate Begeman //Is this safe? declaring that the two parts of the split load 4006ab48be377298bd509427a29e174cf4e305138819Nate Begeman //are from the same instruction? 4007ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getLoad(EVT, Ch, Ptr, Node->getOperand(4)); 4008ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 4009ab48be377298bd509427a29e174cf4e305138819Nate Begeman NumElements /= 2; // Split the vector in half 4010ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getVecLoad(NumElements, EVT, Ch, Ptr, Node->getOperand(4)); 4011ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned IncrementSize = NumElements * MVT::getSizeInBits(EVT)/8; 4012ab48be377298bd509427a29e174cf4e305138819Nate Begeman Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 4013ab48be377298bd509427a29e174cf4e305138819Nate Begeman getIntPtrConstant(IncrementSize)); 4014ab48be377298bd509427a29e174cf4e305138819Nate Begeman //Is this safe? declaring that the two parts of the split load 4015ab48be377298bd509427a29e174cf4e305138819Nate Begeman //are from the same instruction? 4016ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getVecLoad(NumElements, EVT, Ch, Ptr, Node->getOperand(4)); 4017ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 4018ab48be377298bd509427a29e174cf4e305138819Nate Begeman 4019ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Build a factor node to remember that this load is independent of the 4020ab48be377298bd509427a29e174cf4e305138819Nate Begeman // other one. 4021ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand TF = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 4022ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi.getValue(1)); 4023ab48be377298bd509427a29e174cf4e305138819Nate Begeman 4024ab48be377298bd509427a29e174cf4e305138819Nate Begeman // Remember that we legalized the chain. 4025ab48be377298bd509427a29e174cf4e305138819Nate Begeman AddLegalizedOperand(Op.getValue(1), TF); 4026ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (!TLI.isLittleEndian()) 4027ab48be377298bd509427a29e174cf4e305138819Nate Begeman std::swap(Lo, Hi); 4028ab48be377298bd509427a29e174cf4e305138819Nate Begeman break; 4029ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 4030ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VADD: 4031ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VSUB: 4032ab48be377298bd509427a29e174cf4e305138819Nate Begeman case ISD::VMUL: { 4033ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned NumElements =cast<ConstantSDNode>(Node->getOperand(2))->getValue(); 4034ab48be377298bd509427a29e174cf4e305138819Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 4035ab48be377298bd509427a29e174cf4e305138819Nate Begeman SDOperand LL, LH, RL, RH; 4036ab48be377298bd509427a29e174cf4e305138819Nate Begeman 4037ab48be377298bd509427a29e174cf4e305138819Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 4038ab48be377298bd509427a29e174cf4e305138819Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 4039ab48be377298bd509427a29e174cf4e305138819Nate Begeman 4040ab48be377298bd509427a29e174cf4e305138819Nate Begeman // If we only have two elements, turn into a pair of scalar loads. 4041ab48be377298bd509427a29e174cf4e305138819Nate Begeman // FIXME: handle case where a vector of two elements is fine, such as 4042ab48be377298bd509427a29e174cf4e305138819Nate Begeman // 2 x double on SSE2. 4043ab48be377298bd509427a29e174cf4e305138819Nate Begeman if (NumElements == 2) { 4044ab48be377298bd509427a29e174cf4e305138819Nate Begeman unsigned Opc = getScalarizedOpcode(Node->getOpcode(), EVT); 4045ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getNode(Opc, EVT, LL, RL); 4046ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getNode(Opc, EVT, LH, RH); 4047ab48be377298bd509427a29e174cf4e305138819Nate Begeman } else { 4048ab48be377298bd509427a29e174cf4e305138819Nate Begeman Lo = DAG.getNode(Node->getOpcode(), MVT::Vector, LL, RL, LL.getOperand(2), 4049ab48be377298bd509427a29e174cf4e305138819Nate Begeman LL.getOperand(3)); 4050ab48be377298bd509427a29e174cf4e305138819Nate Begeman Hi = DAG.getNode(Node->getOpcode(), MVT::Vector, LH, RH, LH.getOperand(2), 4051ab48be377298bd509427a29e174cf4e305138819Nate Begeman LH.getOperand(3)); 4052ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 4053ab48be377298bd509427a29e174cf4e305138819Nate Begeman break; 4054ab48be377298bd509427a29e174cf4e305138819Nate Begeman } 40553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 40563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 40573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: { // Simple logical operators -> two trivial pieces. 40583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand LL, LH, RL, RH; 40593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(0), LL, LH); 40603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), RL, RH); 40613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(Node->getOpcode(), NVT, LL, RL); 40623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(Node->getOpcode(), NVT, LH, RH); 40633e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 40643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 40653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SELECT: { 40663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SDOperand C, LL, LH, RL, RH; 406747e9223e06390897c3834f8c527001df392570ffChris Lattner 406847e9223e06390897c3834f8c527001df392570ffChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 406947e9223e06390897c3834f8c527001df392570ffChris Lattner case Expand: assert(0 && "It's impossible to expand bools"); 407047e9223e06390897c3834f8c527001df392570ffChris Lattner case Legal: 407147e9223e06390897c3834f8c527001df392570ffChris Lattner C = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 407247e9223e06390897c3834f8c527001df392570ffChris Lattner break; 407347e9223e06390897c3834f8c527001df392570ffChris Lattner case Promote: 407447e9223e06390897c3834f8c527001df392570ffChris Lattner C = PromoteOp(Node->getOperand(0)); // Promote the condition. 407547e9223e06390897c3834f8c527001df392570ffChris Lattner break; 407647e9223e06390897c3834f8c527001df392570ffChris Lattner } 40773e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(1), LL, LH); 40783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ExpandOp(Node->getOperand(2), RL, RH); 40793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Lo = DAG.getNode(ISD::SELECT, NVT, C, LL, RL); 40803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getNode(ISD::SELECT, NVT, C, LH, RH); 40813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 40823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 40839373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case ISD::SELECT_CC: { 40849373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SDOperand TL, TH, FL, FH; 40859373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(2), TL, TH); 40869373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman ExpandOp(Node->getOperand(3), FL, FH); 40879373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Lo = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 40889373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TL, FL, Node->getOperand(4)); 40899373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Hi = DAG.getNode(ISD::SELECT_CC, NVT, Node->getOperand(0), 40909373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Node->getOperand(1), TH, FH, Node->getOperand(4)); 4091e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Lo = LegalizeOp(Lo); 4092e5d63829fd62d815a330c21ea316e6b4cf943562Nate Begeman Hi = LegalizeOp(Hi); 40939373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 40949373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 4095144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::SEXTLOAD: { 4096144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 4097144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 4098144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 4099144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 4100144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 4101144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 4102144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 4103144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::SEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 4104144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 41059ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 41069ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 41079ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 41089ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 4109144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is obtained by SRA'ing all but one of the bits of the lo 4110144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // part. 4111144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 4112144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 4113144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman TLI.getShiftAmountTy())); 4114144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 4115144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Hi = LegalizeOp(Hi); 4116144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 4117144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 4118144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman case ISD::ZEXTLOAD: { 4119144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Chain = LegalizeOp(Node->getOperand(0)); 4120144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 4121144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 4122144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman 4123144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman if (EVT == NVT) 4124144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 4125144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman else 4126144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 4127144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman EVT); 41289ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 41299ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 41309ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 41319ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 4132144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman // The high part is just a zero. 41339ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getConstant(0, NVT)); 41349ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = LegalizeOp(Lo); 41359ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner break; 41369ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner } 41379ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner case ISD::EXTLOAD: { 41389ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Chain = LegalizeOp(Node->getOperand(0)); 41399ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner SDOperand Ptr = LegalizeOp(Node->getOperand(1)); 41409ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner MVT::ValueType EVT = cast<VTSDNode>(Node->getOperand(3))->getVT(); 41419ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 41429ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner if (EVT == NVT) 41439ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getLoad(NVT, Chain, Ptr, Node->getOperand(2)); 41449ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner else 41459ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Lo = DAG.getExtLoad(ISD::EXTLOAD, NVT, Chain, Ptr, Node->getOperand(2), 41469ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner EVT); 41479ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 41489ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // Remember that we legalized the chain. 41499ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), Lo.getValue(1)); 41509ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner 41519ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner // The high part is undefined. 41529ad8481cfbbb9dfe451b771978098677bc8dd254Chris Lattner Hi = LegalizeOp(DAG.getNode(ISD::UNDEF, NVT)); 4153144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman Lo = LegalizeOp(Lo); 4154144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman break; 4155144ff660e66845a575586bc4092c0cf349b5bfb9Nate Begeman } 415613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: { 415713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner SDOperand In; 415813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 415913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 416013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 416113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case Promote: 416213c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner In = PromoteOp(Node->getOperand(0)); 416313c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 416413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 416513c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner 416613c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The low part is any extension of the input (which degenerates to a copy). 416713c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Lo = DAG.getNode(ISD::ANY_EXTEND, NVT, In); 416813c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner // The high part is undefined. 416913c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); 417013c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner break; 417113c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner } 41723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: { 417306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 417406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 417506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 417606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 417706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 417806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 417906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate sign_extend_inreg to get the value we want. 418006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), In, 418115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner DAG.getValueType(Node->getOperand(0).getValueType())); 418206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 418306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 418406098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 41853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a sign extension of the input (which degenerates to 41863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 418706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, In); 4188edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 41893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is obtained by SRA'ing all but one of the bits of the lo 41903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // part. 41912dad454af674cb41a14a85ad6ce5c85c43959acdChris Lattner unsigned LoSize = MVT::getSizeInBits(Lo.getValueType()); 419227ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, DAG.getConstant(LoSize-1, 419327ff112948d059524e5f4ebe249a1da0b7c710e8Chris Lattner TLI.getShiftAmountTy())); 41943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 41953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 419606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case ISD::ZERO_EXTEND: { 419706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner SDOperand In; 419806098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 419906098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Expand: assert(0 && "expand-expand not implemented yet!"); 420006098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Legal: In = LegalizeOp(Node->getOperand(0)); break; 420106098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner case Promote: 420206098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner In = PromoteOp(Node->getOperand(0)); 420306098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner // Emit the appropriate zero_extend_inreg to get the value we want. 420423993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner In = DAG.getZeroExtendInReg(In, Node->getOperand(0).getValueType()); 420506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner break; 420606098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 420706098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner 42083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The low part is just a zero extension of the input (which degenerates to 42093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // a copy). 4210dea29e25c32d2651e2efaff67bc30803ea24d991Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, In); 4211edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 42123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // The high part is just a zero. 42133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Hi = DAG.getConstant(0, NVT); 42143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 421506098e0e9bd542f227aa3802768d1416e79e9f45Chris Lattner } 421635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 421735481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case ISD::BIT_CONVERT: { 421835481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner SDOperand Tmp = ExpandBIT_CONVERT(Node->getValueType(0), 421935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner Node->getOperand(0)); 422035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner ExpandOp(Tmp, Lo, Hi); 422135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 422235481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner } 4223f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 4224308575be66ec3870d27b19df044fda18448feb41Chris Lattner case ISD::READCYCLECOUNTER: { 4225308575be66ec3870d27b19df044fda18448feb41Chris Lattner assert(TLI.getOperationAction(ISD::READCYCLECOUNTER, VT) == 4226308575be66ec3870d27b19df044fda18448feb41Chris Lattner TargetLowering::Custom && 4227308575be66ec3870d27b19df044fda18448feb41Chris Lattner "Must custom expand ReadCycleCounter"); 4228308575be66ec3870d27b19df044fda18448feb41Chris Lattner SDOperand T = TLI.LowerOperation(Op, DAG); 4229308575be66ec3870d27b19df044fda18448feb41Chris Lattner assert(T.Val && "Node must be custom expanded!"); 4230308575be66ec3870d27b19df044fda18448feb41Chris Lattner Lo = LegalizeOp(T.getValue(0)); 4231308575be66ec3870d27b19df044fda18448feb41Chris Lattner Hi = LegalizeOp(T.getValue(1)); 4232308575be66ec3870d27b19df044fda18448feb41Chris Lattner AddLegalizedOperand(SDOperand(Node, 1), // Remember we legalized the chain. 4233308575be66ec3870d27b19df044fda18448feb41Chris Lattner LegalizeOp(T.getValue(2))); 4234f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth break; 4235308575be66ec3870d27b19df044fda18448feb41Chris Lattner } 4236f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 42374e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // These operators cannot be expanded directly, emit them as calls to 42384e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner // library functions. 42394e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_SINT: 424080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_SINT, VT) == TargetLowering::Custom) { 4241f20d183c2268553c738fefb014959ea924dd0555Chris Lattner SDOperand Op; 4242f20d183c2268553c738fefb014959ea924dd0555Chris Lattner switch (getTypeAction(Node->getOperand(0).getValueType())) { 4243f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Expand: assert(0 && "cannot expand FP!"); 4244f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Legal: Op = LegalizeOp(Node->getOperand(0)); break; 4245f20d183c2268553c738fefb014959ea924dd0555Chris Lattner case Promote: Op = PromoteOp(Node->getOperand(0)); break; 4246f20d183c2268553c738fefb014959ea924dd0555Chris Lattner } 4247d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 4248f20d183c2268553c738fefb014959ea924dd0555Chris Lattner Op = TLI.LowerOperation(DAG.getNode(ISD::FP_TO_SINT, VT, Op), DAG); 4249f20d183c2268553c738fefb014959ea924dd0555Chris Lattner 425080a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 425180a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 425207dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 425307dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 425407dffd6af673c73352150583150b242a93694f00Chris Lattner break; 425507dffd6af673c73352150583150b242a93694f00Chris Lattner } 425680a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 4257d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 42584e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 425977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixsfdi", Node, Hi); 42604e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 426177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixdfdi", Node, Hi); 42624e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 4263d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 42644e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner case ISD::FP_TO_UINT: 426580a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner if (TLI.getOperationAction(ISD::FP_TO_UINT, VT) == TargetLowering::Custom) { 426680a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner SDOperand Op = DAG.getNode(ISD::FP_TO_UINT, VT, 426780a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner LegalizeOp(Node->getOperand(0))); 426880a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // Now that the custom expander is done, expand the result, which is still 426980a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner // VT. 427007dffd6af673c73352150583150b242a93694f00Chris Lattner Op = TLI.LowerOperation(Op, DAG); 427107dffd6af673c73352150583150b242a93694f00Chris Lattner if (Op.Val) { 427207dffd6af673c73352150583150b242a93694f00Chris Lattner ExpandOp(Op, Lo, Hi); 427307dffd6af673c73352150583150b242a93694f00Chris Lattner break; 427407dffd6af673c73352150583150b242a93694f00Chris Lattner } 427580a3e94653574c69ac805d9684a23a94ed3e4b5dChris Lattner } 4276d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 42774e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner if (Node->getOperand(0).getValueType() == MVT::f32) 427877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunssfdi", Node, Hi); 42794e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner else 428077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__fixunsdfdi", Node, Hi); 42814e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner break; 42824e6c74689944be1de80c99dc0688ec0bcbd743aaChris Lattner 428305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng case ISD::SHL: { 428450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 4285348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner SDOperand ShiftAmt = LegalizeOp(Node->getOperand(1)); 428650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SHL, VT) == TargetLowering::Custom) { 428750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SHL, VT, Node->getOperand(0), 4288348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner ShiftAmt); 428950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 429050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 429150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 429250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 429350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 429450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 429550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 429650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 429750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 4298e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 4299348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner if (ExpandShift(ISD::SHL, Node->getOperand(0), ShiftAmt, Lo, Hi)) 4300e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 43014759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 43024759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SHL_PARTS, use it. 430305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TargetLowering::LegalizeAction Action = 430405a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TLI.getOperationAction(ISD::SHL_PARTS, NVT); 430505a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) || 430605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Action == TargetLowering::Custom) { 4307348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner ExpandShiftParts(ISD::SHL_PARTS, Node->getOperand(0), ShiftAmt, Lo, Hi); 43084759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 43094759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 43104759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 4311e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 431277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashldi3", Node, Hi); 4313e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 431405a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 4315e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 431605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng case ISD::SRA: { 431750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 4318348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner SDOperand ShiftAmt = LegalizeOp(Node->getOperand(1)); 431950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRA, VT) == TargetLowering::Custom) { 432050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRA, VT, Node->getOperand(0), 4321348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner ShiftAmt); 432250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 432350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 432450ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 432550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 432650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 432750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 432850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 432950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 433050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 4331e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 4332348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner if (ExpandShift(ISD::SRA, Node->getOperand(0), ShiftAmt, Lo, Hi)) 4333e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 43344759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 43354759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRA_PARTS, use it. 433605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TargetLowering::LegalizeAction Action = 433705a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TLI.getOperationAction(ISD::SRA_PARTS, NVT); 433805a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) || 433905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Action == TargetLowering::Custom) { 4340348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner ExpandShiftParts(ISD::SRA_PARTS, Node->getOperand(0), ShiftAmt, Lo, Hi); 43414759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 43424759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 43434759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 4344e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 434577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__ashrdi3", Node, Hi); 4346e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 434705a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 434805a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng 434905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng case ISD::SRL: { 435050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // If the target wants custom lowering, do so. 4351348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner SDOperand ShiftAmt = LegalizeOp(Node->getOperand(1)); 435250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (TLI.getOperationAction(ISD::SRL, VT) == TargetLowering::Custom) { 435350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner SDOperand Op = DAG.getNode(ISD::SRL, VT, Node->getOperand(0), 4354348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner ShiftAmt); 435550ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner Op = TLI.LowerOperation(Op, DAG); 435650ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner if (Op.Val) { 435750ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // Now that the custom expander is done, expand the result, which is 435850ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner // still VT. 435950ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner ExpandOp(Op, Lo, Hi); 436050ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner break; 436150ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 436250ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner } 436350ec8979047065bd0ff41fac4ffd44f744b77723Chris Lattner 4364e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // If we can emit an efficient shift operation, do so now. 4365348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner if (ExpandShift(ISD::SRL, Node->getOperand(0), ShiftAmt, Lo, Hi)) 4366e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 43674759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 43684759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner // If this target supports SRL_PARTS, use it. 436905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TargetLowering::LegalizeAction Action = 437005a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng TLI.getOperationAction(ISD::SRL_PARTS, NVT); 437105a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) || 437205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Action == TargetLowering::Custom) { 4373348e93c8f7132c6ecbaf5866048e087feb7520e2Chris Lattner ExpandShiftParts(ISD::SRL_PARTS, Node->getOperand(0), ShiftAmt, Lo, Hi); 43744759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner break; 43754759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner } 43764759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner 4377e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner // Otherwise, emit a libcall. 437877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner Lo = ExpandLibCall("__lshrdi3", Node, Hi); 4379e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner break; 438005a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 4381e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 4382edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman case ISD::ADD: 43834759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::ADD_PARTS, Node->getOperand(0), Node->getOperand(1), 43844759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 438584f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 438684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner case ISD::SUB: 43874759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner ExpandByParts(ISD::SUB_PARTS, Node->getOperand(0), Node->getOperand(1), 43884759982a2d4ab597fb69d4a1113d0f35e673a4e1Chris Lattner Lo, Hi); 438984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner break; 4390c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MUL: { 4391c9c60f6429416d362c2131b14d097ce0a9ac9599Chris Lattner if (TLI.isOperationLegal(ISD::MULHU, NVT)) { 4392c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman SDOperand LL, LH, RL, RH; 4393c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(0), LL, LH); 4394c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman ExpandOp(Node->getOperand(1), RL, RH); 439556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman unsigned SH = MVT::getSizeInBits(RH.getValueType())-1; 439656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // MULHS implicitly sign extends its inputs. Check to see if ExpandOp 439756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // extended the sign bit of the low half through the upper half, and if so 439856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // emit a MULHS instead of the alternate sequence that is valid for any 439956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // i64 x i64 multiply. 440056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman if (TLI.isOperationLegal(ISD::MULHS, NVT) && 440156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is RH an extension of the sign bit of RL? 440256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOpcode() == ISD::SRA && RH.getOperand(0) == RL && 440356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH.getOperand(1).getOpcode() == ISD::Constant && 440456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(RH.getOperand(1))->getValue() == SH && 440556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman // is LH an extension of the sign bit of LL? 440656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOpcode() == ISD::SRA && LH.getOperand(0) == LL && 440756eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH.getOperand(1).getOpcode() == ISD::Constant && 440856eb86806d5d178d42108f17d11098b3e640b996Nate Begeman cast<ConstantSDNode>(LH.getOperand(1))->getValue() == SH) { 440956eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHS, NVT, LL, RL); 441056eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } else { 441156eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 441256eb86806d5d178d42108f17d11098b3e640b996Nate Begeman RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 441356eb86806d5d178d42108f17d11098b3e640b996Nate Begeman LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 441456eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 441556eb86806d5d178d42108f17d11098b3e640b996Nate Begeman Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 441656eb86806d5d178d42108f17d11098b3e640b996Nate Begeman } 4417c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 4418c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } else { 44199c6b4b8c3a48aa420f6499ca6c1a356f74e100f8Chris Lattner Lo = ExpandLibCall("__muldi3" , Node, Hi); 4420c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 4421c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman break; 4422c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman } 442377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SDIV: Lo = ExpandLibCall("__divdi3" , Node, Hi); break; 442477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UDIV: Lo = ExpandLibCall("__udivdi3", Node, Hi); break; 442577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::SREM: Lo = ExpandLibCall("__moddi3" , Node, Hi); break; 442677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner case ISD::UREM: Lo = ExpandLibCall("__umoddi3", Node, Hi); break; 44273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 44283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 442983397363348662e9352455ea1e6e88e7026300a4Chris Lattner // Make sure the resultant values have been legalized themselves, unless this 443083397363348662e9352455ea1e6e88e7026300a4Chris Lattner // is a type that requires multi-step expansion. 443183397363348662e9352455ea1e6e88e7026300a4Chris Lattner if (getTypeAction(NVT) != Expand && NVT != MVT::isVoid) { 443283397363348662e9352455ea1e6e88e7026300a4Chris Lattner Lo = LegalizeOp(Lo); 443383397363348662e9352455ea1e6e88e7026300a4Chris Lattner Hi = LegalizeOp(Hi); 443483397363348662e9352455ea1e6e88e7026300a4Chris Lattner } 443505a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng 443605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng // Remember in a map if the values will be reused later. 443705a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng bool isNew = 443805a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng ExpandedNodes.insert(std::make_pair(Op, std::make_pair(Lo, Hi))).second; 443905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng assert(isNew && "Value already expanded?!?"); 44403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 44413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 44423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 44433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 44443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 44459c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattnervoid SelectionDAG::Legalize() { 44463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 44473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 44489c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner SelectionDAGLegalize(*this).Run(); 44493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 44503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4451