LegalizeIntegerTypes.cpp revision a1ace76c70ae5332d6f33fce5c0c1e2fdb8cca11
169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands//===----- LegalizeIntegerTypes.cpp - Legalization of integer types -------===// 2cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner// 3cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner// The LLVM Compiler Infrastructure 4cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner// 8cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner//===----------------------------------------------------------------------===// 9cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner// 1069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// This file implements integer type expansion and promotion for LegalizeTypes. 1169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// Promotion is the act of changing a computation in an illegal type into a 1269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// computation in a larger type. For example, implementing i8 arithmetic in an 1369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// i32 register (often needed on powerpc). 1469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// Expansion is the act of changing a computation in an illegal type into a 1578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// computation in two identical registers of a smaller type. For example, 1669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// implementing i64 arithmetic in two i32 registers (often needed on 32-bit 1769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// targets). 18cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner// 19cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner//===----------------------------------------------------------------------===// 20cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 21cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner#include "LegalizeTypes.h" 22cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner#include "llvm/Constants.h" 23cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattnerusing namespace llvm; 24cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 25cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner//===----------------------------------------------------------------------===// 2669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// Integer Result Promotion 27cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner//===----------------------------------------------------------------------===// 28cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 2969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// PromoteIntegerResult - This method is called when a result of a node is 3069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// found to be in need of promotion to a larger type. At this point, the node 3169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// may also have invalid operands or may have other results that need 3269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// expansion, we just know that (at least) one result needs promotion. 3369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::PromoteIntegerResult(SDNode *N, unsigned ResNo) { 3469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DEBUG(cerr << "Promote integer result: "; N->dump(&DAG); cerr << "\n"); 3569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Result = SDOperand(); 3669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 3769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands switch (N->getOpcode()) { 3869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands default: 3969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands#ifndef NDEBUG 4069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands cerr << "PromoteIntegerResult #" << ResNo << ": "; 4169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->dump(&DAG); cerr << "\n"; 4269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands#endif 4369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(0 && "Do not know how to promote this operator!"); 4469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands abort(); 4569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::UNDEF: Result = PromoteIntRes_UNDEF(N); break; 4669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::Constant: Result = PromoteIntRes_Constant(N); break; 4769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 4869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::TRUNCATE: Result = PromoteIntRes_TRUNCATE(N); break; 4969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SIGN_EXTEND: 5069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ZERO_EXTEND: 5169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ANY_EXTEND: Result = PromoteIntRes_INT_EXTEND(N); break; 5269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_ROUND: Result = PromoteIntRes_FP_ROUND(N); break; 5369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_TO_SINT: 5469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_TO_UINT: Result = PromoteIntRes_FP_TO_XINT(N); break; 5569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETCC: Result = PromoteIntRes_SETCC(N); break; 5669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::LOAD: Result = PromoteIntRes_LOAD(cast<LoadSDNode>(N)); break; 5769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BUILD_PAIR: Result = PromoteIntRes_BUILD_PAIR(N); break; 5869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BIT_CONVERT: Result = PromoteIntRes_BIT_CONVERT(N); break; 5969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 6069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::AND: 6169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::OR: 6269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::XOR: 6369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ADD: 6469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SUB: 6569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::MUL: Result = PromoteIntRes_SimpleIntBinOp(N); break; 6669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 6769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SDIV: 6869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SREM: Result = PromoteIntRes_SDIV(N); break; 6969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 7069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::UDIV: 7169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::UREM: Result = PromoteIntRes_UDIV(N); break; 7269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 7369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SHL: Result = PromoteIntRes_SHL(N); break; 7469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SRA: Result = PromoteIntRes_SRA(N); break; 7569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SRL: Result = PromoteIntRes_SRL(N); break; 7669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 7769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SELECT: Result = PromoteIntRes_SELECT(N); break; 7869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SELECT_CC: Result = PromoteIntRes_SELECT_CC(N); break; 7969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 8069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::CTLZ: Result = PromoteIntRes_CTLZ(N); break; 8169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::CTPOP: Result = PromoteIntRes_CTPOP(N); break; 8269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::CTTZ: Result = PromoteIntRes_CTTZ(N); break; 8369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 8469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::EXTRACT_VECTOR_ELT: 8569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Result = PromoteIntRes_EXTRACT_VECTOR_ELT(N); 8669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 8769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 8869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 8969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If Result is null, the sub-method took care of registering the result. 9069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (Result.Val) 9169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SetPromotedInteger(SDOperand(N, ResNo), Result); 9269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 9369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 9469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_UNDEF(SDNode *N) { 9569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::UNDEF, TLI.getTypeToTransformTo(N->getValueType(0))); 9669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 9769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 9869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_Constant(SDNode *N) { 9969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = N->getValueType(0); 10069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Zero extend things like i1, sign extend everything else. It shouldn't 10169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // matter in theory which one we pick, but this tends to give better code? 10269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned Opc = VT.isByteSized() ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND; 10369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Result = DAG.getNode(Opc, TLI.getTypeToTransformTo(VT), 10469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand(N, 0)); 10569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(isa<ConstantSDNode>(Result) && "Didn't constant fold ext?"); 10669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return Result; 10769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 10869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 10969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_TRUNCATE(SDNode *N) { 11069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res; 11169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 11269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands switch (getTypeAction(N->getOperand(0).getValueType())) { 11369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands default: assert(0 && "Unknown type action!"); 11469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case Legal: 11569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ExpandInteger: 11669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = N->getOperand(0); 11769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 11869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case PromoteInteger: 11969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = GetPromotedInteger(N->getOperand(0)); 12069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 12169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 12269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 12369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 12469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(Res.getValueType().getSizeInBits() >= NVT.getSizeInBits() && 12569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands "Truncation doesn't make sense!"); 12669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (Res.getValueType() == NVT) 12769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return Res; 12869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 12969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Truncate to NVT instead of VT 13069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::TRUNCATE, NVT, Res); 13169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 13269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 13369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_INT_EXTEND(SDNode *N) { 13469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 13569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 13669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (getTypeAction(N->getOperand(0).getValueType()) == PromoteInteger) { 13769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = GetPromotedInteger(N->getOperand(0)); 13869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(Res.getValueType().getSizeInBits() <= NVT.getSizeInBits() && 13969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands "Extension doesn't make sense!"); 14069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 14169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If the result and operand types are the same after promotion, simplify 14269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // to an in-register extension. 14369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (NVT == Res.getValueType()) { 14469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The high bits are not guaranteed to be anything. Insert an extend. 14569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (N->getOpcode() == ISD::SIGN_EXTEND) 14669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Res, 14769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getValueType(N->getOperand(0).getValueType())); 14869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (N->getOpcode() == ISD::ZERO_EXTEND) 14969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getZeroExtendInReg(Res, N->getOperand(0).getValueType()); 15069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(N->getOpcode() == ISD::ANY_EXTEND && "Unknown integer extension!"); 15169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return Res; 15269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 15369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 15469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 15569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Otherwise, just extend the original operand all the way to the larger type. 15669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(N->getOpcode(), NVT, N->getOperand(0)); 15769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 15869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 15969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_FP_ROUND(SDNode *N) { 16069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // NOTE: Assumes input is legal. 16169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (N->getConstantOperandVal(1) == 0) 16269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::FP_ROUND_INREG, N->getOperand(0).getValueType(), 16369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(0), DAG.getValueType(N->getValueType(0))); 16469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If the precision discard isn't needed, just return the operand unrounded. 16569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return N->getOperand(0); 16669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 16769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 16869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_FP_TO_XINT(SDNode *N) { 16969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned NewOpc = N->getOpcode(); 17069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 17169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 17269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If we're promoting a UINT to a larger size, check to see if the new node 17369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 17469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // we can use that instead. This allows us to generate better code for 17569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 17669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // legal, such as PowerPC. 17769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (N->getOpcode() == ISD::FP_TO_UINT) { 17869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (!TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) && 17969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands (TLI.isOperationLegal(ISD::FP_TO_SINT, NVT) || 18069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands TLI.getOperationAction(ISD::FP_TO_SINT, NVT)==TargetLowering::Custom)) 18169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewOpc = ISD::FP_TO_SINT; 18269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 18369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 18469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(NewOpc, NVT, N->getOperand(0)); 18569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 18669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 18769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SETCC(SDNode *N) { 18869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(isTypeLegal(TLI.getSetCCResultType(N->getOperand(0))) 18969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands && "SetCC type is not legal??"); 19069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SETCC, TLI.getSetCCResultType(N->getOperand(0)), 19169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(0), N->getOperand(1), N->getOperand(2)); 19269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 19369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 19469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_LOAD(LoadSDNode *N) { 19569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // FIXME: Add support for indexed loads. 19669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 19769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ISD::LoadExtType ExtType = 19869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ISD::isNON_EXTLoad(N) ? ISD::EXTLOAD : N->getExtensionType(); 19969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = DAG.getExtLoad(ExtType, NVT, N->getChain(), N->getBasePtr(), 20069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getSrcValue(), N->getSrcValueOffset(), 20169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getMemoryVT(), N->isVolatile(), 20269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getAlignment()); 20369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 20469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Legalized the chain result - switch anything that used the old chain to 20569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // use the new one. 20669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ReplaceValueWith(SDOperand(N, 1), Res.getValue(1)); 20769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return Res; 20869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 20969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 21069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_BUILD_PAIR(SDNode *N) { 21169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The pair element type may be legal, or may not promote to the same type as 21269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // the result, for example i14 = BUILD_PAIR (i7, i7). Handle all cases. 21369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::ANY_EXTEND, 21469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands TLI.getTypeToTransformTo(N->getValueType(0)), 21569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands JoinIntegers(N->getOperand(0), N->getOperand(1))); 21669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 21769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 21869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_BIT_CONVERT(SDNode *N) { 21969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand InOp = N->getOperand(0); 22069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT InVT = InOp.getValueType(); 22169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NInVT = TLI.getTypeToTransformTo(InVT); 22269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OutVT = TLI.getTypeToTransformTo(N->getValueType(0)); 22369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 22469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands switch (getTypeAction(InVT)) { 22569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands default: 22669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(false && "Unknown type action!"); 22769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 22869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case Legal: 22969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 23069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case PromoteInteger: 23169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (OutVT.getSizeInBits() == NInVT.getSizeInBits()) 23269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The input promotes to the same size. Convert the promoted value. 23369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::BIT_CONVERT, OutVT, GetPromotedInteger(InOp)); 23469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 2354fc4fd657d4266059dac3849133a3a351b03d99dDuncan Sands case SoftenFloat: 23669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Promote the integer operand by hand. 2374fc4fd657d4266059dac3849133a3a351b03d99dDuncan Sands return DAG.getNode(ISD::ANY_EXTEND, OutVT, GetSoftenedFloat(InOp)); 23869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ExpandInteger: 23969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ExpandFloat: 24069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 24169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case Scalarize: 24269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Convert the element to an integer and promote it by hand. 24369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::ANY_EXTEND, OutVT, 24469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands BitConvertToInteger(GetScalarizedVector(InOp))); 24569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case Split: 24669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // For example, i32 = BIT_CONVERT v2i16 on alpha. Convert the split 24769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // pieces of the input into integers and reassemble in the final type. 24869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Lo, Hi; 24969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetSplitVector(N->getOperand(0), Lo, Hi); 25069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Lo = BitConvertToInteger(Lo); 25169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Hi = BitConvertToInteger(Hi); 25269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 25369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (TLI.isBigEndian()) 25469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands std::swap(Lo, Hi); 25569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 25669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands InOp = DAG.getNode(ISD::ANY_EXTEND, 25769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT::getIntegerVT(OutVT.getSizeInBits()), 25869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands JoinIntegers(Lo, Hi)); 25969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::BIT_CONVERT, OutVT, InOp); 26069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 26169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 26269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Otherwise, lower the bit-convert to a store/load from the stack, then 26369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // promote the load. 26469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = CreateStackStoreLoad(InOp, N->getValueType(0)); 26569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return PromoteIntRes_LOAD(cast<LoadSDNode>(Op.Val)); 26669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 26769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 26869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SimpleIntBinOp(SDNode *N) { 26969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The input may have strange things in the top bits of the registers, but 27069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // these operations don't care. They may have weird bits going out, but 27169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // that too is okay if they are integer operations. 27269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = GetPromotedInteger(N->getOperand(0)); 27369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = GetPromotedInteger(N->getOperand(1)); 27469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(N->getOpcode(), LHS.getValueType(), LHS, RHS); 27569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 27669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 27769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SDIV(SDNode *N) { 27869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Sign extend the input. 27969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = GetPromotedInteger(N->getOperand(0)); 28069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = GetPromotedInteger(N->getOperand(1)); 28169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = N->getValueType(0); 28269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands LHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, LHS.getValueType(), LHS, 28369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getValueType(VT)); 28469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands RHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, RHS.getValueType(), RHS, 28569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getValueType(VT)); 28669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 28769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(N->getOpcode(), LHS.getValueType(), LHS, RHS); 28869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 28969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 29069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_UDIV(SDNode *N) { 29169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Zero extend the input. 29269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = GetPromotedInteger(N->getOperand(0)); 29369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = GetPromotedInteger(N->getOperand(1)); 29469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = N->getValueType(0); 29569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands LHS = DAG.getZeroExtendInReg(LHS, VT); 29669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands RHS = DAG.getZeroExtendInReg(RHS, VT); 29769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 29869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(N->getOpcode(), LHS.getValueType(), LHS, RHS); 29969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 30069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 30169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SHL(SDNode *N) { 30269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SHL, TLI.getTypeToTransformTo(N->getValueType(0)), 30369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetPromotedInteger(N->getOperand(0)), N->getOperand(1)); 30469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 30569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 30669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SRA(SDNode *N) { 30769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The input value must be properly sign extended. 30869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = N->getValueType(0); 30969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 31069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = GetPromotedInteger(N->getOperand(0)); 31169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Res, DAG.getValueType(VT)); 31269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SRA, NVT, Res, N->getOperand(1)); 31369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 31469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 31569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SRL(SDNode *N) { 31669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The input value must be properly zero extended. 31769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = N->getValueType(0); 31869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 31969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = ZExtPromotedInteger(N->getOperand(0)); 32069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SRL, NVT, Res, N->getOperand(1)); 32169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 32269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 32369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SELECT(SDNode *N) { 32469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = GetPromotedInteger(N->getOperand(1)); 32569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = GetPromotedInteger(N->getOperand(2)); 32669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SELECT, LHS.getValueType(), N->getOperand(0),LHS,RHS); 32769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 32869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 32969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SELECT_CC(SDNode *N) { 33069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = GetPromotedInteger(N->getOperand(2)); 33169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = GetPromotedInteger(N->getOperand(3)); 33269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SELECT_CC, LHS.getValueType(), N->getOperand(0), 33369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(1), LHS, RHS, N->getOperand(4)); 33469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 33569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 33669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_CTLZ(SDNode *N) { 33769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 33869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OVT = N->getValueType(0); 33969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = Op.getValueType(); 34069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Zero extend to the promoted type and do the count there. 34169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Op = DAG.getNode(ISD::CTLZ, NVT, DAG.getZeroExtendInReg(Op, OVT)); 34269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Subtract off the extra leading bits in the bigger type. 34369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SUB, NVT, Op, 34469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(NVT.getSizeInBits() - 34569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands OVT.getSizeInBits(), NVT)); 34669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 34769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 34869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_CTPOP(SDNode *N) { 34969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 35069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OVT = N->getValueType(0); 35169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = Op.getValueType(); 35269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Zero extend to the promoted type and do the count there. 35369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::CTPOP, NVT, DAG.getZeroExtendInReg(Op, OVT)); 35469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 35569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 35669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_CTTZ(SDNode *N) { 35769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 35869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OVT = N->getValueType(0); 35969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = Op.getValueType(); 36069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The count is the same in the promoted type except if the original 36169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // value was zero. This can be handled by setting the bit just off 36269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // the top of the original type. 36369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Op = DAG.getNode(ISD::OR, NVT, Op, 36469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // FIXME: Do this using an APINT constant. 36569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(1UL << OVT.getSizeInBits(), NVT)); 36669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::CTTZ, NVT, Op); 36769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 36869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 36969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *N) { 37069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OldVT = N->getValueType(0); 37169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand OldVec = N->getOperand(0); 37269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned OldElts = OldVec.getValueType().getVectorNumElements(); 37369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 37469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (OldElts == 1) { 37569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(!isTypeLegal(OldVec.getValueType()) && 37669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands "Legal one-element vector of a type needing promotion!"); 37769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // It is tempting to follow GetScalarizedVector by a call to 37869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // GetPromotedInteger, but this would be wrong because the 37969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // scalarized value may not yet have been processed. 38069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::ANY_EXTEND, TLI.getTypeToTransformTo(OldVT), 38169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetScalarizedVector(OldVec)); 38269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 38369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 38469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Convert to a vector half as long with an element type of twice the width, 38569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // for example <4 x i16> -> <2 x i32>. 38669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(!(OldElts & 1) && "Odd length vectors not supported!"); 38769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NewVT = MVT::getIntegerVT(2 * OldVT.getSizeInBits()); 38869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OldVT.isSimple() && NewVT.isSimple()); 38969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 39069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand NewVec = DAG.getNode(ISD::BIT_CONVERT, 39169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT::getVectorVT(NewVT, OldElts / 2), 39269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands OldVec); 39369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 39469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Extract the element at OldIdx / 2 from the new vector. 39569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand OldIdx = N->getOperand(1); 39669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand NewIdx = DAG.getNode(ISD::SRL, OldIdx.getValueType(), OldIdx, 39769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(1, TLI.getShiftAmountTy())); 39869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, NewVT, NewVec, NewIdx); 39969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 40069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Select the appropriate half of the element: Lo if OldIdx was even, 40169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Hi if it was odd. 40269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Lo = Elt; 40369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Hi = DAG.getNode(ISD::SRL, NewVT, Elt, 40469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(OldVT.getSizeInBits(), 40569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands TLI.getShiftAmountTy())); 40669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (TLI.isBigEndian()) 40769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands std::swap(Lo, Hi); 40869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 40969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Odd = DAG.getNode(ISD::AND, OldIdx.getValueType(), OldIdx, 41069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(1, TLI.getShiftAmountTy())); 41169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SELECT, NewVT, Odd, Hi, Lo); 41269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 41369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 41469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands//===----------------------------------------------------------------------===// 41569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// Integer Operand Promotion 41669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands//===----------------------------------------------------------------------===// 41769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 41869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// PromoteIntegerOperand - This method is called when the specified operand of 41969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// the specified node is found to need promotion. At this point, all of the 42069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// result types of the node are known to be legal, but other operands of the 42169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// node may need promotion or expansion as well as the specified one. 42269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsbool DAGTypeLegalizer::PromoteIntegerOperand(SDNode *N, unsigned OpNo) { 42369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DEBUG(cerr << "Promote integer operand: "; N->dump(&DAG); cerr << "\n"); 42469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res; 42569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands switch (N->getOpcode()) { 42669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands default: 42769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands#ifndef NDEBUG 42869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands cerr << "PromoteIntegerOperand Op #" << OpNo << ": "; 42969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->dump(&DAG); cerr << "\n"; 43069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands#endif 43169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(0 && "Do not know how to promote this operator's operand!"); 43269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands abort(); 43369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 43469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ANY_EXTEND: Res = PromoteIntOp_ANY_EXTEND(N); break; 43569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ZERO_EXTEND: Res = PromoteIntOp_ZERO_EXTEND(N); break; 43669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SIGN_EXTEND: Res = PromoteIntOp_SIGN_EXTEND(N); break; 43769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::TRUNCATE: Res = PromoteIntOp_TRUNCATE(N); break; 43869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_EXTEND: Res = PromoteIntOp_FP_EXTEND(N); break; 43969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_ROUND: Res = PromoteIntOp_FP_ROUND(N); break; 44069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SINT_TO_FP: 44169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::UINT_TO_FP: Res = PromoteIntOp_INT_TO_FP(N); break; 44269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BUILD_PAIR: Res = PromoteIntOp_BUILD_PAIR(N); break; 44369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 44469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SELECT: Res = PromoteIntOp_SELECT(N, OpNo); break; 44569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BRCOND: Res = PromoteIntOp_BRCOND(N, OpNo); break; 44669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BR_CC: Res = PromoteIntOp_BR_CC(N, OpNo); break; 44769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETCC: Res = PromoteIntOp_SETCC(N, OpNo); break; 44869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 44969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::STORE: Res = PromoteIntOp_STORE(cast<StoreSDNode>(N), 45069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands OpNo); break; 45169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 45269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BUILD_VECTOR: Res = PromoteIntOp_BUILD_VECTOR(N); break; 45369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::INSERT_VECTOR_ELT: 45469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = PromoteIntOp_INSERT_VECTOR_ELT(N, OpNo); 45569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 45669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 45769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::MEMBARRIER: Res = PromoteIntOp_MEMBARRIER(N); break; 45869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 45969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 46069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If the result is null, the sub-method took care of registering results etc. 46169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (!Res.Val) return false; 46269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If the result is N, the sub-method updated N in place. 46369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (Res.Val == N) { 46469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Mark N as new and remark N and its operands. This allows us to correctly 46569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // revisit N if it needs another step of promotion and allows us to visit 46669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // any new operands to N. 46769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ReanalyzeNode(N); 46869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return true; 46969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 47069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 47169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 && 47269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands "Invalid operand expansion"); 47369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 47469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ReplaceValueWith(SDOperand(N, 0), Res); 47569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return false; 47669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 47769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 47869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_ANY_EXTEND(SDNode *N) { 47969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 48069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::ANY_EXTEND, N->getValueType(0), Op); 48169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 48269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 48369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_ZERO_EXTEND(SDNode *N) { 48469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 48569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Op = DAG.getNode(ISD::ANY_EXTEND, N->getValueType(0), Op); 48669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getZeroExtendInReg(Op, N->getOperand(0).getValueType()); 48769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 48869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 48969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_SIGN_EXTEND(SDNode *N) { 49069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 49169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Op = DAG.getNode(ISD::ANY_EXTEND, N->getValueType(0), Op); 49269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SIGN_EXTEND_INREG, Op.getValueType(), 49369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Op, DAG.getValueType(N->getOperand(0).getValueType())); 49469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 49569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 49669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_TRUNCATE(SDNode *N) { 49769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 49869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::TRUNCATE, N->getValueType(0), Op); 49969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 50069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 50169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_FP_EXTEND(SDNode *N) { 50269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 50369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::FP_EXTEND, N->getValueType(0), Op); 50469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 50569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 50669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_FP_ROUND(SDNode *N) { 50769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 50869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::FP_ROUND, N->getValueType(0), Op, 50969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getIntPtrConstant(0)); 51069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 51169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 51269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_INT_TO_FP(SDNode *N) { 51369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand In = GetPromotedInteger(N->getOperand(0)); 51469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OpVT = N->getOperand(0).getValueType(); 51569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (N->getOpcode() == ISD::UINT_TO_FP) 51669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands In = DAG.getZeroExtendInReg(In, OpVT); 51769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands else 51869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), 51969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands In, DAG.getValueType(OpVT)); 52069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 52169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), In); 52269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 52369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 52469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_BUILD_PAIR(SDNode *N) { 52569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Since the result type is legal, the operands must promote to it. 52669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OVT = N->getOperand(0).getValueType(); 52769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Lo = GetPromotedInteger(N->getOperand(0)); 52869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Hi = GetPromotedInteger(N->getOperand(1)); 52969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(Lo.getValueType() == N->getValueType(0) && "Operand over promoted?"); 53069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 53169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Lo = DAG.getZeroExtendInReg(Lo, OVT); 53269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Hi = DAG.getNode(ISD::SHL, N->getValueType(0), Hi, 53369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(OVT.getSizeInBits(), 53469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands TLI.getShiftAmountTy())); 53569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::OR, N->getValueType(0), Lo, Hi); 53669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 53769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 53869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_SELECT(SDNode *N, unsigned OpNo) { 53969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OpNo == 0 && "Only know how to promote condition"); 54069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Cond = GetPromotedInteger(N->getOperand(0)); // Promote condition. 54169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 54269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The top bits of the promoted condition are not necessarily zero, ensure 54369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // that the value is properly zero extended. 54469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned BitWidth = Cond.getValueSizeInBits(); 54569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (!DAG.MaskedValueIsZero(Cond, 54669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands APInt::getHighBitsSet(BitWidth, BitWidth-1))) 54769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Cond = DAG.getZeroExtendInReg(Cond, MVT::i1); 54869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 54969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The chain (Op#0) and basic block destination (Op#2) are always legal types. 55069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), Cond, N->getOperand(1), 55169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(2)); 55269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 55369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 55469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_BRCOND(SDNode *N, unsigned OpNo) { 55569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OpNo == 1 && "only know how to promote condition"); 55669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Cond = GetPromotedInteger(N->getOperand(1)); // Promote condition. 55769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 55869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The top bits of the promoted condition are not necessarily zero, ensure 55969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // that the value is properly zero extended. 56069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned BitWidth = Cond.getValueSizeInBits(); 56169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (!DAG.MaskedValueIsZero(Cond, 56269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands APInt::getHighBitsSet(BitWidth, BitWidth-1))) 56369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Cond = DAG.getZeroExtendInReg(Cond, MVT::i1); 56469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 56569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The chain (Op#0) and basic block destination (Op#2) are always legal types. 56669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), Cond, 56769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(2)); 56869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 56969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 57069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_BR_CC(SDNode *N, unsigned OpNo) { 57169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OpNo == 2 && "Don't know how to promote this operand"); 57269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 57369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = N->getOperand(2); 57469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = N->getOperand(3); 57569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands PromoteSetCCOperands(LHS, RHS, cast<CondCodeSDNode>(N->getOperand(1))->get()); 57669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 57769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The chain (Op#0), CC (#1) and basic block destination (Op#4) are always 57869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // legal types. 57969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), 58069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(1), LHS, RHS, N->getOperand(4)); 58169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 58269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 58369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_SETCC(SDNode *N, unsigned OpNo) { 58469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OpNo == 0 && "Don't know how to promote this operand"); 58569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 58669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = N->getOperand(0); 58769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = N->getOperand(1); 58869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands PromoteSetCCOperands(LHS, RHS, cast<CondCodeSDNode>(N->getOperand(2))->get()); 58969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 59069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The CC (#2) is always legal. 59169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), LHS, RHS, N->getOperand(2)); 59269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 59369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 59469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// PromoteSetCCOperands - Promote the operands of a comparison. This code is 59569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// shared among BR_CC, SELECT_CC, and SETCC handlers. 59669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::PromoteSetCCOperands(SDOperand &NewLHS,SDOperand &NewRHS, 59769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ISD::CondCode CCCode) { 59869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = NewLHS.getValueType(); 59969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 60069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Get the promoted values. 60169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewLHS = GetPromotedInteger(NewLHS); 60269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewRHS = GetPromotedInteger(NewRHS); 60369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 60469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If this is an FP compare, the operands have already been extended. 60569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (!NewLHS.getValueType().isInteger()) 60669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return; 60769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 60869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Otherwise, we have to insert explicit sign or zero extends. Note 60969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // that we could insert sign extends for ALL conditions, but zero extend 61069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // is cheaper on many machines (an AND instead of two shifts), so prefer 61169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // it. 61269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands switch (CCCode) { 61369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands default: assert(0 && "Unknown integer comparison!"); 61469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETEQ: 61569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETNE: 61669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETUGE: 61769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETUGT: 61869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETULE: 61969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETULT: 62069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // ALL of these operations will work if we either sign or zero extend 62169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // the operands (including the unsigned comparisons!). Zero extend is 62269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // usually a simpler/cheaper operation, so prefer it. 62369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewLHS = DAG.getZeroExtendInReg(NewLHS, VT); 62469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewRHS = DAG.getZeroExtendInReg(NewRHS, VT); 62569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return; 62669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETGE: 62769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETGT: 62869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETLT: 62969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETLE: 63069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewLHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, NewLHS.getValueType(), NewLHS, 63169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getValueType(VT)); 63269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewRHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, NewRHS.getValueType(), NewRHS, 63369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getValueType(VT)); 63469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return; 63569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 63669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 63769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 63869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_STORE(StoreSDNode *N, unsigned OpNo){ 63969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // FIXME: Add support for indexed stores. 64069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Ch = N->getChain(), Ptr = N->getBasePtr(); 64169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands int SVOffset = N->getSrcValueOffset(); 64269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned Alignment = N->getAlignment(); 64369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands bool isVolatile = N->isVolatile(); 64469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 64569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Val = GetPromotedInteger(N->getValue()); // Get promoted value. 64669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 64769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(!N->isTruncatingStore() && "Cannot promote this store operand!"); 64869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 64969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Truncate the value and store the result. 65069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getTruncStore(Ch, Val, Ptr, N->getSrcValue(), 65169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SVOffset, N->getMemoryVT(), 65269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands isVolatile, Alignment); 65369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 65469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 65569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_BUILD_VECTOR(SDNode *N) { 65669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The vector type is legal but the element type is not. This implies 65769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // that the vector is a power-of-two in length and that the element 65869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // type does not have a strange size (eg: it is not i1). 65969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VecVT = N->getValueType(0); 66069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned NumElts = VecVT.getVectorNumElements(); 66169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(!(NumElts & 1) && "Legal vector of one illegal element?"); 66269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 66369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Build a vector of half the length out of elements of twice the bitwidth. 66469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // For example <4 x i16> -> <2 x i32>. 66569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OldVT = N->getOperand(0).getValueType(); 66669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NewVT = MVT::getIntegerVT(2 * OldVT.getSizeInBits()); 66769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OldVT.isSimple() && NewVT.isSimple()); 66869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 66969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands std::vector<SDOperand> NewElts; 67069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewElts.reserve(NumElts/2); 67169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 67269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands for (unsigned i = 0; i < NumElts; i += 2) { 67369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Combine two successive elements into one promoted element. 67469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Lo = N->getOperand(i); 67569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Hi = N->getOperand(i+1); 67669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (TLI.isBigEndian()) 67769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands std::swap(Lo, Hi); 67869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewElts.push_back(JoinIntegers(Lo, Hi)); 67969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 68069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 68169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand NewVec = DAG.getNode(ISD::BUILD_VECTOR, 68269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT::getVectorVT(NewVT, NewElts.size()), 68369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands &NewElts[0], NewElts.size()); 68469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 68569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Convert the new vector to the old vector type. 68669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::BIT_CONVERT, VecVT, NewVec); 68769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 68869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 68969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_INSERT_VECTOR_ELT(SDNode *N, 69069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned OpNo) { 69169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (OpNo == 1) { 69269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Promote the inserted value. This is valid because the type does not 69369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // have to match the vector element type. 69469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 69569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Check that any extra bits introduced will be truncated away. 69669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(N->getOperand(1).getValueType().getSizeInBits() >= 69769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getValueType(0).getVectorElementType().getSizeInBits() && 69869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands "Type of inserted value narrower than vector element type!"); 69969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), 70069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetPromotedInteger(N->getOperand(1)), 70169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(2)); 70269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 70369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 70469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OpNo == 2 && "Different operand and result vector types?"); 70569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 70669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Promote the index. 70769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Idx = N->getOperand(2); 70869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Idx = DAG.getZeroExtendInReg(GetPromotedInteger(Idx), Idx.getValueType()); 70969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), 71069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(1), Idx); 71169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 71269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 71369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_MEMBARRIER(SDNode *N) { 71469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand NewOps[6]; 71569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewOps[0] = N->getOperand(0); 71669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands for (unsigned i = 1; i < array_lengthof(NewOps); ++i) { 71769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Flag = GetPromotedInteger(N->getOperand(i)); 71869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewOps[i] = DAG.getZeroExtendInReg(Flag, MVT::i1); 71969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 72069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand (N, 0), NewOps, 72169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands array_lengthof(NewOps)); 72269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 72369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 72469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 72569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands//===----------------------------------------------------------------------===// 72669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// Integer Result Expansion 72769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands//===----------------------------------------------------------------------===// 72869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 72969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// ExpandIntegerResult - This method is called when the specified result of the 730cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// specified node is found to need expansion. At this point, the node may also 731cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// have invalid operands or may have other results that need promotion, we just 732cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// know that (at least) one result needs expansion. 73369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntegerResult(SDNode *N, unsigned ResNo) { 73469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DEBUG(cerr << "Expand integer result: "; N->dump(&DAG); cerr << "\n"); 735cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Lo, Hi; 736cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = Hi = SDOperand(); 737cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 738cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // See if the target wants to custom expand this node. 73969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (TLI.getOperationAction(N->getOpcode(), N->getValueType(0)) == 740cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TargetLowering::Custom) { 741cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If the target wants to, allow it to lower this itself. 742cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (SDNode *P = TLI.ExpandOperationResult(N, DAG)) { 743cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Everything that once used N now uses P. We are guaranteed that the 744cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // result value types of N and the result value types of P match. 745cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ReplaceNodeWith(N, P); 746cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 747cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 748cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 749cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 750cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner switch (N->getOpcode()) { 751cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner default: 752cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner#ifndef NDEBUG 75369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands cerr << "ExpandIntegerResult #" << ResNo << ": "; 754cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner N->dump(&DAG); cerr << "\n"; 755cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner#endif 75678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(0 && "Do not know how to expand the result of this operator!"); 757cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner abort(); 75869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 75978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, Lo, Hi); break; 76078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::SELECT: SplitRes_SELECT(N, Lo, Hi); break; 76178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::SELECT_CC: SplitRes_SELECT_CC(N, Lo, Hi); break; 76278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::UNDEF: SplitRes_UNDEF(N, Lo, Hi); break; 76378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 76478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::BIT_CONVERT: ExpandRes_BIT_CONVERT(N, Lo, Hi); break; 76578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::BUILD_PAIR: ExpandRes_BUILD_PAIR(N, Lo, Hi); break; 76678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::EXTRACT_VECTOR_ELT: ExpandRes_EXTRACT_VECTOR_ELT(N, Lo, Hi); break; 76778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 76869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::Constant: ExpandIntRes_Constant(N, Lo, Hi); break; 76969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ANY_EXTEND: ExpandIntRes_ANY_EXTEND(N, Lo, Hi); break; 77069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ZERO_EXTEND: ExpandIntRes_ZERO_EXTEND(N, Lo, Hi); break; 77169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SIGN_EXTEND: ExpandIntRes_SIGN_EXTEND(N, Lo, Hi); break; 77269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::AssertZext: ExpandIntRes_AssertZext(N, Lo, Hi); break; 77369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::TRUNCATE: ExpandIntRes_TRUNCATE(N, Lo, Hi); break; 77469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SIGN_EXTEND_INREG: ExpandIntRes_SIGN_EXTEND_INREG(N, Lo, Hi); break; 77569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_TO_SINT: ExpandIntRes_FP_TO_SINT(N, Lo, Hi); break; 77669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_TO_UINT: ExpandIntRes_FP_TO_UINT(N, Lo, Hi); break; 77769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::LOAD: ExpandIntRes_LOAD(cast<LoadSDNode>(N), Lo, Hi); break; 77869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 779cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::AND: 780cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::OR: 78169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::XOR: ExpandIntRes_Logical(N, Lo, Hi); break; 78269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BSWAP: ExpandIntRes_BSWAP(N, Lo, Hi); break; 783cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::ADD: 78469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SUB: ExpandIntRes_ADDSUB(N, Lo, Hi); break; 785cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::ADDC: 78669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SUBC: ExpandIntRes_ADDSUBC(N, Lo, Hi); break; 787cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::ADDE: 78869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SUBE: ExpandIntRes_ADDSUBE(N, Lo, Hi); break; 78969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::MUL: ExpandIntRes_MUL(N, Lo, Hi); break; 79069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SDIV: ExpandIntRes_SDIV(N, Lo, Hi); break; 79169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SREM: ExpandIntRes_SREM(N, Lo, Hi); break; 79269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::UDIV: ExpandIntRes_UDIV(N, Lo, Hi); break; 79369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::UREM: ExpandIntRes_UREM(N, Lo, Hi); break; 794cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SHL: 795cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SRA: 79669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SRL: ExpandIntRes_Shift(N, Lo, Hi); break; 797d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 79869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::CTLZ: ExpandIntRes_CTLZ(N, Lo, Hi); break; 79969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::CTPOP: ExpandIntRes_CTPOP(N, Lo, Hi); break; 80069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::CTTZ: ExpandIntRes_CTTZ(N, Lo, Hi); break; 801cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 802d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 803cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If Lo/Hi is null, the sub-method took care of registering results etc. 804cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Lo.Val) 80569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SetExpandedInteger(SDOperand(N, ResNo), Lo, Hi); 806cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 807cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 80869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_Constant(SDNode *N, 809cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 81083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 81183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NBitWidth = NVT.getSizeInBits(); 812f25275cb3c930b579707e33c22c1e1c5682b89d3Dan Gohman const APInt &Cst = cast<ConstantSDNode>(N)->getAPIntValue(); 813f25275cb3c930b579707e33c22c1e1c5682b89d3Dan Gohman Lo = DAG.getConstant(APInt(Cst).trunc(NBitWidth), NVT); 814f25275cb3c930b579707e33c22c1e1c5682b89d3Dan Gohman Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), NVT); 815cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 816cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 81769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_ANY_EXTEND(SDNode *N, 818cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 81983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 820cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Op = N->getOperand(0); 8218e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands if (Op.getValueType().bitsLE(NVT)) { 822cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The low part is any extension of the input (which degenerates to a copy). 823cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::ANY_EXTEND, NVT, Op); 824cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); // The high part is undefined. 825cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 826cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For example, extension of an i48 to an i64. The operand type necessarily 827cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // promotes to the result type, so will end up being expanded too. 82869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(getTypeAction(Op.getValueType()) == PromoteInteger && 829077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands "Only know how to promote this result!"); 83069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = GetPromotedInteger(Op); 831cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(Res.getValueType() == N->getValueType(0) && 832cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "Operand over promoted?"); 833cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Split the promoted operand. This will simplify when it is expanded. 834ac7613a3263caa80d735f3fbf2b9f7b81deabc08Duncan Sands SplitInteger(Res, Lo, Hi); 835cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 836cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 837cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 83869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_ZERO_EXTEND(SDNode *N, 839cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 84083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 841cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Op = N->getOperand(0); 8428e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands if (Op.getValueType().bitsLE(NVT)) { 843cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The low part is zero extension of the input (which degenerates to a copy). 844cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, N->getOperand(0)); 845cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); // The high part is just a zero. 846cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 847cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For example, extension of an i48 to an i64. The operand type necessarily 848cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // promotes to the result type, so will end up being expanded too. 84969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(getTypeAction(Op.getValueType()) == PromoteInteger && 850077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands "Only know how to promote this result!"); 85169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = GetPromotedInteger(Op); 852cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(Res.getValueType() == N->getValueType(0) && 853cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "Operand over promoted?"); 854cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Split the promoted operand. This will simplify when it is expanded. 855ac7613a3263caa80d735f3fbf2b9f7b81deabc08Duncan Sands SplitInteger(Res, Lo, Hi); 856cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = 85783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands Op.getValueType().getSizeInBits() - NVT.getSizeInBits(); 85883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands Hi = DAG.getZeroExtendInReg(Hi, MVT::getIntegerVT(ExcessBits)); 859cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 860cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 861cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 86269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_SIGN_EXTEND(SDNode *N, 863cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 86483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 865cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Op = N->getOperand(0); 8668e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands if (Op.getValueType().bitsLE(NVT)) { 867cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The low part is sign extension of the input (which degenerates to a copy). 868cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, N->getOperand(0)); 869cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The high part is obtained by SRA'ing all but one of the bits of low part. 87083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned LoSize = NVT.getSizeInBits(); 871cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, 872cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(LoSize-1, TLI.getShiftAmountTy())); 873cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 874cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For example, extension of an i48 to an i64. The operand type necessarily 875cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // promotes to the result type, so will end up being expanded too. 87669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(getTypeAction(Op.getValueType()) == PromoteInteger && 877077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands "Only know how to promote this result!"); 87869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = GetPromotedInteger(Op); 879cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(Res.getValueType() == N->getValueType(0) && 880cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "Operand over promoted?"); 881cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Split the promoted operand. This will simplify when it is expanded. 882ac7613a3263caa80d735f3fbf2b9f7b81deabc08Duncan Sands SplitInteger(Res, Lo, Hi); 883cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = 88483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands Op.getValueType().getSizeInBits() - NVT.getSizeInBits(); 885cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, Hi.getValueType(), Hi, 88683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getValueType(MVT::getIntegerVT(ExcessBits))); 887cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 888cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 889cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 89069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_AssertZext(SDNode *N, 891d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands SDOperand &Lo, SDOperand &Hi) { 89269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Lo, Hi); 89383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = Lo.getValueType(); 89483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT(); 89583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NVTBits = NVT.getSizeInBits(); 89683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned EVTBits = EVT.getSizeInBits(); 897d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands 898d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands if (NVTBits < EVTBits) { 899d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Hi = DAG.getNode(ISD::AssertZext, NVT, Hi, 90083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getValueType(MVT::getIntegerVT(EVTBits - NVTBits))); 901d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands } else { 902d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Lo = DAG.getNode(ISD::AssertZext, NVT, Lo, DAG.getValueType(EVT)); 903d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands // The high part must be zero, make it explicit. 904d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Hi = DAG.getConstant(0, NVT); 905d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands } 906d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands} 907d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands 90869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_TRUNCATE(SDNode *N, 909d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands SDOperand &Lo, SDOperand &Hi) { 91083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 911d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Lo = DAG.getNode(ISD::TRUNCATE, NVT, N->getOperand(0)); 912d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Hi = DAG.getNode(ISD::SRL, N->getOperand(0).getValueType(), N->getOperand(0), 91383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits(), 914d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands TLI.getShiftAmountTy())); 915d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Hi = DAG.getNode(ISD::TRUNCATE, NVT, Hi); 916d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands} 917d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands 918cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattnervoid DAGTypeLegalizer:: 91969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsExpandIntRes_SIGN_EXTEND_INREG(SDNode *N, SDOperand &Lo, SDOperand &Hi) { 92069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Lo, Hi); 92183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT(); 922cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 9238e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands if (EVT.bitsLE(Lo.getValueType())) { 924cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // sext_inreg the low part if needed. 925cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, Lo.getValueType(), Lo, 926cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner N->getOperand(1)); 927cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 928cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The high part gets the sign extension from the lo-part. This handles 929cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // things like sextinreg V:i64 from i8. 930cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, Hi.getValueType(), Lo, 93183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(Hi.getValueType().getSizeInBits()-1, 932cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TLI.getShiftAmountTy())); 933cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 934cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For example, extension of an i48 to an i64. Leave the low part alone, 935cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // sext_inreg the high part. 936cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = 93783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands EVT.getSizeInBits() - Lo.getValueType().getSizeInBits(); 938cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, Hi.getValueType(), Hi, 93983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getValueType(MVT::getIntegerVT(ExcessBits))); 940cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 941cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 942cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 94369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDOperand &Lo, 944ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Hi) { 94583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getValueType(0); 94641edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Op = N->getOperand(0); 947ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 948ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands if (VT == MVT::i64) { 94941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (Op.getValueType() == MVT::f32) 950ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F32_I64; 95141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f64) 952ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F64_I64; 95341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f80) 954ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F80_I64; 95541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::ppcf128) 956ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_PPCF128_I64; 957ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } else if (VT == MVT::i128) { 95841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (Op.getValueType() == MVT::f32) 959ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F32_I128; 96041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f64) 961ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F64_I128; 96241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f80) 963ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F80_I128; 96441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::ppcf128) 965ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_PPCF128_I128; 966ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } else { 967ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(0 && "Unexpected fp-to-sint conversion!"); 968ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } 96941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(LC, VT, &Op, 1, true/*sign irrelevant*/), Lo, Hi); 970ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 971ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 97269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_FP_TO_UINT(SDNode *N, SDOperand &Lo, 973ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Hi) { 97483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getValueType(0); 97541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Op = N->getOperand(0); 976ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 977ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands if (VT == MVT::i64) { 97841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (Op.getValueType() == MVT::f32) 979ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F32_I64; 98041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f64) 981ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F64_I64; 98241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f80) 983ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F80_I64; 98441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::ppcf128) 985ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_PPCF128_I64; 986ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } else if (VT == MVT::i128) { 98741edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (Op.getValueType() == MVT::f32) 988ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F32_I128; 98941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f64) 990ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F64_I128; 99141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f80) 992ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F80_I128; 99341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::ppcf128) 994ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_PPCF128_I128; 995ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } else { 996ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(0 && "Unexpected fp-to-uint conversion!"); 997ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } 99841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(LC, VT, &Op, 1, false/*sign irrelevant*/), Lo, Hi); 999ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1000ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 100169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_LOAD(LoadSDNode *N, 1002cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 100378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (ISD::isNON_EXTLoad(N)) { 100478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands ExpandRes_NON_EXTLOAD(N, Lo, Hi); 100578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return; 100678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 100778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 100878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(ISD::isUNINDEXEDLoad(N) && "Indexed load during type legalization!"); 100978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 101083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getValueType(0); 101183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 1012cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Ch = N->getChain(); // Legalize the chain. 1013cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Ptr = N->getBasePtr(); // Legalize the pointer. 1014cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::LoadExtType ExtType = N->getExtensionType(); 1015cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner int SVOffset = N->getSrcValueOffset(); 1016cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned Alignment = N->getAlignment(); 1017cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool isVolatile = N->isVolatile(); 1018cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 101978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(NVT.isByteSized() && "Expanded type not byte sized!"); 1020cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 102178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (N->getMemoryVT().bitsLE(NVT)) { 102283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EVT = N->getMemoryVT(); 1023cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1024cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getExtLoad(ExtType, NVT, Ch, Ptr, N->getSrcValue(), SVOffset, EVT, 1025cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, Alignment); 1026cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1027cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Remember the chain. 1028cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ch = Lo.getValue(1); 1029cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1030cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (ExtType == ISD::SEXTLOAD) { 1031cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The high part is obtained by SRA'ing all but one of the bits of the 1032cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // lo part. 103383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned LoSize = Lo.getValueType().getSizeInBits(); 1034cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, 1035cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(LoSize-1, TLI.getShiftAmountTy())); 1036cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (ExtType == ISD::ZEXTLOAD) { 1037cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The high part is just a zero. 1038cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); 1039cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1040cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(ExtType == ISD::EXTLOAD && "Unknown extload!"); 1041cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The high part is undefined. 1042cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); 1043cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1044cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (TLI.isLittleEndian()) { 1045cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Little-endian - low bits are at low addresses. 1046cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getLoad(NVT, Ch, Ptr, N->getSrcValue(), SVOffset, 1047cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, Alignment); 1048cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1049cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = 105083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits(); 105183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NEVT = MVT::getIntegerVT(ExcessBits); 1052cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1053cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Increment the pointer to the other half. 105483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned IncrementSize = NVT.getSizeInBits()/8; 1055cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 10560bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(IncrementSize)); 1057cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getExtLoad(ExtType, NVT, Ch, Ptr, N->getSrcValue(), 1058cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SVOffset+IncrementSize, NEVT, 1059cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, MinAlign(Alignment, IncrementSize)); 1060cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1061cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Build a factor node to remember that this load is independent of the 1062cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // other one. 1063cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ch = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 1064cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi.getValue(1)); 1065cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1066cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Big-endian - high bits are at low addresses. Favor aligned loads at 1067cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // the cost of some bit-fiddling. 106883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EVT = N->getMemoryVT(); 106983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned EBytes = EVT.getStoreSizeInBits()/8; 107083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned IncrementSize = NVT.getSizeInBits()/8; 1071cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = (EBytes - IncrementSize)*8; 1072cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1073cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Load both the high bits and maybe some of the low bits. 1074cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getExtLoad(ExtType, NVT, Ch, Ptr, N->getSrcValue(), SVOffset, 107583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT::getIntegerVT(EVT.getSizeInBits() - ExcessBits), 1076cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, Alignment); 1077cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1078cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Increment the pointer to the other half. 1079cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 10800bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(IncrementSize)); 1081cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Load the rest of the low bits. 1082cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Ch, Ptr, N->getSrcValue(), 108383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands SVOffset+IncrementSize, 108483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT::getIntegerVT(ExcessBits), 1085cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, MinAlign(Alignment, IncrementSize)); 1086cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1087cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Build a factor node to remember that this load is independent of the 1088cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // other one. 1089cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ch = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 1090cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi.getValue(1)); 1091cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 109283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (ExcessBits < NVT.getSizeInBits()) { 1093cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Transfer low bits from the bottom of Hi to the top of Lo. 1094cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::OR, NVT, Lo, 1095cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SHL, NVT, Hi, 1096cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(ExcessBits, 1097cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TLI.getShiftAmountTy()))); 1098cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Move high bits to the right position in Hi. 1099cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ExtType == ISD::SEXTLOAD ? ISD::SRA : ISD::SRL, NVT, Hi, 110083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits() - ExcessBits, 1101cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TLI.getShiftAmountTy())); 1102cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1103cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1104cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1105cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Legalized the chain result - switch anything that used the old chain to 1106cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // use the new one. 1107cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ReplaceValueWith(SDOperand(N, 1), Ch); 1108cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1109cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 111069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_Logical(SDNode *N, 1111cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1112cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LL, LH, RL, RH; 111369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LL, LH); 111469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(1), RL, RH); 1115cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(N->getOpcode(), LL.getValueType(), LL, RL); 1116cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(N->getOpcode(), LL.getValueType(), LH, RH); 1117cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1118cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 111969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_BSWAP(SDNode *N, 1120cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 112169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Hi, Lo); // Note swapped operands. 1122cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::BSWAP, Lo.getValueType(), Lo); 1123cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::BSWAP, Hi.getValueType(), Hi); 1124cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1125cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 112669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_ADDSUB(SDNode *N, 1127cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1128cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Expand the subcomponents. 1129cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 113069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LHSL, LHSH); 113169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(1), RHSL, RHSH); 1132cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDVTList VTList = DAG.getVTList(LHSL.getValueType(), MVT::Flag); 1133cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LoOps[2] = { LHSL, RHSL }; 1134cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand HiOps[3] = { LHSH, RHSH }; 1135cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1136cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (N->getOpcode() == ISD::ADD) { 1137cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::ADDC, VTList, LoOps, 2); 1138cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner HiOps[2] = Lo.getValue(1); 1139cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::ADDE, VTList, HiOps, 3); 1140cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1141cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SUBC, VTList, LoOps, 2); 1142cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner HiOps[2] = Lo.getValue(1); 1143cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SUBE, VTList, HiOps, 3); 1144cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1145cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1146cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 114769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_ADDSUBC(SDNode *N, 1148cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1149cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Expand the subcomponents. 1150cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 115169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LHSL, LHSH); 115269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(1), RHSL, RHSH); 1153cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDVTList VTList = DAG.getVTList(LHSL.getValueType(), MVT::Flag); 1154cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LoOps[2] = { LHSL, RHSL }; 1155cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand HiOps[3] = { LHSH, RHSH }; 1156cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1157cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (N->getOpcode() == ISD::ADDC) { 1158cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::ADDC, VTList, LoOps, 2); 1159cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner HiOps[2] = Lo.getValue(1); 1160cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::ADDE, VTList, HiOps, 3); 1161cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1162cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SUBC, VTList, LoOps, 2); 1163cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner HiOps[2] = Lo.getValue(1); 1164cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SUBE, VTList, HiOps, 3); 1165cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1166cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1167cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Legalized the flag result - switch anything that used the old flag to 1168cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // use the new one. 1169cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ReplaceValueWith(SDOperand(N, 1), Hi.getValue(1)); 1170cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1171cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 117269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_ADDSUBE(SDNode *N, 1173cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1174cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Expand the subcomponents. 1175cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 117669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LHSL, LHSH); 117769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(1), RHSL, RHSH); 1178cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDVTList VTList = DAG.getVTList(LHSL.getValueType(), MVT::Flag); 1179cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LoOps[3] = { LHSL, RHSL, N->getOperand(2) }; 1180cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand HiOps[3] = { LHSH, RHSH }; 1181cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1182cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(N->getOpcode(), VTList, LoOps, 3); 1183cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner HiOps[2] = Lo.getValue(1); 1184cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(N->getOpcode(), VTList, HiOps, 3); 1185cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1186cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Legalized the flag result - switch anything that used the old flag to 1187cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // use the new one. 1188cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ReplaceValueWith(SDOperand(N, 1), Hi.getValue(1)); 1189cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1190cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 119169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_MUL(SDNode *N, 1192cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 119383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getValueType(0); 119483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 119569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1196cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool HasMULHS = TLI.isOperationLegal(ISD::MULHS, NVT); 1197cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool HasMULHU = TLI.isOperationLegal(ISD::MULHU, NVT); 1198cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool HasSMUL_LOHI = TLI.isOperationLegal(ISD::SMUL_LOHI, NVT); 1199cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool HasUMUL_LOHI = TLI.isOperationLegal(ISD::UMUL_LOHI, NVT); 1200cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasMULHU || HasMULHS || HasUMUL_LOHI || HasSMUL_LOHI) { 1201cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LL, LH, RL, RH; 120269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LL, LH); 120369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(1), RL, RH); 120483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned OuterBitSize = VT.getSizeInBits(); 120583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned BitSize = NVT.getSizeInBits(); 1206cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned LHSSB = DAG.ComputeNumSignBits(N->getOperand(0)); 1207cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned RHSSB = DAG.ComputeNumSignBits(N->getOperand(1)); 120869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 12092e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman if (DAG.MaskedValueIsZero(N->getOperand(0), 12102e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman APInt::getHighBitsSet(OuterBitSize, LHSSB)) && 12112e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman DAG.MaskedValueIsZero(N->getOperand(1), 12122e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman APInt::getHighBitsSet(OuterBitSize, RHSSB))) { 1213cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The inputs are both zero-extended. 1214cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasUMUL_LOHI) { 1215cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We can emit a umul_lohi. 1216cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::UMUL_LOHI, DAG.getVTList(NVT, NVT), LL, RL); 1217cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = SDOperand(Lo.Val, 1); 1218cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1219cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1220cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasMULHU) { 1221cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We can emit a mulhu+mul. 1222cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 1223cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 1224cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1225cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1226cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1227cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (LHSSB > BitSize && RHSSB > BitSize) { 1228cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The input values are both sign-extended. 1229cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasSMUL_LOHI) { 1230cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We can emit a smul_lohi. 1231cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SMUL_LOHI, DAG.getVTList(NVT, NVT), LL, RL); 1232cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = SDOperand(Lo.Val, 1); 1233cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1234cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1235cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasMULHS) { 1236cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We can emit a mulhs+mul. 1237cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 1238cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::MULHS, NVT, LL, RL); 1239cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1240cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1241cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1242cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasUMUL_LOHI) { 1243cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Lo,Hi = umul LHS, RHS. 1244cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand UMulLOHI = DAG.getNode(ISD::UMUL_LOHI, 1245cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getVTList(NVT, NVT), LL, RL); 1246cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = UMulLOHI; 1247cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = UMulLOHI.getValue(1); 1248cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 1249cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 1250cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 1251cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 1252cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1253cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1254cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 125541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 1256cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If nothing else, we can make a libcall. 125741edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 125841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(RTLIB::MUL_I64, VT, Ops, 2, true/*sign irrelevant*/), 125941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands Lo, Hi); 126041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands} 1261cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 126269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_SDIV(SDNode *N, 1263ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1264ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(N->getValueType(0) == MVT::i64 && "Unsupported sdiv!"); 126541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 126641edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(RTLIB::SDIV_I64, N->getValueType(0), Ops, 2, true), 126741edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands Lo, Hi); 1268ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1269ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 127069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_SREM(SDNode *N, 1271ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1272ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(N->getValueType(0) == MVT::i64 && "Unsupported srem!"); 127341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 127441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(RTLIB::SREM_I64, N->getValueType(0), Ops, 2, true), 127541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands Lo, Hi); 1276ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1277ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 127869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_UDIV(SDNode *N, 1279ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1280ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(N->getValueType(0) == MVT::i64 && "Unsupported udiv!"); 128141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 128241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(RTLIB::UDIV_I64, N->getValueType(0), Ops, 2, false), 128341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands Lo, Hi); 1284ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1285ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 128669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_UREM(SDNode *N, 1287ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1288ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(N->getValueType(0) == MVT::i64 && "Unsupported urem!"); 128941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 129041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(RTLIB::UREM_I64, N->getValueType(0), Ops, 2, false), 129141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands Lo, Hi); 1292ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1293cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 129469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_Shift(SDNode *N, 1295cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 129683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getValueType(0); 129769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 129869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If we can emit an efficient shift operation, do so now. Check to see if 1299cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // the RHS is a constant. 1300cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N->getOperand(1))) 1301cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return ExpandShiftByConstant(N, CN->getValue(), Lo, Hi); 1302cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1303cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If we can determine that the high bit of the shift is zero or one, even if 1304cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // the low bits are variable, emit this shift in an optimized form. 1305cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (ExpandShiftWithKnownAmountBit(N, Lo, Hi)) 1306cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 130769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1308cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If this target supports shift_PARTS, use it. First, map to the _PARTS opc. 1309cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned PartsOpc; 131041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (N->getOpcode() == ISD::SHL) { 1311cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner PartsOpc = ISD::SHL_PARTS; 131241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands } else if (N->getOpcode() == ISD::SRL) { 1313cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner PartsOpc = ISD::SRL_PARTS; 131441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands } else { 1315cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(N->getOpcode() == ISD::SRA && "Unknown shift!"); 1316cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner PartsOpc = ISD::SRA_PARTS; 1317cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 131869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1319cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Next check to see if the target supports this SHL_PARTS operation or if it 1320cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // will custom expand it. 132183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 1322cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TargetLowering::LegalizeAction Action = TLI.getOperationAction(PartsOpc, NVT); 1323cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) || 1324cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Action == TargetLowering::Custom) { 1325cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Expand the subcomponents. 1326cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LHSL, LHSH; 132769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LHSL, LHSH); 132869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1329cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Ops[] = { LHSL, LHSH, N->getOperand(1) }; 133083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = LHSL.getValueType(); 1331cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(PartsOpc, DAG.getNodeValueTypes(VT, VT), 2, Ops, 3); 1332cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = Lo.getValue(1); 1333cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1334cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 133541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 1336cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Otherwise, emit a libcall. 133741edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands assert(VT == MVT::i64 && "Unsupported shift!"); 133841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 133941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands RTLIB::Libcall LC; 134041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands bool isSigned; 134141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (N->getOpcode() == ISD::SHL) { 134241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands LC = RTLIB::SHL_I64; 134341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands isSigned = false; /*sign irrelevant*/ 134441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands } else if (N->getOpcode() == ISD::SRL) { 134541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands LC = RTLIB::SRL_I64; 134641edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands isSigned = false; 134741edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands } else { 134841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands assert(N->getOpcode() == ISD::SRA && "Unknown shift!"); 134941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands LC = RTLIB::SRA_I64; 135041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands isSigned = true; 135141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands } 135241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 135341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 135441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(LC, VT, Ops, 2, isSigned), Lo, Hi); 135541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands} 1356cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 135769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_CTLZ(SDNode *N, 1358d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1359d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands // ctlz (HiLo) -> Hi != 0 ? ctlz(Hi) : (ctlz(Lo)+32) 136069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Lo, Hi); 136183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = Lo.getValueType(); 1362d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 13635b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel SDOperand HiNotZero = DAG.getSetCC(TLI.getSetCCResultType(Hi), Hi, 1364d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands DAG.getConstant(0, NVT), ISD::SETNE); 1365d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 1366d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand LoLZ = DAG.getNode(ISD::CTLZ, NVT, Lo); 1367d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand HiLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 1368d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 1369d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Lo = DAG.getNode(ISD::SELECT, NVT, HiNotZero, HiLZ, 1370d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands DAG.getNode(ISD::ADD, NVT, LoLZ, 137183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits(), NVT))); 1372d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Hi = DAG.getConstant(0, NVT); 1373d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands} 1374d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 137569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_CTPOP(SDNode *N, 1376d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1377d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands // ctpop(HiLo) -> ctpop(Hi)+ctpop(Lo) 137869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Lo, Hi); 137983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = Lo.getValueType(); 1380d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Lo = DAG.getNode(ISD::ADD, NVT, DAG.getNode(ISD::CTPOP, NVT, Lo), 1381d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands DAG.getNode(ISD::CTPOP, NVT, Hi)); 1382d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Hi = DAG.getConstant(0, NVT); 1383d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands} 1384d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 138569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_CTTZ(SDNode *N, 1386d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1387d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands // cttz (HiLo) -> Lo != 0 ? cttz(Lo) : (cttz(Hi)+32) 138869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Lo, Hi); 138983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = Lo.getValueType(); 1390d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 13915b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel SDOperand LoNotZero = DAG.getSetCC(TLI.getSetCCResultType(Lo), Lo, 1392d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands DAG.getConstant(0, NVT), ISD::SETNE); 1393d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 1394d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand LoLZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 1395d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand HiLZ = DAG.getNode(ISD::CTTZ, NVT, Hi); 1396d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 1397d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Lo = DAG.getNode(ISD::SELECT, NVT, LoNotZero, LoLZ, 1398d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands DAG.getNode(ISD::ADD, NVT, HiLZ, 139983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits(), NVT))); 1400d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Hi = DAG.getConstant(0, NVT); 1401d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands} 1402cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1403cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// ExpandShiftByConstant - N is a shift by a value that needs to be expanded, 1404cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// and the shift amount is a constant 'Amt'. Expand the operation. 140569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandShiftByConstant(SDNode *N, unsigned Amt, 1406cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1407cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Expand the incoming operand to be shifted, so that we have its parts 1408cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand InL, InH; 140969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), InL, InH); 141069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 141183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = InL.getValueType(); 141283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned VTBits = N->getValueType(0).getSizeInBits(); 141383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NVTBits = NVT.getSizeInBits(); 141483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ShTy = N->getOperand(1).getValueType(); 1415cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1416cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (N->getOpcode() == ISD::SHL) { 1417cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Amt > VTBits) { 1418cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = Hi = DAG.getConstant(0, NVT); 1419cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt > NVTBits) { 1420cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getConstant(0, NVT); 1421cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Amt-NVTBits,ShTy)); 1422cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt == NVTBits) { 1423cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getConstant(0, NVT); 1424cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = InL; 1425cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1426cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Amt, ShTy)); 1427cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::OR, NVT, 1428cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, 1429cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(Amt, ShTy)), 1430cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, 1431cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-Amt, ShTy))); 1432cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1433cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1434cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 143569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1436cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (N->getOpcode() == ISD::SRL) { 1437cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Amt > VTBits) { 1438cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getConstant(0, NVT); 1439cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); 1440cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt > NVTBits) { 1441cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Amt-NVTBits,ShTy)); 1442cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); 1443cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt == NVTBits) { 1444cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = InH; 1445cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); 1446cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1447cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::OR, NVT, 1448cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, 1449cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(Amt, ShTy)), 1450cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, 1451cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-Amt, ShTy))); 1452cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Amt, ShTy)); 1453cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1454cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1455cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 145669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1457cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(N->getOpcode() == ISD::SRA && "Unknown shift!"); 1458cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Amt > VTBits) { 1459cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 1460cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 1461cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt > NVTBits) { 1462cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SRA, NVT, InH, 1463cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(Amt-NVTBits, ShTy)); 1464cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, InH, 1465cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 1466cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt == NVTBits) { 1467cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = InH; 1468cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, InH, 1469cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 1470cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1471cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::OR, NVT, 1472cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, 1473cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(Amt, ShTy)), 1474cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, 1475cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-Amt, ShTy))); 1476cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Amt, ShTy)); 1477cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1478cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1479cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1480cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// ExpandShiftWithKnownAmountBit - Try to determine whether we can simplify 1481cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// this shift based on knowledge of the high bit of the shift amount. If we 1482cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// can tell this, we know that it is >= 32 or < 32, without knowing the actual 1483cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// shift amount. 1484cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattnerbool DAGTypeLegalizer:: 1485cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris LattnerExpandShiftWithKnownAmountBit(SDNode *N, SDOperand &Lo, SDOperand &Hi) { 148691dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman SDOperand Amt = N->getOperand(1); 148783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 148883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ShTy = Amt.getValueType(); 148983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned ShBits = ShTy.getSizeInBits(); 149083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NVTBits = NVT.getSizeInBits(); 149191dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman assert(isPowerOf2_32(NVTBits) && 1492cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "Expanded integer type size not a power of two!"); 1493cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 149491dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman APInt HighBitMask = APInt::getHighBitsSet(ShBits, ShBits - Log2_32(NVTBits)); 149591dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman APInt KnownZero, KnownOne; 1496cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.ComputeMaskedBits(N->getOperand(1), HighBitMask, KnownZero, KnownOne); 149769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 14989e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // If we don't know anything about the high bits, exit. 1499cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (((KnownZero|KnownOne) & HighBitMask) == 0) 1500cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return false; 1501cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1502cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Get the incoming operand to be shifted. 1503cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand InL, InH; 150469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), InL, InH); 1505cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 15069e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // If we know that any of the high bits of the shift amount are one, then we 15079e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // can do this as a couple of simple shifts. 150891dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman if (KnownOne.intersects(HighBitMask)) { 1509cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Mask out the high bit, which we know is set. 151091dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman Amt = DAG.getNode(ISD::AND, ShTy, Amt, 151191dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman DAG.getConstant(~HighBitMask, ShTy)); 151269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1513cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner switch (N->getOpcode()) { 1514cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner default: assert(0 && "Unknown shift"); 1515cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SHL: 1516cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getConstant(0, NVT); // Low part is zero. 1517cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SHL, NVT, InL, Amt); // High part from Lo part. 1518cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return true; 1519cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SRL: 1520cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); // Hi part is zero. 1521cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SRL, NVT, InH, Amt); // Lo part from Hi part. 1522cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return true; 1523cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SRA: 1524cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, InH, // Sign extend high part. 152591dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman DAG.getConstant(NVTBits-1, ShTy)); 1526cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SRA, NVT, InH, Amt); // Lo part from Hi part. 1527cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return true; 1528cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1529cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 153069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 15319e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // If we know that all of the high bits of the shift amount are zero, then we 15329e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // can do this as a couple of simple shifts. 15339e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman if ((KnownZero & HighBitMask) == HighBitMask) { 15349e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // Compute 32-amt. 15359e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman SDOperand Amt2 = DAG.getNode(ISD::SUB, ShTy, 15369e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman DAG.getConstant(NVTBits, ShTy), 15379e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman Amt); 15389e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman unsigned Op1, Op2; 15399e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman switch (N->getOpcode()) { 15409e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman default: assert(0 && "Unknown shift"); 15419e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman case ISD::SHL: Op1 = ISD::SHL; Op2 = ISD::SRL; break; 15429e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman case ISD::SRL: 15439e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman case ISD::SRA: Op1 = ISD::SRL; Op2 = ISD::SHL; break; 15449e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman } 154569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 15469e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman Lo = DAG.getNode(N->getOpcode(), NVT, InL, Amt); 15479e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman Hi = DAG.getNode(ISD::OR, NVT, 15489e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman DAG.getNode(Op1, NVT, InH, Amt), 15499e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman DAG.getNode(Op2, NVT, InL, Amt2)); 15509e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman return true; 15519e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman } 15529e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman 15539e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman return false; 1554cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1555cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1556cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1557cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner//===----------------------------------------------------------------------===// 155869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// Integer Operand Expansion 1559cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner//===----------------------------------------------------------------------===// 1560cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 156169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// ExpandIntegerOperand - This method is called when the specified operand of 156269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// the specified node is found to need expansion. At this point, all of the 156369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// result types of the node are known to be legal, but other operands of the 156469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// node may need promotion or expansion as well as the specified one. 156569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsbool DAGTypeLegalizer::ExpandIntegerOperand(SDNode *N, unsigned OpNo) { 156669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DEBUG(cerr << "Expand integer operand: "; N->dump(&DAG); cerr << "\n"); 1567cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Res(0, 0); 156869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1569648f880dc907faf5c05f3d79a424597b65758360Duncan Sands if (TLI.getOperationAction(N->getOpcode(), N->getOperand(OpNo).getValueType()) 1570648f880dc907faf5c05f3d79a424597b65758360Duncan Sands == TargetLowering::Custom) 1571cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Res = TLI.LowerOperation(SDOperand(N, 0), DAG); 157269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1573cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Res.Val == 0) { 1574cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner switch (N->getOpcode()) { 1575cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner default: 1576cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner #ifndef NDEBUG 157769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands cerr << "ExpandIntegerOperand Op #" << OpNo << ": "; 1578cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner N->dump(&DAG); cerr << "\n"; 1579cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner #endif 1580cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(0 && "Do not know how to expand this operator's operand!"); 1581cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner abort(); 158269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 158378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::BUILD_VECTOR: Res = ExpandOp_BUILD_VECTOR(N); break; 158478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::BIT_CONVERT: Res = ExpandOp_BIT_CONVERT(N); break; 158578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::EXTRACT_ELEMENT: Res = ExpandOp_EXTRACT_ELEMENT(N); break; 158678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 158769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::TRUNCATE: Res = ExpandIntOp_TRUNCATE(N); break; 1588cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1589cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SINT_TO_FP: 159069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = ExpandIntOp_SINT_TO_FP(N->getOperand(0), N->getValueType(0)); 1591cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner break; 1592cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::UINT_TO_FP: 159369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = ExpandIntOp_UINT_TO_FP(N->getOperand(0), N->getValueType(0)); 1594cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner break; 1595051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands 159669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BR_CC: Res = ExpandIntOp_BR_CC(N); break; 159769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETCC: Res = ExpandIntOp_SETCC(N); break; 1598cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1599cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::STORE: 160069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = ExpandIntOp_STORE(cast<StoreSDNode>(N), OpNo); 1601cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner break; 1602cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1603cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 160469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1605cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If the result is null, the sub-method took care of registering results etc. 1606cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (!Res.Val) return false; 1607cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If the result is N, the sub-method updated N in place. Check to see if any 1608cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // operands are new, and if so, mark them. 1609cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Res.Val == N) { 1610cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Mark N as new and remark N and its operands. This allows us to correctly 161169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // revisit N if it needs another step of expansion and allows us to visit 1612cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // any new operands to N. 1613212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands ReanalyzeNode(N); 1614cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return true; 1615cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1616cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1617cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 && 1618cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "Invalid operand expansion"); 161969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1620cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ReplaceValueWith(SDOperand(N, 0), Res); 1621cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return false; 1622cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1623cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 162469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_TRUNCATE(SDNode *N) { 1625cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand InL, InH; 162669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), InL, InH); 1627cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Just truncate the low part of the source. 1628cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.getNode(ISD::TRUNCATE, N->getValueType(0), InL); 1629cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1630cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 163169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_SINT_TO_FP(SDOperand Source, 163283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT DestTy) { 1633cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We know the destination is legal, but that the input needs to be expanded. 163483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT SourceVT = Source.getValueType(); 163569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1636cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 1637d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman switch (TLI.getOperationAction(ISD::SINT_TO_FP, SourceVT)) { 1638cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 1639cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case TargetLowering::Legal: 1640cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case TargetLowering::Expand: 1641cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner break; // This case is handled below. 1642cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case TargetLowering::Custom: 1643cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand NV = TLI.LowerOperation(DAG.getNode(ISD::SINT_TO_FP, DestTy, 1644cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Source), DAG); 1645cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (NV.Val) return NV; 1646cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner break; // The target lowered this. 1647cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 164869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 164941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 1650d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman if (SourceVT == MVT::i64) { 1651d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman if (DestTy == MVT::f32) 1652d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I64_F32; 1653d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman else { 1654d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman assert(DestTy == MVT::f64 && "Unknown fp value type!"); 1655d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I64_F64; 1656d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman } 1657d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman } else if (SourceVT == MVT::i128) { 1658d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman if (DestTy == MVT::f32) 1659d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I128_F32; 1660d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman else if (DestTy == MVT::f64) 1661d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I128_F64; 1662d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman else if (DestTy == MVT::f80) 1663d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I128_F80; 1664d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman else { 1665d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman assert(DestTy == MVT::ppcf128 && "Unknown fp value type!"); 1666d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I128_PPCF128; 1667d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman } 1668d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman } else { 1669d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman assert(0 && "Unknown int value type!"); 1670cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 167141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 167241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands assert(LC != RTLIB::UNKNOWN_LIBCALL && 167341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands "Don't know how to expand this SINT_TO_FP!"); 167441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands return MakeLibCall(LC, DestTy, &Source, 1, true); 1675cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1676cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 167769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_UINT_TO_FP(SDOperand Source, 167883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT DestTy) { 1679cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We know the destination is legal, but that the input needs to be expanded. 168069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(getTypeAction(Source.getValueType()) == ExpandInteger && 1681cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "This is not an expansion!"); 168269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1683cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 1684cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // signed, then adjust the result if the sign bit is set. 168569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand SignedConv = ExpandIntOp_SINT_TO_FP(Source, DestTy); 1686cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1687cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 1688cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // incoming integer is set. To handle this, we dynamically test to see if 1689cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // it is set, and, if so, add a fudge factor. 1690cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Lo, Hi; 169169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(Source, Lo, Hi); 169269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 16935b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultType(Hi), Hi, 1694cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(0, Hi.getValueType()), 1695cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::SETLT); 16960bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner SDOperand Zero = DAG.getIntPtrConstant(0), Four = DAG.getIntPtrConstant(4); 1697cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 1698cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SignSet, Four, Zero); 1699cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner uint64_t FF = 0x5f800000ULL; 1700cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (TLI.isLittleEndian()) FF <<= 32; 1701cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Constant *FudgeFactor = ConstantInt::get((Type*)Type::Int64Ty, FF); 170269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1703cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 1704cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 1705cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand FudgeInReg; 1706cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (DestTy == MVT::f32) 1707cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, NULL, 0); 17088e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands else if (DestTy.bitsGT(MVT::f32)) 1709cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // FIXME: Avoid the extend by construction the right constantpool? 1710cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, DestTy, DAG.getEntryNode(), 1711cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner CPIdx, NULL, 0, MVT::f32); 171269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands else 1713cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(0 && "Unexpected conversion"); 171469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1715cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.getNode(ISD::FADD, DestTy, SignedConv, FudgeInReg); 1716cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1717cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 171869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_BR_CC(SDNode *N) { 1719051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands SDOperand NewLHS = N->getOperand(2), NewRHS = N->getOperand(3); 1720051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get(); 1721051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands ExpandSetCCOperands(NewLHS, NewRHS, CCCode); 1722051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands 1723051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands // If ExpandSetCCOperands returned a scalar, we need to compare the result 1724051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands // against zero to select between true and false values. 1725051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands if (NewRHS.Val == 0) { 1726051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands NewRHS = DAG.getConstant(0, NewLHS.getValueType()); 1727051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands CCCode = ISD::SETNE; 1728051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands } 1729051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands 1730051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands // Update N to have the operands specified. 1731051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), 1732051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands DAG.getCondCode(CCCode), NewLHS, NewRHS, 1733051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands N->getOperand(4)); 1734051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands} 1735051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands 173669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_SETCC(SDNode *N) { 1737cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand NewLHS = N->getOperand(0), NewRHS = N->getOperand(1); 1738cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get(); 1739cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ExpandSetCCOperands(NewLHS, NewRHS, CCCode); 174069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1741cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If ExpandSetCCOperands returned a scalar, use it. 1742cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (NewRHS.Val == 0) return NewLHS; 1743cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1744cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Otherwise, update N to have the operands specified. 1745cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.UpdateNodeOperands(SDOperand(N, 0), NewLHS, NewRHS, 1746cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getCondCode(CCCode)); 1747cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1748cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1749cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// ExpandSetCCOperands - Expand the operands of a comparison. This code is 1750cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// shared among BR_CC, SELECT_CC, and SETCC handlers. 1751cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattnervoid DAGTypeLegalizer::ExpandSetCCOperands(SDOperand &NewLHS, SDOperand &NewRHS, 1752cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::CondCode &CCCode) { 1753cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 175469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(NewLHS, LHSLo, LHSHi); 175569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(NewRHS, RHSLo, RHSHi); 175641edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 175783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = NewLHS.getValueType(); 1758cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (VT == MVT::ppcf128) { 1759cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // FIXME: This generated code sucks. We want to generate 1760cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // FCMP crN, hi1, hi2 1761cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // BNE crN, L: 1762cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // FCMP crN, lo1, lo2 1763cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The following can be improved, but not that much. 1764cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Tmp1, Tmp2, Tmp3; 17655b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp1 = DAG.getSetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, ISD::SETEQ); 17665b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp2 = DAG.getSetCC(TLI.getSetCCResultType(LHSLo), LHSLo, RHSLo, CCCode); 1767cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Tmp3 = DAG.getNode(ISD::AND, Tmp1.getValueType(), Tmp1, Tmp2); 17685b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp1 = DAG.getSetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, ISD::SETNE); 17695b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp2 = DAG.getSetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, CCCode); 1770cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Tmp1 = DAG.getNode(ISD::AND, Tmp1.getValueType(), Tmp1, Tmp2); 1771cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = DAG.getNode(ISD::OR, Tmp1.getValueType(), Tmp1, Tmp3); 1772cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = SDOperand(); // LHS is the result, not a compare. 1773cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1774cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 177541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 1776cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (CCCode == ISD::SETEQ || CCCode == ISD::SETNE) { 1777cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (RHSLo == RHSHi) 1778cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) 1779cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (RHSCST->isAllOnesValue()) { 1780cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Equality comparison to -1. 1781cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 1782cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = RHSLo; 1783cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1784cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 178569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1786cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 1787cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 1788cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = DAG.getNode(ISD::OR, NewLHS.getValueType(), NewLHS, NewRHS); 1789cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = DAG.getConstant(0, NewLHS.getValueType()); 1790cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1791cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 179269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1793cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 1794cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // X > -1, x < 0 1795cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(NewRHS)) 1796002e5d0a170dadd5c307e0b00d8c7970835837e6Dan Gohman if ((CCCode == ISD::SETLT && CST->isNullValue()) || // X < 0 1797cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner (CCCode == ISD::SETGT && CST->isAllOnesValue())) { // X > -1 1798cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = LHSHi; 1799cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = RHSHi; 1800cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1801cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 180269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1803cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // FIXME: This generated code sucks. 1804cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::CondCode LowCC; 1805cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner switch (CCCode) { 1806cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner default: assert(0 && "Unknown integer setcc!"); 1807cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETLT: 1808cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 1809cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETGT: 1810cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 1811cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETLE: 1812cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 1813cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETGE: 1814cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 1815cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 181669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1817cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 1818cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 1819cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 182069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1821cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 1822cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 1823cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TargetLowering::DAGCombinerInfo DagCombineInfo(DAG, false, true, NULL); 1824cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Tmp1, Tmp2; 18255b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp1 = TLI.SimplifySetCC(TLI.getSetCCResultType(LHSLo), LHSLo, RHSLo, LowCC, 1826cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner false, DagCombineInfo); 1827cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (!Tmp1.Val) 18285b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp1 = DAG.getSetCC(TLI.getSetCCResultType(LHSLo), LHSLo, RHSLo, LowCC); 18295b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp2 = TLI.SimplifySetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, 1830cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner CCCode, false, DagCombineInfo); 1831cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (!Tmp2.Val) 18325b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp2 = DAG.getNode(ISD::SETCC, TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, 1833cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getCondCode(CCCode)); 183469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1835cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ConstantSDNode *Tmp1C = dyn_cast<ConstantSDNode>(Tmp1.Val); 1836cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ConstantSDNode *Tmp2C = dyn_cast<ConstantSDNode>(Tmp2.Val); 1837002e5d0a170dadd5c307e0b00d8c7970835837e6Dan Gohman if ((Tmp1C && Tmp1C->isNullValue()) || 1838002e5d0a170dadd5c307e0b00d8c7970835837e6Dan Gohman (Tmp2C && Tmp2C->isNullValue() && 1839cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner (CCCode == ISD::SETLE || CCCode == ISD::SETGE || 1840cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner CCCode == ISD::SETUGE || CCCode == ISD::SETULE)) || 1841002e5d0a170dadd5c307e0b00d8c7970835837e6Dan Gohman (Tmp2C && Tmp2C->getAPIntValue() == 1 && 1842cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner (CCCode == ISD::SETLT || CCCode == ISD::SETGT || 1843cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner CCCode == ISD::SETUGT || CCCode == ISD::SETULT))) { 1844cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // low part is known false, returns high part. 1845cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For LE / GE, if high part is known false, ignore the low part. 1846cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For LT / GT, if high part is known true, ignore the low part. 1847cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = Tmp2; 1848cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = SDOperand(); 1849cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1850cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 185169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 18525b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel NewLHS = TLI.SimplifySetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, 1853cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::SETEQ, false, DagCombineInfo); 1854cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (!NewLHS.Val) 18555b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel NewLHS = DAG.getSetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, 185671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner ISD::SETEQ); 1857cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1858cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS, Tmp1, Tmp2); 1859cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = SDOperand(); 1860cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1861cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 186269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo) { 186378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (ISD::isNON_TRUNCStore(N)) 186478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return ExpandOp_NON_TRUNCStore(N, OpNo); 186578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 186678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!"); 1867cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(OpNo == 1 && "Can only expand the stored value so far"); 1868cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 186983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getOperand(1).getValueType(); 187083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 1871cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Ch = N->getChain(); 1872cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Ptr = N->getBasePtr(); 1873cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner int SVOffset = N->getSrcValueOffset(); 1874cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned Alignment = N->getAlignment(); 1875cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool isVolatile = N->isVolatile(); 1876cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Lo, Hi; 1877cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1878a1ace76c70ae5332d6f33fce5c0c1e2fdb8cca11Duncan Sands assert(NVT.isByteSized() && "Expanded type not byte sized!"); 1879cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 188078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (N->getMemoryVT().bitsLE(NVT)) { 188169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getValue(), Lo, Hi); 1882cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.getTruncStore(Ch, Lo, Ptr, N->getSrcValue(), SVOffset, 1883b625f2f8960de32bc973092aaee8ac62863006feDan Gohman N->getMemoryVT(), isVolatile, Alignment); 1884cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (TLI.isLittleEndian()) { 1885cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Little-endian - low bits are at low addresses. 188669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getValue(), Lo, Hi); 1887cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1888cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getStore(Ch, Lo, Ptr, N->getSrcValue(), SVOffset, 1889cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, Alignment); 1890cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1891cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = 189283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits(); 189383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NEVT = MVT::getIntegerVT(ExcessBits); 1894cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1895cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Increment the pointer to the other half. 189683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned IncrementSize = NVT.getSizeInBits()/8; 1897cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 18980bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(IncrementSize)); 1899cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getTruncStore(Ch, Hi, Ptr, N->getSrcValue(), 1900cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SVOffset+IncrementSize, NEVT, 1901cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, MinAlign(Alignment, IncrementSize)); 1902cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1903cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1904cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Big-endian - high bits are at low addresses. Favor aligned stores at 1905cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // the cost of some bit-fiddling. 190669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getValue(), Lo, Hi); 1907cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 190883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EVT = N->getMemoryVT(); 190983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned EBytes = EVT.getStoreSizeInBits()/8; 191083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned IncrementSize = NVT.getSizeInBits()/8; 1911cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = (EBytes - IncrementSize)*8; 191283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT HiVT = MVT::getIntegerVT(EVT.getSizeInBits() - ExcessBits); 1913cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 191483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (ExcessBits < NVT.getSizeInBits()) { 1915cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Transfer high bits from the top of Lo to the bottom of Hi. 1916cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SHL, NVT, Hi, 191783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits() - ExcessBits, 1918cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TLI.getShiftAmountTy())); 1919cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::OR, NVT, Hi, 1920cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SRL, NVT, Lo, 1921cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(ExcessBits, 1922cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TLI.getShiftAmountTy()))); 1923cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1924cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1925cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Store both the high bits and maybe some of the low bits. 1926cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getTruncStore(Ch, Hi, Ptr, N->getSrcValue(), 1927cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SVOffset, HiVT, isVolatile, Alignment); 1928cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1929cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Increment the pointer to the other half. 1930cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 19310bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(IncrementSize)); 1932cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Store the lowest ExcessBits bits in the second half. 1933cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getTruncStore(Ch, Lo, Ptr, N->getSrcValue(), 1934cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SVOffset+IncrementSize, 193583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT::getIntegerVT(ExcessBits), 1936cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, MinAlign(Alignment, IncrementSize)); 1937cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1938cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1939cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1940