LegalizeIntegerTypes.cpp revision d3ca9fc9984d036146886a40ad3f73aaf7a424eb
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; 87d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands 88d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands case ISD::VAARG : Result = PromoteIntRes_VAARG(N); break; 8969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 9069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 9169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If Result is null, the sub-method took care of registering the result. 9269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (Result.Val) 9369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SetPromotedInteger(SDOperand(N, ResNo), Result); 9469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 9569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 9669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_UNDEF(SDNode *N) { 9769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::UNDEF, TLI.getTypeToTransformTo(N->getValueType(0))); 9869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 9969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 10069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_Constant(SDNode *N) { 10169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = N->getValueType(0); 10269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Zero extend things like i1, sign extend everything else. It shouldn't 10369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // matter in theory which one we pick, but this tends to give better code? 10469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned Opc = VT.isByteSized() ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND; 10569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Result = DAG.getNode(Opc, TLI.getTypeToTransformTo(VT), 10669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand(N, 0)); 10769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(isa<ConstantSDNode>(Result) && "Didn't constant fold ext?"); 10869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return Result; 10969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 11069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 11169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_TRUNCATE(SDNode *N) { 11269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res; 11369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 11469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands switch (getTypeAction(N->getOperand(0).getValueType())) { 11569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands default: assert(0 && "Unknown type action!"); 11669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case Legal: 11769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ExpandInteger: 11869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = N->getOperand(0); 11969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 12069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case PromoteInteger: 12169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = GetPromotedInteger(N->getOperand(0)); 12269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 12369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 12469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 12569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 12669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(Res.getValueType().getSizeInBits() >= NVT.getSizeInBits() && 12769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands "Truncation doesn't make sense!"); 12869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (Res.getValueType() == NVT) 12969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return Res; 13069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 13169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Truncate to NVT instead of VT 13269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::TRUNCATE, NVT, Res); 13369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 13469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 13569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_INT_EXTEND(SDNode *N) { 13669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 13769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 13869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (getTypeAction(N->getOperand(0).getValueType()) == PromoteInteger) { 13969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = GetPromotedInteger(N->getOperand(0)); 14069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(Res.getValueType().getSizeInBits() <= NVT.getSizeInBits() && 14169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands "Extension doesn't make sense!"); 14269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 14369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If the result and operand types are the same after promotion, simplify 14469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // to an in-register extension. 14569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (NVT == Res.getValueType()) { 14669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The high bits are not guaranteed to be anything. Insert an extend. 14769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (N->getOpcode() == ISD::SIGN_EXTEND) 14869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Res, 14969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getValueType(N->getOperand(0).getValueType())); 15069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (N->getOpcode() == ISD::ZERO_EXTEND) 15169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getZeroExtendInReg(Res, N->getOperand(0).getValueType()); 15269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(N->getOpcode() == ISD::ANY_EXTEND && "Unknown integer extension!"); 15369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return Res; 15469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 15569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 15669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 15769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Otherwise, just extend the original operand all the way to the larger type. 15869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(N->getOpcode(), NVT, N->getOperand(0)); 15969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 16069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 16169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_FP_ROUND(SDNode *N) { 16269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // NOTE: Assumes input is legal. 16369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (N->getConstantOperandVal(1) == 0) 16469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::FP_ROUND_INREG, N->getOperand(0).getValueType(), 16569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(0), DAG.getValueType(N->getValueType(0))); 16669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If the precision discard isn't needed, just return the operand unrounded. 16769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return N->getOperand(0); 16869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 16969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 17069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_FP_TO_XINT(SDNode *N) { 17169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned NewOpc = N->getOpcode(); 17269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 17369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 17469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If we're promoting a UINT to a larger size, check to see if the new node 17569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // will be legal. If it isn't, check to see if FP_TO_SINT is legal, since 17669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // we can use that instead. This allows us to generate better code for 17769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not 17869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // legal, such as PowerPC. 17969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (N->getOpcode() == ISD::FP_TO_UINT) { 18069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (!TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) && 18169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands (TLI.isOperationLegal(ISD::FP_TO_SINT, NVT) || 18269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands TLI.getOperationAction(ISD::FP_TO_SINT, NVT)==TargetLowering::Custom)) 18369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewOpc = ISD::FP_TO_SINT; 18469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 18569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 18669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(NewOpc, NVT, N->getOperand(0)); 18769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 18869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 18969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SETCC(SDNode *N) { 19069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(isTypeLegal(TLI.getSetCCResultType(N->getOperand(0))) 19169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands && "SetCC type is not legal??"); 19269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SETCC, TLI.getSetCCResultType(N->getOperand(0)), 19369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(0), N->getOperand(1), N->getOperand(2)); 19469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 19569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 19669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_LOAD(LoadSDNode *N) { 197ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands assert(ISD::isUNINDEXEDLoad(N) && "Indexed load during type legalization!"); 19869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 19969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ISD::LoadExtType ExtType = 20069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ISD::isNON_EXTLoad(N) ? ISD::EXTLOAD : N->getExtensionType(); 20169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = DAG.getExtLoad(ExtType, NVT, N->getChain(), N->getBasePtr(), 20269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getSrcValue(), N->getSrcValueOffset(), 20369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getMemoryVT(), N->isVolatile(), 20469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getAlignment()); 20569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 20669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Legalized the chain result - switch anything that used the old chain to 20769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // use the new one. 20869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ReplaceValueWith(SDOperand(N, 1), Res.getValue(1)); 20969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return Res; 21069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 21169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 21269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_BUILD_PAIR(SDNode *N) { 21369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The pair element type may be legal, or may not promote to the same type as 21469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // the result, for example i14 = BUILD_PAIR (i7, i7). Handle all cases. 21569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::ANY_EXTEND, 21669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands TLI.getTypeToTransformTo(N->getValueType(0)), 21769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands JoinIntegers(N->getOperand(0), N->getOperand(1))); 21869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 21969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 22069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_BIT_CONVERT(SDNode *N) { 22169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand InOp = N->getOperand(0); 22269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT InVT = InOp.getValueType(); 22369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NInVT = TLI.getTypeToTransformTo(InVT); 22469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OutVT = TLI.getTypeToTransformTo(N->getValueType(0)); 22569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 22669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands switch (getTypeAction(InVT)) { 22769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands default: 22869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(false && "Unknown type action!"); 22969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 23069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case Legal: 23169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 23269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case PromoteInteger: 23369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (OutVT.getSizeInBits() == NInVT.getSizeInBits()) 23469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The input promotes to the same size. Convert the promoted value. 23569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::BIT_CONVERT, OutVT, GetPromotedInteger(InOp)); 23669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 2374fc4fd657d4266059dac3849133a3a351b03d99dDuncan Sands case SoftenFloat: 23869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Promote the integer operand by hand. 2394fc4fd657d4266059dac3849133a3a351b03d99dDuncan Sands return DAG.getNode(ISD::ANY_EXTEND, OutVT, GetSoftenedFloat(InOp)); 24069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ExpandInteger: 24169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ExpandFloat: 24269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 24369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case Scalarize: 24469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Convert the element to an integer and promote it by hand. 24569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::ANY_EXTEND, OutVT, 24669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands BitConvertToInteger(GetScalarizedVector(InOp))); 24769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case Split: 24869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // For example, i32 = BIT_CONVERT v2i16 on alpha. Convert the split 24969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // pieces of the input into integers and reassemble in the final type. 25069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Lo, Hi; 25169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetSplitVector(N->getOperand(0), Lo, Hi); 25269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Lo = BitConvertToInteger(Lo); 25369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Hi = BitConvertToInteger(Hi); 25469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 25569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (TLI.isBigEndian()) 25669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands std::swap(Lo, Hi); 25769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 25869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands InOp = DAG.getNode(ISD::ANY_EXTEND, 25969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT::getIntegerVT(OutVT.getSizeInBits()), 26069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands JoinIntegers(Lo, Hi)); 26169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::BIT_CONVERT, OutVT, InOp); 26269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 26369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 26469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Otherwise, lower the bit-convert to a store/load from the stack, then 26569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // promote the load. 26669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = CreateStackStoreLoad(InOp, N->getValueType(0)); 26769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return PromoteIntRes_LOAD(cast<LoadSDNode>(Op.Val)); 26869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 26969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 27069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SimpleIntBinOp(SDNode *N) { 27169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The input may have strange things in the top bits of the registers, but 27269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // these operations don't care. They may have weird bits going out, but 27369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // that too is okay if they are integer operations. 27469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = GetPromotedInteger(N->getOperand(0)); 27569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = GetPromotedInteger(N->getOperand(1)); 27669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(N->getOpcode(), LHS.getValueType(), LHS, RHS); 27769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 27869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 27969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SDIV(SDNode *N) { 28069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Sign extend the input. 28169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = GetPromotedInteger(N->getOperand(0)); 28269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = GetPromotedInteger(N->getOperand(1)); 28369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = N->getValueType(0); 28469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands LHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, LHS.getValueType(), LHS, 28569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getValueType(VT)); 28669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands RHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, RHS.getValueType(), RHS, 28769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getValueType(VT)); 28869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 28969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(N->getOpcode(), LHS.getValueType(), LHS, RHS); 29069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 29169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 29269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_UDIV(SDNode *N) { 29369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Zero extend the input. 29469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = GetPromotedInteger(N->getOperand(0)); 29569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = GetPromotedInteger(N->getOperand(1)); 29669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = N->getValueType(0); 29769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands LHS = DAG.getZeroExtendInReg(LHS, VT); 29869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands RHS = DAG.getZeroExtendInReg(RHS, VT); 29969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 30069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(N->getOpcode(), LHS.getValueType(), LHS, RHS); 30169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 30269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 30369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SHL(SDNode *N) { 30469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SHL, TLI.getTypeToTransformTo(N->getValueType(0)), 30569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetPromotedInteger(N->getOperand(0)), N->getOperand(1)); 30669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 30769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 30869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SRA(SDNode *N) { 30969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The input value must be properly sign extended. 31069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = N->getValueType(0); 31169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 31269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = GetPromotedInteger(N->getOperand(0)); 31369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Res, DAG.getValueType(VT)); 31469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SRA, NVT, Res, N->getOperand(1)); 31569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 31669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 31769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SRL(SDNode *N) { 31869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The input value must be properly zero extended. 31969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = N->getValueType(0); 32069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 32169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = ZExtPromotedInteger(N->getOperand(0)); 32269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SRL, NVT, Res, N->getOperand(1)); 32369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 32469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 32569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SELECT(SDNode *N) { 32669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = GetPromotedInteger(N->getOperand(1)); 32769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = GetPromotedInteger(N->getOperand(2)); 32869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SELECT, LHS.getValueType(), N->getOperand(0),LHS,RHS); 32969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 33069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 33169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_SELECT_CC(SDNode *N) { 33269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = GetPromotedInteger(N->getOperand(2)); 33369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = GetPromotedInteger(N->getOperand(3)); 33469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SELECT_CC, LHS.getValueType(), N->getOperand(0), 33569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(1), LHS, RHS, N->getOperand(4)); 33669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 33769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 33869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_CTLZ(SDNode *N) { 33969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 34069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OVT = N->getValueType(0); 34169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = Op.getValueType(); 34269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Zero extend to the promoted type and do the count there. 34369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Op = DAG.getNode(ISD::CTLZ, NVT, DAG.getZeroExtendInReg(Op, OVT)); 34469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Subtract off the extra leading bits in the bigger type. 34569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SUB, NVT, Op, 34669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(NVT.getSizeInBits() - 34769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands OVT.getSizeInBits(), NVT)); 34869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 34969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 35069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_CTPOP(SDNode *N) { 35169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 35269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OVT = N->getValueType(0); 35369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = Op.getValueType(); 35469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Zero extend to the promoted type and do the count there. 35569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::CTPOP, NVT, DAG.getZeroExtendInReg(Op, OVT)); 35669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 35769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 35869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_CTTZ(SDNode *N) { 35969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 36069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OVT = N->getValueType(0); 36169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NVT = Op.getValueType(); 36269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The count is the same in the promoted type except if the original 36369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // value was zero. This can be handled by setting the bit just off 36469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // the top of the original type. 36569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Op = DAG.getNode(ISD::OR, NVT, Op, 36669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // FIXME: Do this using an APINT constant. 36769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(1UL << OVT.getSizeInBits(), NVT)); 36869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::CTTZ, NVT, Op); 36969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 37069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 37169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *N) { 37269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OldVT = N->getValueType(0); 37369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand OldVec = N->getOperand(0); 37469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned OldElts = OldVec.getValueType().getVectorNumElements(); 37569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 37669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (OldElts == 1) { 37769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(!isTypeLegal(OldVec.getValueType()) && 37869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands "Legal one-element vector of a type needing promotion!"); 37969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // It is tempting to follow GetScalarizedVector by a call to 38069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // GetPromotedInteger, but this would be wrong because the 38169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // scalarized value may not yet have been processed. 38269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::ANY_EXTEND, TLI.getTypeToTransformTo(OldVT), 38369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetScalarizedVector(OldVec)); 38469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 38569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 38669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Convert to a vector half as long with an element type of twice the width, 38769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // for example <4 x i16> -> <2 x i32>. 38869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(!(OldElts & 1) && "Odd length vectors not supported!"); 38969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NewVT = MVT::getIntegerVT(2 * OldVT.getSizeInBits()); 39069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OldVT.isSimple() && NewVT.isSimple()); 39169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 39269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand NewVec = DAG.getNode(ISD::BIT_CONVERT, 39369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT::getVectorVT(NewVT, OldElts / 2), 39469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands OldVec); 39569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 39669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Extract the element at OldIdx / 2 from the new vector. 39769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand OldIdx = N->getOperand(1); 39869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand NewIdx = DAG.getNode(ISD::SRL, OldIdx.getValueType(), OldIdx, 39969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(1, TLI.getShiftAmountTy())); 40069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, NewVT, NewVec, NewIdx); 40169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 40269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Select the appropriate half of the element: Lo if OldIdx was even, 40369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Hi if it was odd. 40469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Lo = Elt; 40569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Hi = DAG.getNode(ISD::SRL, NewVT, Elt, 40669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(OldVT.getSizeInBits(), 40769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands TLI.getShiftAmountTy())); 40869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (TLI.isBigEndian()) 40969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands std::swap(Lo, Hi); 41069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 41169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Odd = DAG.getNode(ISD::AND, OldIdx.getValueType(), OldIdx, 41269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(1, TLI.getShiftAmountTy())); 41369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SELECT, NewVT, Odd, Hi, Lo); 41469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 41569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 416d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan SandsSDOperand DAGTypeLegalizer::PromoteIntRes_VAARG(SDNode *N) { 417d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands SDOperand Chain = N->getOperand(0); // Get the chain. 418d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands SDOperand Ptr = N->getOperand(1); // Get the pointer. 419d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands MVT VT = N->getValueType(0); 420d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands 421d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands const Value *V = cast<SrcValueSDNode>(N->getOperand(2))->getValue(); 422d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands SDOperand VAList = DAG.getLoad(TLI.getPointerTy(), Chain, Ptr, V, 0); 423d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands 424d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands // Increment the arg pointer, VAList, to the next vaarg 425d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands // FIXME: should the ABI size be used for the increment? Think of 426d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands // x86 long double (10 bytes long, but aligned on 4 or 8 bytes) or 427d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands // integers of unusual size (such MVT::i1, which gives an increment 428d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands // of zero here!). 429d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands unsigned Increment = VT.getSizeInBits() / 8; 430d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands SDOperand Tmp = DAG.getNode(ISD::ADD, TLI.getPointerTy(), VAList, 431d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands DAG.getConstant(Increment, TLI.getPointerTy())); 432d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands 433d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands // Store the incremented VAList to the pointer. 434d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands Tmp = DAG.getStore(VAList.getValue(1), Tmp, Ptr, V, 0); 435d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands 436d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands // Load the actual argument out of the arg pointer VAList. 437d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands Tmp = DAG.getExtLoad(ISD::EXTLOAD, TLI.getTypeToTransformTo(VT), Tmp, 438d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands VAList, NULL, 0, VT); 439d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands 440d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands // Legalized the chain result - switch anything that used the old chain to 441d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands // use the new one. 442d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands ReplaceValueWith(SDOperand(N, 1), Tmp.getValue(1)); 443d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands return Tmp; 444d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands} 445d3ca9fc9984d036146886a40ad3f73aaf7a424ebDuncan Sands 44669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands//===----------------------------------------------------------------------===// 44769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// Integer Operand Promotion 44869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands//===----------------------------------------------------------------------===// 44969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 45069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// PromoteIntegerOperand - This method is called when the specified operand of 45169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// the specified node is found to need promotion. At this point, all of the 45269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// result types of the node are known to be legal, but other operands of the 45369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// node may need promotion or expansion as well as the specified one. 45469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsbool DAGTypeLegalizer::PromoteIntegerOperand(SDNode *N, unsigned OpNo) { 45569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DEBUG(cerr << "Promote integer operand: "; N->dump(&DAG); cerr << "\n"); 45669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res; 45769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands switch (N->getOpcode()) { 45869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands default: 45969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands#ifndef NDEBUG 46069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands cerr << "PromoteIntegerOperand Op #" << OpNo << ": "; 46169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->dump(&DAG); cerr << "\n"; 46269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands#endif 46369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(0 && "Do not know how to promote this operator's operand!"); 46469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands abort(); 46569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 46669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ANY_EXTEND: Res = PromoteIntOp_ANY_EXTEND(N); break; 46769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ZERO_EXTEND: Res = PromoteIntOp_ZERO_EXTEND(N); break; 46869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SIGN_EXTEND: Res = PromoteIntOp_SIGN_EXTEND(N); break; 46969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::TRUNCATE: Res = PromoteIntOp_TRUNCATE(N); break; 47069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_EXTEND: Res = PromoteIntOp_FP_EXTEND(N); break; 47169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_ROUND: Res = PromoteIntOp_FP_ROUND(N); break; 47269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SINT_TO_FP: 47369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::UINT_TO_FP: Res = PromoteIntOp_INT_TO_FP(N); break; 47469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BUILD_PAIR: Res = PromoteIntOp_BUILD_PAIR(N); break; 47569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 47669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BRCOND: Res = PromoteIntOp_BRCOND(N, OpNo); break; 47769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BR_CC: Res = PromoteIntOp_BR_CC(N, OpNo); break; 47811ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands case ISD::SELECT: Res = PromoteIntOp_SELECT(N, OpNo); break; 4797fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands case ISD::SELECT_CC: Res = PromoteIntOp_SELECT_CC(N, OpNo); break; 48069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETCC: Res = PromoteIntOp_SETCC(N, OpNo); break; 48169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 48269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::STORE: Res = PromoteIntOp_STORE(cast<StoreSDNode>(N), 48369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands OpNo); break; 48469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 48569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BUILD_VECTOR: Res = PromoteIntOp_BUILD_VECTOR(N); break; 48669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::INSERT_VECTOR_ELT: 48769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = PromoteIntOp_INSERT_VECTOR_ELT(N, OpNo); 48869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands break; 48969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 49069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::MEMBARRIER: Res = PromoteIntOp_MEMBARRIER(N); break; 49169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 49269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 49369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If the result is null, the sub-method took care of registering results etc. 49469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (!Res.Val) return false; 49569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If the result is N, the sub-method updated N in place. 49669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (Res.Val == N) { 49769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Mark N as new and remark N and its operands. This allows us to correctly 49869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // revisit N if it needs another step of promotion and allows us to visit 49969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // any new operands to N. 50069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ReanalyzeNode(N); 50169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return true; 50269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 50369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 50469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 && 50569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands "Invalid operand expansion"); 50669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 50769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ReplaceValueWith(SDOperand(N, 0), Res); 50869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return false; 50969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 51069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 51169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_ANY_EXTEND(SDNode *N) { 51269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 51369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::ANY_EXTEND, N->getValueType(0), Op); 51469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 51569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 51669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_ZERO_EXTEND(SDNode *N) { 51769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 51869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Op = DAG.getNode(ISD::ANY_EXTEND, N->getValueType(0), Op); 51969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getZeroExtendInReg(Op, N->getOperand(0).getValueType()); 52069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 52169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 52269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_SIGN_EXTEND(SDNode *N) { 52369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 52469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Op = DAG.getNode(ISD::ANY_EXTEND, N->getValueType(0), Op); 52569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::SIGN_EXTEND_INREG, Op.getValueType(), 52669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Op, DAG.getValueType(N->getOperand(0).getValueType())); 52769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 52869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 52969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_TRUNCATE(SDNode *N) { 53069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 53169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::TRUNCATE, N->getValueType(0), Op); 53269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 53369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 53469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_FP_EXTEND(SDNode *N) { 53569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 53669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::FP_EXTEND, N->getValueType(0), Op); 53769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 53869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 53969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_FP_ROUND(SDNode *N) { 54069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Op = GetPromotedInteger(N->getOperand(0)); 54169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::FP_ROUND, N->getValueType(0), Op, 54269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getIntPtrConstant(0)); 54369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 54469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 54569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_INT_TO_FP(SDNode *N) { 54669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand In = GetPromotedInteger(N->getOperand(0)); 54769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OpVT = N->getOperand(0).getValueType(); 54869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (N->getOpcode() == ISD::UINT_TO_FP) 54969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands In = DAG.getZeroExtendInReg(In, OpVT); 55069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands else 55169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands In = DAG.getNode(ISD::SIGN_EXTEND_INREG, In.getValueType(), 55269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands In, DAG.getValueType(OpVT)); 55369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 55469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), In); 55569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 55669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 55769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_BUILD_PAIR(SDNode *N) { 55869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Since the result type is legal, the operands must promote to it. 55969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OVT = N->getOperand(0).getValueType(); 56069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Lo = GetPromotedInteger(N->getOperand(0)); 56169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Hi = GetPromotedInteger(N->getOperand(1)); 56269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(Lo.getValueType() == N->getValueType(0) && "Operand over promoted?"); 56369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 56469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Lo = DAG.getZeroExtendInReg(Lo, OVT); 56569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Hi = DAG.getNode(ISD::SHL, N->getValueType(0), Hi, 56669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getConstant(OVT.getSizeInBits(), 56769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands TLI.getShiftAmountTy())); 56869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::OR, N->getValueType(0), Lo, Hi); 56969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 57069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 57169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_SELECT(SDNode *N, unsigned OpNo) { 57269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OpNo == 0 && "Only know how to promote condition"); 57369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Cond = GetPromotedInteger(N->getOperand(0)); // Promote condition. 57469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 57569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The top bits of the promoted condition are not necessarily zero, ensure 57669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // that the value is properly zero extended. 57769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned BitWidth = Cond.getValueSizeInBits(); 57869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (!DAG.MaskedValueIsZero(Cond, 57969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands APInt::getHighBitsSet(BitWidth, BitWidth-1))) 58069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Cond = DAG.getZeroExtendInReg(Cond, MVT::i1); 58169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 58269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The chain (Op#0) and basic block destination (Op#2) are always legal types. 58369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), Cond, N->getOperand(1), 58469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(2)); 58569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 58669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 58769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_BRCOND(SDNode *N, unsigned OpNo) { 58869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OpNo == 1 && "only know how to promote condition"); 58969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Cond = GetPromotedInteger(N->getOperand(1)); // Promote condition. 59069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 59169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The top bits of the promoted condition are not necessarily zero, ensure 59269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // that the value is properly zero extended. 59369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned BitWidth = Cond.getValueSizeInBits(); 59469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (!DAG.MaskedValueIsZero(Cond, 59569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands APInt::getHighBitsSet(BitWidth, BitWidth-1))) 59669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Cond = DAG.getZeroExtendInReg(Cond, MVT::i1); 59769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 59869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The chain (Op#0) and basic block destination (Op#2) are always legal types. 59969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), Cond, 60069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(2)); 60169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 60269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 60369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_BR_CC(SDNode *N, unsigned OpNo) { 6047fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands assert(OpNo == 2 && "Don't know how to promote this operand!"); 60569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 60669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = N->getOperand(2); 60769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = N->getOperand(3); 60869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands PromoteSetCCOperands(LHS, RHS, cast<CondCodeSDNode>(N->getOperand(1))->get()); 60969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 61069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The chain (Op#0), CC (#1) and basic block destination (Op#4) are always 61169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // legal types. 61269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), 61369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(1), LHS, RHS, N->getOperand(4)); 61469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 61569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 6167fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_SELECT_CC(SDNode *N, unsigned OpNo) { 6177fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands assert(OpNo == 0 && "Don't know how to promote this operand!"); 6187fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands 6197fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands SDOperand LHS = N->getOperand(0); 6207fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands SDOperand RHS = N->getOperand(1); 6217fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands PromoteSetCCOperands(LHS, RHS, cast<CondCodeSDNode>(N->getOperand(4))->get()); 6227fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands 6237fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands // The CC (#4) and the possible return values (#2 and #3) have legal types. 6247fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), LHS, RHS, N->getOperand(2), 6257fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands N->getOperand(3), N->getOperand(4)); 6267fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands} 6277fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands 62869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_SETCC(SDNode *N, unsigned OpNo) { 6297fc8ab81f5f46dcba0f76b1c546a1d11ccbebe26Duncan Sands assert(OpNo == 0 && "Don't know how to promote this operand!"); 63069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 63169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand LHS = N->getOperand(0); 63269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand RHS = N->getOperand(1); 63369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands PromoteSetCCOperands(LHS, RHS, cast<CondCodeSDNode>(N->getOperand(2))->get()); 63469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 63569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The CC (#2) is always legal. 63669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), LHS, RHS, N->getOperand(2)); 63769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 63869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 63969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// PromoteSetCCOperands - Promote the operands of a comparison. This code is 64069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// shared among BR_CC, SELECT_CC, and SETCC handlers. 64169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::PromoteSetCCOperands(SDOperand &NewLHS,SDOperand &NewRHS, 64269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands ISD::CondCode CCCode) { 64369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VT = NewLHS.getValueType(); 64469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 64569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Get the promoted values. 64669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewLHS = GetPromotedInteger(NewLHS); 64769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewRHS = GetPromotedInteger(NewRHS); 64869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 64969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Otherwise, we have to insert explicit sign or zero extends. Note 65069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // that we could insert sign extends for ALL conditions, but zero extend 65169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // is cheaper on many machines (an AND instead of two shifts), so prefer 65269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // it. 65369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands switch (CCCode) { 65469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands default: assert(0 && "Unknown integer comparison!"); 65569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETEQ: 65669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETNE: 65769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETUGE: 65869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETUGT: 65969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETULE: 66069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETULT: 66169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // ALL of these operations will work if we either sign or zero extend 66269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // the operands (including the unsigned comparisons!). Zero extend is 66369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // usually a simpler/cheaper operation, so prefer it. 66469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewLHS = DAG.getZeroExtendInReg(NewLHS, VT); 66569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewRHS = DAG.getZeroExtendInReg(NewRHS, VT); 66611ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands break; 66769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETGE: 66869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETGT: 66969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETLT: 67069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SETLE: 67169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewLHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, NewLHS.getValueType(), NewLHS, 67269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getValueType(VT)); 67369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewRHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, NewRHS.getValueType(), NewRHS, 67469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DAG.getValueType(VT)); 67511ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands break; 67669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 67769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 67869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 67969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_STORE(StoreSDNode *N, unsigned OpNo){ 680ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!"); 68169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Ch = N->getChain(), Ptr = N->getBasePtr(); 68269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands int SVOffset = N->getSrcValueOffset(); 68369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned Alignment = N->getAlignment(); 68469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands bool isVolatile = N->isVolatile(); 68569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 68669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Val = GetPromotedInteger(N->getValue()); // Get promoted value. 68769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 68869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(!N->isTruncatingStore() && "Cannot promote this store operand!"); 68969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 69069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Truncate the value and store the result. 69169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getTruncStore(Ch, Val, Ptr, N->getSrcValue(), 69269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SVOffset, N->getMemoryVT(), 69369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands isVolatile, Alignment); 69469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 69569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 69669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_BUILD_VECTOR(SDNode *N) { 69769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // The vector type is legal but the element type is not. This implies 69869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // that the vector is a power-of-two in length and that the element 69969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // type does not have a strange size (eg: it is not i1). 70069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT VecVT = N->getValueType(0); 70169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned NumElts = VecVT.getVectorNumElements(); 70269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(!(NumElts & 1) && "Legal vector of one illegal element?"); 70369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 70469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Build a vector of half the length out of elements of twice the bitwidth. 70569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // For example <4 x i16> -> <2 x i32>. 70669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT OldVT = N->getOperand(0).getValueType(); 70769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT NewVT = MVT::getIntegerVT(2 * OldVT.getSizeInBits()); 70869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OldVT.isSimple() && NewVT.isSimple()); 70969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 71069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands std::vector<SDOperand> NewElts; 71169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewElts.reserve(NumElts/2); 71269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 71369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands for (unsigned i = 0; i < NumElts; i += 2) { 71469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Combine two successive elements into one promoted element. 71569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Lo = N->getOperand(i); 71669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Hi = N->getOperand(i+1); 71769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (TLI.isBigEndian()) 71869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands std::swap(Lo, Hi); 71969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewElts.push_back(JoinIntegers(Lo, Hi)); 72069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 72169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 72269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand NewVec = DAG.getNode(ISD::BUILD_VECTOR, 72369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands MVT::getVectorVT(NewVT, NewElts.size()), 72469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands &NewElts[0], NewElts.size()); 72569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 72669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Convert the new vector to the old vector type. 72769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.getNode(ISD::BIT_CONVERT, VecVT, NewVec); 72869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 72969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 73069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_INSERT_VECTOR_ELT(SDNode *N, 73169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands unsigned OpNo) { 73269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (OpNo == 1) { 73369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Promote the inserted value. This is valid because the type does not 73469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // have to match the vector element type. 73569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 73669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Check that any extra bits introduced will be truncated away. 73769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(N->getOperand(1).getValueType().getSizeInBits() >= 73869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getValueType(0).getVectorElementType().getSizeInBits() && 73969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands "Type of inserted value narrower than vector element type!"); 74069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), 74169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetPromotedInteger(N->getOperand(1)), 74269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(2)); 74369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 74469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 74569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(OpNo == 2 && "Different operand and result vector types?"); 74669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 74769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // Promote the index. 74869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Idx = N->getOperand(2); 74969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Idx = DAG.getZeroExtendInReg(GetPromotedInteger(Idx), Idx.getValueType()); 75069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), 75169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands N->getOperand(1), Idx); 75269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 75369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 75469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::PromoteIntOp_MEMBARRIER(SDNode *N) { 75569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand NewOps[6]; 75669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewOps[0] = N->getOperand(0); 75769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands for (unsigned i = 1; i < array_lengthof(NewOps); ++i) { 75869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Flag = GetPromotedInteger(N->getOperand(i)); 75969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands NewOps[i] = DAG.getZeroExtendInReg(Flag, MVT::i1); 76069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands } 76169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands return DAG.UpdateNodeOperands(SDOperand (N, 0), NewOps, 76269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands array_lengthof(NewOps)); 76369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands} 76469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 76569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 76669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands//===----------------------------------------------------------------------===// 76769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// Integer Result Expansion 76869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands//===----------------------------------------------------------------------===// 76969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 77069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// ExpandIntegerResult - This method is called when the specified result of the 771cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// specified node is found to need expansion. At this point, the node may also 772cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// have invalid operands or may have other results that need promotion, we just 773cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// know that (at least) one result needs expansion. 77469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntegerResult(SDNode *N, unsigned ResNo) { 77569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DEBUG(cerr << "Expand integer result: "; N->dump(&DAG); cerr << "\n"); 776cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Lo, Hi; 777cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = Hi = SDOperand(); 778cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 779cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // See if the target wants to custom expand this node. 78069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands if (TLI.getOperationAction(N->getOpcode(), N->getValueType(0)) == 781cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TargetLowering::Custom) { 782cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If the target wants to, allow it to lower this itself. 783cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (SDNode *P = TLI.ExpandOperationResult(N, DAG)) { 784cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Everything that once used N now uses P. We are guaranteed that the 785cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // result value types of N and the result value types of P match. 786cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ReplaceNodeWith(N, P); 787cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 788cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 789cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 790cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 791cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner switch (N->getOpcode()) { 792cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner default: 793cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner#ifndef NDEBUG 79469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands cerr << "ExpandIntegerResult #" << ResNo << ": "; 795cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner N->dump(&DAG); cerr << "\n"; 796cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner#endif 79778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(0 && "Do not know how to expand the result of this operator!"); 798cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner abort(); 79969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 80078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, Lo, Hi); break; 80178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::SELECT: SplitRes_SELECT(N, Lo, Hi); break; 80278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::SELECT_CC: SplitRes_SELECT_CC(N, Lo, Hi); break; 80378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::UNDEF: SplitRes_UNDEF(N, Lo, Hi); break; 80478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 80578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::BIT_CONVERT: ExpandRes_BIT_CONVERT(N, Lo, Hi); break; 80678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::BUILD_PAIR: ExpandRes_BUILD_PAIR(N, Lo, Hi); break; 8074a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands case ISD::EXTRACT_ELEMENT: ExpandRes_EXTRACT_ELEMENT(N, Lo, Hi); break; 80878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::EXTRACT_VECTOR_ELT: ExpandRes_EXTRACT_VECTOR_ELT(N, Lo, Hi); break; 80978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 81069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::Constant: ExpandIntRes_Constant(N, Lo, Hi); break; 81169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ANY_EXTEND: ExpandIntRes_ANY_EXTEND(N, Lo, Hi); break; 81269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::ZERO_EXTEND: ExpandIntRes_ZERO_EXTEND(N, Lo, Hi); break; 81369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SIGN_EXTEND: ExpandIntRes_SIGN_EXTEND(N, Lo, Hi); break; 81469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::AssertZext: ExpandIntRes_AssertZext(N, Lo, Hi); break; 81569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::TRUNCATE: ExpandIntRes_TRUNCATE(N, Lo, Hi); break; 81669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SIGN_EXTEND_INREG: ExpandIntRes_SIGN_EXTEND_INREG(N, Lo, Hi); break; 81769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_TO_SINT: ExpandIntRes_FP_TO_SINT(N, Lo, Hi); break; 81869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::FP_TO_UINT: ExpandIntRes_FP_TO_UINT(N, Lo, Hi); break; 81969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::LOAD: ExpandIntRes_LOAD(cast<LoadSDNode>(N), Lo, Hi); break; 82069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 821cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::AND: 822cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::OR: 82369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::XOR: ExpandIntRes_Logical(N, Lo, Hi); break; 82469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::BSWAP: ExpandIntRes_BSWAP(N, Lo, Hi); break; 825cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::ADD: 82669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SUB: ExpandIntRes_ADDSUB(N, Lo, Hi); break; 827cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::ADDC: 82869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SUBC: ExpandIntRes_ADDSUBC(N, Lo, Hi); break; 829cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::ADDE: 83069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SUBE: ExpandIntRes_ADDSUBE(N, Lo, Hi); break; 83169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::MUL: ExpandIntRes_MUL(N, Lo, Hi); break; 83269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SDIV: ExpandIntRes_SDIV(N, Lo, Hi); break; 83369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SREM: ExpandIntRes_SREM(N, Lo, Hi); break; 83469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::UDIV: ExpandIntRes_UDIV(N, Lo, Hi); break; 83569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::UREM: ExpandIntRes_UREM(N, Lo, Hi); break; 836cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SHL: 837cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SRA: 83869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::SRL: ExpandIntRes_Shift(N, Lo, Hi); break; 839d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 84069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::CTLZ: ExpandIntRes_CTLZ(N, Lo, Hi); break; 84169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::CTPOP: ExpandIntRes_CTPOP(N, Lo, Hi); break; 84269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::CTTZ: ExpandIntRes_CTTZ(N, Lo, Hi); break; 843cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 844d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 845cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If Lo/Hi is null, the sub-method took care of registering results etc. 846cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Lo.Val) 84769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SetExpandedInteger(SDOperand(N, ResNo), Lo, Hi); 848cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 849cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 85069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_Constant(SDNode *N, 851cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 85283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 85383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NBitWidth = NVT.getSizeInBits(); 854f25275cb3c930b579707e33c22c1e1c5682b89d3Dan Gohman const APInt &Cst = cast<ConstantSDNode>(N)->getAPIntValue(); 855f25275cb3c930b579707e33c22c1e1c5682b89d3Dan Gohman Lo = DAG.getConstant(APInt(Cst).trunc(NBitWidth), NVT); 856f25275cb3c930b579707e33c22c1e1c5682b89d3Dan Gohman Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), NVT); 857cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 858cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 85969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_ANY_EXTEND(SDNode *N, 860cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 86183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 862cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Op = N->getOperand(0); 8638e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands if (Op.getValueType().bitsLE(NVT)) { 864cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The low part is any extension of the input (which degenerates to a copy). 865cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::ANY_EXTEND, NVT, Op); 866cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); // The high part is undefined. 867cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 868cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For example, extension of an i48 to an i64. The operand type necessarily 869cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // promotes to the result type, so will end up being expanded too. 87069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(getTypeAction(Op.getValueType()) == PromoteInteger && 871077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands "Only know how to promote this result!"); 87269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = GetPromotedInteger(Op); 873cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(Res.getValueType() == N->getValueType(0) && 874cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "Operand over promoted?"); 875cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Split the promoted operand. This will simplify when it is expanded. 876ac7613a3263caa80d735f3fbf2b9f7b81deabc08Duncan Sands SplitInteger(Res, Lo, Hi); 877cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 878cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 879cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 88069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_ZERO_EXTEND(SDNode *N, 881cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 88283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 883cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Op = N->getOperand(0); 8848e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands if (Op.getValueType().bitsLE(NVT)) { 885cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The low part is zero extension of the input (which degenerates to a copy). 886cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, N->getOperand(0)); 887cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); // The high part is just a zero. 888cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 889cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For example, extension of an i48 to an i64. The operand type necessarily 890cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // promotes to the result type, so will end up being expanded too. 89169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(getTypeAction(Op.getValueType()) == PromoteInteger && 892077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands "Only know how to promote this result!"); 89369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = GetPromotedInteger(Op); 894cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(Res.getValueType() == N->getValueType(0) && 895cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "Operand over promoted?"); 896cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Split the promoted operand. This will simplify when it is expanded. 897ac7613a3263caa80d735f3fbf2b9f7b81deabc08Duncan Sands SplitInteger(Res, Lo, Hi); 898cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = 89983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands Op.getValueType().getSizeInBits() - NVT.getSizeInBits(); 90083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands Hi = DAG.getZeroExtendInReg(Hi, MVT::getIntegerVT(ExcessBits)); 901cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 902cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 903cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 90469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_SIGN_EXTEND(SDNode *N, 905cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 90683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 907cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Op = N->getOperand(0); 9088e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands if (Op.getValueType().bitsLE(NVT)) { 909cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The low part is sign extension of the input (which degenerates to a copy). 910cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, N->getOperand(0)); 911cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The high part is obtained by SRA'ing all but one of the bits of low part. 91283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned LoSize = NVT.getSizeInBits(); 913cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, 914cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(LoSize-1, TLI.getShiftAmountTy())); 915cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 916cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For example, extension of an i48 to an i64. The operand type necessarily 917cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // promotes to the result type, so will end up being expanded too. 91869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(getTypeAction(Op.getValueType()) == PromoteInteger && 919077f9b20d0e8659d00a09046a63e28edf0665ffeDuncan Sands "Only know how to promote this result!"); 92069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand Res = GetPromotedInteger(Op); 921cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(Res.getValueType() == N->getValueType(0) && 922cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "Operand over promoted?"); 923cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Split the promoted operand. This will simplify when it is expanded. 924ac7613a3263caa80d735f3fbf2b9f7b81deabc08Duncan Sands SplitInteger(Res, Lo, Hi); 925cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = 92683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands Op.getValueType().getSizeInBits() - NVT.getSizeInBits(); 927cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, Hi.getValueType(), Hi, 92883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getValueType(MVT::getIntegerVT(ExcessBits))); 929cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 930cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 931cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 93269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_AssertZext(SDNode *N, 933d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands SDOperand &Lo, SDOperand &Hi) { 93469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Lo, Hi); 93583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = Lo.getValueType(); 93683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT(); 93783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NVTBits = NVT.getSizeInBits(); 93883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned EVTBits = EVT.getSizeInBits(); 939d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands 940d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands if (NVTBits < EVTBits) { 941d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Hi = DAG.getNode(ISD::AssertZext, NVT, Hi, 94283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getValueType(MVT::getIntegerVT(EVTBits - NVTBits))); 943d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands } else { 944d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Lo = DAG.getNode(ISD::AssertZext, NVT, Lo, DAG.getValueType(EVT)); 945d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands // The high part must be zero, make it explicit. 946d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Hi = DAG.getConstant(0, NVT); 947d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands } 948d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands} 949d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands 95069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_TRUNCATE(SDNode *N, 951d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands SDOperand &Lo, SDOperand &Hi) { 95283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 953d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Lo = DAG.getNode(ISD::TRUNCATE, NVT, N->getOperand(0)); 954d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Hi = DAG.getNode(ISD::SRL, N->getOperand(0).getValueType(), N->getOperand(0), 95583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits(), 956d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands TLI.getShiftAmountTy())); 957d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands Hi = DAG.getNode(ISD::TRUNCATE, NVT, Hi); 958d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands} 959d885dbdf9eb7a51ebb9a15a85921f27d8219997cDuncan Sands 960cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattnervoid DAGTypeLegalizer:: 96169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsExpandIntRes_SIGN_EXTEND_INREG(SDNode *N, SDOperand &Lo, SDOperand &Hi) { 96269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Lo, Hi); 96383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT(); 964cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 9658e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands if (EVT.bitsLE(Lo.getValueType())) { 966cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // sext_inreg the low part if needed. 967cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, Lo.getValueType(), Lo, 968cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner N->getOperand(1)); 969cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 970cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The high part gets the sign extension from the lo-part. This handles 971cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // things like sextinreg V:i64 from i8. 972cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, Hi.getValueType(), Lo, 97383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(Hi.getValueType().getSizeInBits()-1, 974cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TLI.getShiftAmountTy())); 975cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 976cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For example, extension of an i48 to an i64. Leave the low part alone, 977cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // sext_inreg the high part. 978cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = 97983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands EVT.getSizeInBits() - Lo.getValueType().getSizeInBits(); 980cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, Hi.getValueType(), Hi, 98183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getValueType(MVT::getIntegerVT(ExcessBits))); 982cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 983cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 984cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 98569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDOperand &Lo, 986ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Hi) { 98783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getValueType(0); 98841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Op = N->getOperand(0); 989ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 990ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands if (VT == MVT::i64) { 99141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (Op.getValueType() == MVT::f32) 992ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F32_I64; 99341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f64) 994ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F64_I64; 99541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f80) 996ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F80_I64; 99741edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::ppcf128) 998ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_PPCF128_I64; 999ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } else if (VT == MVT::i128) { 100041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (Op.getValueType() == MVT::f32) 1001ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F32_I128; 100241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f64) 1003ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F64_I128; 100441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f80) 1005ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_F80_I128; 100641edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::ppcf128) 1007ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOSINT_PPCF128_I128; 1008ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } else { 1009ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(0 && "Unexpected fp-to-sint conversion!"); 1010ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } 101141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(LC, VT, &Op, 1, true/*sign irrelevant*/), Lo, Hi); 1012ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1013ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 101469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_FP_TO_UINT(SDNode *N, SDOperand &Lo, 1015ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Hi) { 101683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getValueType(0); 101741edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Op = N->getOperand(0); 1018ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 1019ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands if (VT == MVT::i64) { 102041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (Op.getValueType() == MVT::f32) 1021ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F32_I64; 102241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f64) 1023ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F64_I64; 102441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f80) 1025ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F80_I64; 102641edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::ppcf128) 1027ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_PPCF128_I64; 1028ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } else if (VT == MVT::i128) { 102941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (Op.getValueType() == MVT::f32) 1030ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F32_I128; 103141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f64) 1032ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F64_I128; 103341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::f80) 1034ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_F80_I128; 103541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands else if (Op.getValueType() == MVT::ppcf128) 1036ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands LC = RTLIB::FPTOUINT_PPCF128_I128; 1037ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } else { 1038ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(0 && "Unexpected fp-to-uint conversion!"); 1039ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands } 104041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(LC, VT, &Op, 1, false/*sign irrelevant*/), Lo, Hi); 1041ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1042ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 104369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_LOAD(LoadSDNode *N, 1044cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1045ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands if (ISD::isNormalLoad(N)) { 1046ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands ExpandRes_NormalLoad(N, Lo, Hi); 104778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return; 104878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 104978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 105078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(ISD::isUNINDEXEDLoad(N) && "Indexed load during type legalization!"); 105178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 105283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getValueType(0); 105383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 1054cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Ch = N->getChain(); // Legalize the chain. 1055cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Ptr = N->getBasePtr(); // Legalize the pointer. 1056cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::LoadExtType ExtType = N->getExtensionType(); 1057cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner int SVOffset = N->getSrcValueOffset(); 1058cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned Alignment = N->getAlignment(); 1059cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool isVolatile = N->isVolatile(); 1060cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 106178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(NVT.isByteSized() && "Expanded type not byte sized!"); 1062cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 106378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (N->getMemoryVT().bitsLE(NVT)) { 106483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EVT = N->getMemoryVT(); 1065cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1066cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getExtLoad(ExtType, NVT, Ch, Ptr, N->getSrcValue(), SVOffset, EVT, 1067cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, Alignment); 1068cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1069cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Remember the chain. 1070cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ch = Lo.getValue(1); 1071cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1072cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (ExtType == ISD::SEXTLOAD) { 1073cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The high part is obtained by SRA'ing all but one of the bits of the 1074cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // lo part. 107583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned LoSize = Lo.getValueType().getSizeInBits(); 1076cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, Lo, 1077cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(LoSize-1, TLI.getShiftAmountTy())); 1078cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (ExtType == ISD::ZEXTLOAD) { 1079cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The high part is just a zero. 1080cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); 1081cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1082cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(ExtType == ISD::EXTLOAD && "Unknown extload!"); 1083cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The high part is undefined. 1084cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::UNDEF, NVT); 1085cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1086cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (TLI.isLittleEndian()) { 1087cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Little-endian - low bits are at low addresses. 1088cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getLoad(NVT, Ch, Ptr, N->getSrcValue(), SVOffset, 1089cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, Alignment); 1090cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1091cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = 109283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits(); 109383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NEVT = MVT::getIntegerVT(ExcessBits); 1094cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1095cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Increment the pointer to the other half. 109683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned IncrementSize = NVT.getSizeInBits()/8; 1097cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 10980bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(IncrementSize)); 1099cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getExtLoad(ExtType, NVT, Ch, Ptr, N->getSrcValue(), 1100cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SVOffset+IncrementSize, NEVT, 1101cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, MinAlign(Alignment, IncrementSize)); 1102cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1103cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Build a factor node to remember that this load is independent of the 1104cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // other one. 1105cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ch = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 1106cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi.getValue(1)); 1107cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1108cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Big-endian - high bits are at low addresses. Favor aligned loads at 1109cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // the cost of some bit-fiddling. 111083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EVT = N->getMemoryVT(); 111183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned EBytes = EVT.getStoreSizeInBits()/8; 111283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned IncrementSize = NVT.getSizeInBits()/8; 1113cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = (EBytes - IncrementSize)*8; 1114cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1115cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Load both the high bits and maybe some of the low bits. 1116cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getExtLoad(ExtType, NVT, Ch, Ptr, N->getSrcValue(), SVOffset, 111783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT::getIntegerVT(EVT.getSizeInBits() - ExcessBits), 1118cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, Alignment); 1119cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1120cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Increment the pointer to the other half. 1121cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 11220bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(IncrementSize)); 1123cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Load the rest of the low bits. 1124cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getExtLoad(ISD::ZEXTLOAD, NVT, Ch, Ptr, N->getSrcValue(), 112583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands SVOffset+IncrementSize, 112683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT::getIntegerVT(ExcessBits), 1127cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, MinAlign(Alignment, IncrementSize)); 1128cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1129cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Build a factor node to remember that this load is independent of the 1130cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // other one. 1131cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ch = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 1132cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi.getValue(1)); 1133cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 113483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (ExcessBits < NVT.getSizeInBits()) { 1135cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Transfer low bits from the bottom of Hi to the top of Lo. 1136cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::OR, NVT, Lo, 1137cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SHL, NVT, Hi, 1138cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(ExcessBits, 1139cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TLI.getShiftAmountTy()))); 1140cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Move high bits to the right position in Hi. 1141cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ExtType == ISD::SEXTLOAD ? ISD::SRA : ISD::SRL, NVT, Hi, 114283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits() - ExcessBits, 1143cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TLI.getShiftAmountTy())); 1144cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1145cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1146cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1147cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Legalized the chain result - switch anything that used the old chain to 1148cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // use the new one. 1149cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ReplaceValueWith(SDOperand(N, 1), Ch); 1150cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1151cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 115269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_Logical(SDNode *N, 1153cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1154cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LL, LH, RL, RH; 115569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LL, LH); 115669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(1), RL, RH); 1157cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(N->getOpcode(), LL.getValueType(), LL, RL); 1158cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(N->getOpcode(), LL.getValueType(), LH, RH); 1159cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1160cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 116169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_BSWAP(SDNode *N, 1162cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 116369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Hi, Lo); // Note swapped operands. 1164cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::BSWAP, Lo.getValueType(), Lo); 1165cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::BSWAP, Hi.getValueType(), Hi); 1166cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1167cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 116869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_ADDSUB(SDNode *N, 1169cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1170cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Expand the subcomponents. 1171cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 117269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LHSL, LHSH); 117369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(1), RHSL, RHSH); 1174cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDVTList VTList = DAG.getVTList(LHSL.getValueType(), MVT::Flag); 1175cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LoOps[2] = { LHSL, RHSL }; 1176cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand HiOps[3] = { LHSH, RHSH }; 1177cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1178cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (N->getOpcode() == ISD::ADD) { 1179cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::ADDC, VTList, LoOps, 2); 1180cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner HiOps[2] = Lo.getValue(1); 1181cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::ADDE, VTList, HiOps, 3); 1182cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1183cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SUBC, VTList, LoOps, 2); 1184cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner HiOps[2] = Lo.getValue(1); 1185cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SUBE, VTList, HiOps, 3); 1186cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1187cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1188cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 118969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_ADDSUBC(SDNode *N, 1190cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1191cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Expand the subcomponents. 1192cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 119369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LHSL, LHSH); 119469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(1), RHSL, RHSH); 1195cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDVTList VTList = DAG.getVTList(LHSL.getValueType(), MVT::Flag); 1196cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LoOps[2] = { LHSL, RHSL }; 1197cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand HiOps[3] = { LHSH, RHSH }; 1198cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1199cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (N->getOpcode() == ISD::ADDC) { 1200cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::ADDC, VTList, LoOps, 2); 1201cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner HiOps[2] = Lo.getValue(1); 1202cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::ADDE, VTList, HiOps, 3); 1203cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1204cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SUBC, VTList, LoOps, 2); 1205cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner HiOps[2] = Lo.getValue(1); 1206cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SUBE, VTList, HiOps, 3); 1207cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1208cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1209cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Legalized the flag result - switch anything that used the old flag to 1210cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // use the new one. 1211cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ReplaceValueWith(SDOperand(N, 1), Hi.getValue(1)); 1212cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1213cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 121469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_ADDSUBE(SDNode *N, 1215cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1216cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Expand the subcomponents. 1217cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LHSL, LHSH, RHSL, RHSH; 121869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LHSL, LHSH); 121969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(1), RHSL, RHSH); 1220cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDVTList VTList = DAG.getVTList(LHSL.getValueType(), MVT::Flag); 1221cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LoOps[3] = { LHSL, RHSL, N->getOperand(2) }; 1222cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand HiOps[3] = { LHSH, RHSH }; 1223cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1224cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(N->getOpcode(), VTList, LoOps, 3); 1225cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner HiOps[2] = Lo.getValue(1); 1226cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(N->getOpcode(), VTList, HiOps, 3); 1227cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1228cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Legalized the flag result - switch anything that used the old flag to 1229cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // use the new one. 1230cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ReplaceValueWith(SDOperand(N, 1), Hi.getValue(1)); 1231cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1232cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 123369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_MUL(SDNode *N, 1234cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 123583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getValueType(0); 123683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 123769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1238cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool HasMULHS = TLI.isOperationLegal(ISD::MULHS, NVT); 1239cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool HasMULHU = TLI.isOperationLegal(ISD::MULHU, NVT); 1240cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool HasSMUL_LOHI = TLI.isOperationLegal(ISD::SMUL_LOHI, NVT); 1241cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool HasUMUL_LOHI = TLI.isOperationLegal(ISD::UMUL_LOHI, NVT); 1242cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasMULHU || HasMULHS || HasUMUL_LOHI || HasSMUL_LOHI) { 1243cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LL, LH, RL, RH; 124469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LL, LH); 124569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(1), RL, RH); 124683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned OuterBitSize = VT.getSizeInBits(); 1247e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands unsigned InnerBitSize = NVT.getSizeInBits(); 1248cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned LHSSB = DAG.ComputeNumSignBits(N->getOperand(0)); 1249cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned RHSSB = DAG.ComputeNumSignBits(N->getOperand(1)); 125069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1251e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands APInt HighMask = APInt::getHighBitsSet(OuterBitSize, InnerBitSize); 1252e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands if (DAG.MaskedValueIsZero(N->getOperand(0), HighMask) && 1253e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands DAG.MaskedValueIsZero(N->getOperand(1), HighMask)) { 1254cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The inputs are both zero-extended. 1255cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasUMUL_LOHI) { 1256cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We can emit a umul_lohi. 1257cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::UMUL_LOHI, DAG.getVTList(NVT, NVT), LL, RL); 1258cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = SDOperand(Lo.Val, 1); 1259cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1260cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1261cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasMULHU) { 1262cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We can emit a mulhu+mul. 1263cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 1264cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 1265cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1266cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1267cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1268e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands if (LHSSB > InnerBitSize && RHSSB > InnerBitSize) { 1269cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The input values are both sign-extended. 1270cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasSMUL_LOHI) { 1271cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We can emit a smul_lohi. 1272cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SMUL_LOHI, DAG.getVTList(NVT, NVT), LL, RL); 1273cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = SDOperand(Lo.Val, 1); 1274cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1275cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1276cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasMULHS) { 1277cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We can emit a mulhs+mul. 1278cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 1279cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::MULHS, NVT, LL, RL); 1280cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1281cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1282cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1283cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (HasUMUL_LOHI) { 1284cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Lo,Hi = umul LHS, RHS. 1285cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand UMulLOHI = DAG.getNode(ISD::UMUL_LOHI, 1286cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getVTList(NVT, NVT), LL, RL); 1287cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = UMulLOHI; 1288cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = UMulLOHI.getValue(1); 1289cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 1290cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 1291cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 1292cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 1293cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1294cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1295e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands if (HasMULHU) { 1296e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands Lo = DAG.getNode(ISD::MUL, NVT, LL, RL); 1297e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands Hi = DAG.getNode(ISD::MULHU, NVT, LL, RL); 1298e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands RH = DAG.getNode(ISD::MUL, NVT, LL, RH); 1299e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands LH = DAG.getNode(ISD::MUL, NVT, LH, RL); 1300e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands Hi = DAG.getNode(ISD::ADD, NVT, Hi, RH); 1301e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands Hi = DAG.getNode(ISD::ADD, NVT, Hi, LH); 1302e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands return; 1303e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands } 1304cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 130541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 1306cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If nothing else, we can make a libcall. 1307e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands RTLIB::Libcall LC; 1308e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands switch (VT.getSimpleVT()) { 1309e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands default: 1310e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands assert(false && "Unsupported MUL!"); 1311e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands case MVT::i64: 1312e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands LC = RTLIB::MUL_I64; 1313e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands break; 1314e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands } 1315e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands 131641edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 1317e9c80f4d576bf1ff682958d447c1a60fa9348da3Duncan Sands SplitInteger(MakeLibCall(LC, VT, Ops, 2, true/*sign irrelevant*/), Lo, Hi); 131841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands} 1319cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 132069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_SDIV(SDNode *N, 1321ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1322ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(N->getValueType(0) == MVT::i64 && "Unsupported sdiv!"); 132341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 132441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(RTLIB::SDIV_I64, N->getValueType(0), Ops, 2, true), 132541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands Lo, Hi); 1326ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1327ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 132869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_SREM(SDNode *N, 1329ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1330ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(N->getValueType(0) == MVT::i64 && "Unsupported srem!"); 133141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 133241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(RTLIB::SREM_I64, N->getValueType(0), Ops, 2, true), 133341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands Lo, Hi); 1334ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1335ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 133669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_UDIV(SDNode *N, 1337ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1338ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(N->getValueType(0) == MVT::i64 && "Unsupported udiv!"); 133941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 134041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(RTLIB::UDIV_I64, N->getValueType(0), Ops, 2, false), 134141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands Lo, Hi); 1342ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1343ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands 134469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_UREM(SDNode *N, 1345ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1346ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands assert(N->getValueType(0) == MVT::i64 && "Unsupported urem!"); 134741edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 134841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(RTLIB::UREM_I64, N->getValueType(0), Ops, 2, false), 134941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands Lo, Hi); 1350ddc016cc8592fe5c9379feb42a1fb4fb63164a91Duncan Sands} 1351cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 135269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_Shift(SDNode *N, 1353cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 135483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getValueType(0); 135569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 135669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // If we can emit an efficient shift operation, do so now. Check to see if 1357cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // the RHS is a constant. 1358cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N->getOperand(1))) 1359cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return ExpandShiftByConstant(N, CN->getValue(), Lo, Hi); 1360cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1361cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If we can determine that the high bit of the shift is zero or one, even if 1362cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // the low bits are variable, emit this shift in an optimized form. 1363cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (ExpandShiftWithKnownAmountBit(N, Lo, Hi)) 1364cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 136569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1366cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If this target supports shift_PARTS, use it. First, map to the _PARTS opc. 1367cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned PartsOpc; 136841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (N->getOpcode() == ISD::SHL) { 1369cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner PartsOpc = ISD::SHL_PARTS; 137041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands } else if (N->getOpcode() == ISD::SRL) { 1371cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner PartsOpc = ISD::SRL_PARTS; 137241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands } else { 1373cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(N->getOpcode() == ISD::SRA && "Unknown shift!"); 1374cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner PartsOpc = ISD::SRA_PARTS; 1375cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 137669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1377cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Next check to see if the target supports this SHL_PARTS operation or if it 1378cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // will custom expand it. 137983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 1380cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TargetLowering::LegalizeAction Action = TLI.getOperationAction(PartsOpc, NVT); 1381cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) || 1382cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Action == TargetLowering::Custom) { 1383cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Expand the subcomponents. 1384cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LHSL, LHSH; 138569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), LHSL, LHSH); 138669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1387cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Ops[] = { LHSL, LHSH, N->getOperand(1) }; 138883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = LHSL.getValueType(); 1389cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(PartsOpc, DAG.getNodeValueTypes(VT, VT), 2, Ops, 3); 1390cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = Lo.getValue(1); 1391cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1392cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 139341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 1394cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Otherwise, emit a libcall. 139541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands assert(VT == MVT::i64 && "Unsupported shift!"); 139641edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 139741edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands RTLIB::Libcall LC; 139841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands bool isSigned; 139941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands if (N->getOpcode() == ISD::SHL) { 140041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands LC = RTLIB::SHL_I64; 140141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands isSigned = false; /*sign irrelevant*/ 140241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands } else if (N->getOpcode() == ISD::SRL) { 140341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands LC = RTLIB::SRL_I64; 140441edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands isSigned = false; 140541edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands } else { 140641edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands assert(N->getOpcode() == ISD::SRA && "Unknown shift!"); 140741edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands LC = RTLIB::SRA_I64; 140841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands isSigned = true; 140941edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands } 141041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 141141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SDOperand Ops[2] = { N->getOperand(0), N->getOperand(1) }; 141241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands SplitInteger(MakeLibCall(LC, VT, Ops, 2, isSigned), Lo, Hi); 141341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands} 1414cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 141569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_CTLZ(SDNode *N, 1416d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1417d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands // ctlz (HiLo) -> Hi != 0 ? ctlz(Hi) : (ctlz(Lo)+32) 141869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Lo, Hi); 141983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = Lo.getValueType(); 1420d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 14215b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel SDOperand HiNotZero = DAG.getSetCC(TLI.getSetCCResultType(Hi), Hi, 1422d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands DAG.getConstant(0, NVT), ISD::SETNE); 1423d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 1424d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand LoLZ = DAG.getNode(ISD::CTLZ, NVT, Lo); 1425d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand HiLZ = DAG.getNode(ISD::CTLZ, NVT, Hi); 1426d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 1427d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Lo = DAG.getNode(ISD::SELECT, NVT, HiNotZero, HiLZ, 1428d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands DAG.getNode(ISD::ADD, NVT, LoLZ, 142983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits(), NVT))); 1430d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Hi = DAG.getConstant(0, NVT); 1431d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands} 1432d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 143369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_CTPOP(SDNode *N, 1434d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1435d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands // ctpop(HiLo) -> ctpop(Hi)+ctpop(Lo) 143669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Lo, Hi); 143783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = Lo.getValueType(); 1438d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Lo = DAG.getNode(ISD::ADD, NVT, DAG.getNode(ISD::CTPOP, NVT, Lo), 1439d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands DAG.getNode(ISD::CTPOP, NVT, Hi)); 1440d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Hi = DAG.getConstant(0, NVT); 1441d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands} 1442d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 144369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandIntRes_CTTZ(SDNode *N, 1444d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand &Lo, SDOperand &Hi) { 1445d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands // cttz (HiLo) -> Lo != 0 ? cttz(Lo) : (cttz(Hi)+32) 144669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), Lo, Hi); 144783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = Lo.getValueType(); 1448d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 14495b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel SDOperand LoNotZero = DAG.getSetCC(TLI.getSetCCResultType(Lo), Lo, 1450d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands DAG.getConstant(0, NVT), ISD::SETNE); 1451d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 1452d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand LoLZ = DAG.getNode(ISD::CTTZ, NVT, Lo); 1453d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands SDOperand HiLZ = DAG.getNode(ISD::CTTZ, NVT, Hi); 1454d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands 1455d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Lo = DAG.getNode(ISD::SELECT, NVT, LoNotZero, LoLZ, 1456d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands DAG.getNode(ISD::ADD, NVT, HiLZ, 145783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits(), NVT))); 1458d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands Hi = DAG.getConstant(0, NVT); 1459d462ba853981d45bf9c777564e79dc9e1c850ca6Duncan Sands} 1460cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1461cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// ExpandShiftByConstant - N is a shift by a value that needs to be expanded, 1462cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// and the shift amount is a constant 'Amt'. Expand the operation. 146369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsvoid DAGTypeLegalizer::ExpandShiftByConstant(SDNode *N, unsigned Amt, 1464cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand &Lo, SDOperand &Hi) { 1465cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Expand the incoming operand to be shifted, so that we have its parts 1466cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand InL, InH; 146769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), InL, InH); 146869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 146983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = InL.getValueType(); 147083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned VTBits = N->getValueType(0).getSizeInBits(); 147183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NVTBits = NVT.getSizeInBits(); 147283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ShTy = N->getOperand(1).getValueType(); 1473cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1474cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (N->getOpcode() == ISD::SHL) { 1475cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Amt > VTBits) { 1476cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = Hi = DAG.getConstant(0, NVT); 1477cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt > NVTBits) { 1478cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getConstant(0, NVT); 1479cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Amt-NVTBits,ShTy)); 1480cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt == NVTBits) { 1481cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getConstant(0, NVT); 1482cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = InL; 1483cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1484cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SHL, NVT, InL, DAG.getConstant(Amt, ShTy)); 1485cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::OR, NVT, 1486cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, 1487cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(Amt, ShTy)), 1488cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, 1489cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-Amt, ShTy))); 1490cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1491cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1492cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 149369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1494cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (N->getOpcode() == ISD::SRL) { 1495cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Amt > VTBits) { 1496cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getConstant(0, NVT); 1497cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); 1498cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt > NVTBits) { 1499cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Amt-NVTBits,ShTy)); 1500cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); 1501cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt == NVTBits) { 1502cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = InH; 1503cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); 1504cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1505cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::OR, NVT, 1506cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, 1507cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(Amt, ShTy)), 1508cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, 1509cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-Amt, ShTy))); 1510cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRL, NVT, InH, DAG.getConstant(Amt, ShTy)); 1511cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1512cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1513cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 151469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1515cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(N->getOpcode() == ISD::SRA && "Unknown shift!"); 1516cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Amt > VTBits) { 1517cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = Lo = DAG.getNode(ISD::SRA, NVT, InH, 1518cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 1519cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt > NVTBits) { 1520cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SRA, NVT, InH, 1521cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(Amt-NVTBits, ShTy)); 1522cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, InH, 1523cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 1524cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (Amt == NVTBits) { 1525cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = InH; 1526cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, InH, 1527cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-1, ShTy)); 1528cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1529cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::OR, NVT, 1530cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SRL, NVT, InL, 1531cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(Amt, ShTy)), 1532cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SHL, NVT, InH, 1533cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(NVTBits-Amt, ShTy))); 1534cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, InH, DAG.getConstant(Amt, ShTy)); 1535cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1536cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1537cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1538cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// ExpandShiftWithKnownAmountBit - Try to determine whether we can simplify 1539cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// this shift based on knowledge of the high bit of the shift amount. If we 1540cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// can tell this, we know that it is >= 32 or < 32, without knowing the actual 1541cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner/// shift amount. 1542cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattnerbool DAGTypeLegalizer:: 1543cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris LattnerExpandShiftWithKnownAmountBit(SDNode *N, SDOperand &Lo, SDOperand &Hi) { 154491dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman SDOperand Amt = N->getOperand(1); 154583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 154683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ShTy = Amt.getValueType(); 154783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned ShBits = ShTy.getSizeInBits(); 154883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NVTBits = NVT.getSizeInBits(); 154991dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman assert(isPowerOf2_32(NVTBits) && 1550cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "Expanded integer type size not a power of two!"); 1551cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 155291dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman APInt HighBitMask = APInt::getHighBitsSet(ShBits, ShBits - Log2_32(NVTBits)); 155391dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman APInt KnownZero, KnownOne; 1554cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.ComputeMaskedBits(N->getOperand(1), HighBitMask, KnownZero, KnownOne); 155569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 15569e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // If we don't know anything about the high bits, exit. 1557cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (((KnownZero|KnownOne) & HighBitMask) == 0) 1558cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return false; 1559cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1560cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Get the incoming operand to be shifted. 1561cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand InL, InH; 156269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), InL, InH); 1563cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 15649e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // If we know that any of the high bits of the shift amount are one, then we 15659e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // can do this as a couple of simple shifts. 156691dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman if (KnownOne.intersects(HighBitMask)) { 1567cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Mask out the high bit, which we know is set. 156891dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman Amt = DAG.getNode(ISD::AND, ShTy, Amt, 156991dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman DAG.getConstant(~HighBitMask, ShTy)); 157069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1571cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner switch (N->getOpcode()) { 1572cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner default: assert(0 && "Unknown shift"); 1573cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SHL: 1574cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getConstant(0, NVT); // Low part is zero. 1575cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SHL, NVT, InL, Amt); // High part from Lo part. 1576cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return true; 1577cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SRL: 1578cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getConstant(0, NVT); // Hi part is zero. 1579cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SRL, NVT, InH, Amt); // Lo part from Hi part. 1580cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return true; 1581cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SRA: 1582cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SRA, NVT, InH, // Sign extend high part. 158391dc17ba4991e971c7e89e07642b10817aa28055Dan Gohman DAG.getConstant(NVTBits-1, ShTy)); 1584cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getNode(ISD::SRA, NVT, InH, Amt); // Lo part from Hi part. 1585cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return true; 1586cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1587cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 158869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 15899e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // If we know that all of the high bits of the shift amount are zero, then we 15909e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // can do this as a couple of simple shifts. 15919e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman if ((KnownZero & HighBitMask) == HighBitMask) { 15929e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman // Compute 32-amt. 15939e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman SDOperand Amt2 = DAG.getNode(ISD::SUB, ShTy, 15949e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman DAG.getConstant(NVTBits, ShTy), 15959e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman Amt); 15969e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman unsigned Op1, Op2; 15979e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman switch (N->getOpcode()) { 15989e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman default: assert(0 && "Unknown shift"); 15999e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman case ISD::SHL: Op1 = ISD::SHL; Op2 = ISD::SRL; break; 16009e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman case ISD::SRL: 16019e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman case ISD::SRA: Op1 = ISD::SRL; Op2 = ISD::SHL; break; 16029e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman } 160369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 16049e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman Lo = DAG.getNode(N->getOpcode(), NVT, InL, Amt); 16059e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman Hi = DAG.getNode(ISD::OR, NVT, 16069e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman DAG.getNode(Op1, NVT, InH, Amt), 16079e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman DAG.getNode(Op2, NVT, InL, Amt2)); 16089e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman return true; 16099e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman } 16109e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman 16119e255b7df5a0a629920706e086e78ef89bf2f183Dan Gohman return false; 1612cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1613cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1614cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1615cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner//===----------------------------------------------------------------------===// 161669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands// Integer Operand Expansion 1617cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner//===----------------------------------------------------------------------===// 1618cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 161969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// ExpandIntegerOperand - This method is called when the specified operand of 162069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// the specified node is found to need expansion. At this point, all of the 162169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// result types of the node are known to be legal, but other operands of the 162269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands/// node may need promotion or expansion as well as the specified one. 162369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sandsbool DAGTypeLegalizer::ExpandIntegerOperand(SDNode *N, unsigned OpNo) { 162469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands DEBUG(cerr << "Expand integer operand: "; N->dump(&DAG); cerr << "\n"); 1625cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Res(0, 0); 162669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1627648f880dc907faf5c05f3d79a424597b65758360Duncan Sands if (TLI.getOperationAction(N->getOpcode(), N->getOperand(OpNo).getValueType()) 1628648f880dc907faf5c05f3d79a424597b65758360Duncan Sands == TargetLowering::Custom) 1629cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Res = TLI.LowerOperation(SDOperand(N, 0), DAG); 163069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1631cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Res.Val == 0) { 1632cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner switch (N->getOpcode()) { 1633cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner default: 1634cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner #ifndef NDEBUG 163569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands cerr << "ExpandIntegerOperand Op #" << OpNo << ": "; 1636cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner N->dump(&DAG); cerr << "\n"; 1637cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner #endif 1638cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(0 && "Do not know how to expand this operator's operand!"); 1639cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner abort(); 164069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 164178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::BUILD_VECTOR: Res = ExpandOp_BUILD_VECTOR(N); break; 164278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::BIT_CONVERT: Res = ExpandOp_BIT_CONVERT(N); break; 164378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ISD::EXTRACT_ELEMENT: Res = ExpandOp_EXTRACT_ELEMENT(N); break; 164478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 164569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands case ISD::TRUNCATE: Res = ExpandIntOp_TRUNCATE(N); break; 1646cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1647cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SINT_TO_FP: 164869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = ExpandIntOp_SINT_TO_FP(N->getOperand(0), N->getValueType(0)); 1649cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner break; 1650cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::UINT_TO_FP: 165169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = ExpandIntOp_UINT_TO_FP(N->getOperand(0), N->getValueType(0)); 1652cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner break; 1653051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands 165411ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands case ISD::BR_CC: Res = ExpandIntOp_BR_CC(N); break; 165511ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands case ISD::SELECT_CC: Res = ExpandIntOp_SELECT_CC(N); break; 165611ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands case ISD::SETCC: Res = ExpandIntOp_SETCC(N); break; 1657cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1658cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::STORE: 165969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands Res = ExpandIntOp_STORE(cast<StoreSDNode>(N), OpNo); 1660cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner break; 1661cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1662cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 166369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1664cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If the result is null, the sub-method took care of registering results etc. 1665cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (!Res.Val) return false; 1666cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If the result is N, the sub-method updated N in place. Check to see if any 1667cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // operands are new, and if so, mark them. 1668cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (Res.Val == N) { 1669cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Mark N as new and remark N and its operands. This allows us to correctly 167069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands // revisit N if it needs another step of expansion and allows us to visit 1671cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // any new operands to N. 1672212a11c417e272cc8fd12e66cfe5110c47559e17Duncan Sands ReanalyzeNode(N); 1673cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return true; 1674cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1675cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1676cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 && 1677cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "Invalid operand expansion"); 167869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1679cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ReplaceValueWith(SDOperand(N, 0), Res); 1680cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return false; 1681cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1682cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 168369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_TRUNCATE(SDNode *N) { 1684cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand InL, InH; 168569b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getOperand(0), InL, InH); 1686cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Just truncate the low part of the source. 1687cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.getNode(ISD::TRUNCATE, N->getValueType(0), InL); 1688cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1689cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 169069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_SINT_TO_FP(SDOperand Source, 169183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT DestTy) { 1692cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We know the destination is legal, but that the input needs to be expanded. 169383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT SourceVT = Source.getValueType(); 169469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1695cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Check to see if the target has a custom way to lower this. If so, use it. 1696d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman switch (TLI.getOperationAction(ISD::SINT_TO_FP, SourceVT)) { 1697cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner default: assert(0 && "This action not implemented for this operation!"); 1698cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case TargetLowering::Legal: 1699cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case TargetLowering::Expand: 1700cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner break; // This case is handled below. 1701cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case TargetLowering::Custom: 1702cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand NV = TLI.LowerOperation(DAG.getNode(ISD::SINT_TO_FP, DestTy, 1703cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Source), DAG); 1704cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (NV.Val) return NV; 1705cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner break; // The target lowered this. 1706cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 170769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 170841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 1709d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman if (SourceVT == MVT::i64) { 1710d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman if (DestTy == MVT::f32) 1711d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I64_F32; 1712d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman else { 1713d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman assert(DestTy == MVT::f64 && "Unknown fp value type!"); 1714d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I64_F64; 1715d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman } 1716d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman } else if (SourceVT == MVT::i128) { 1717d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman if (DestTy == MVT::f32) 1718d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I128_F32; 1719d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman else if (DestTy == MVT::f64) 1720d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I128_F64; 1721d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman else if (DestTy == MVT::f80) 1722d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I128_F80; 1723d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman else { 1724d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman assert(DestTy == MVT::ppcf128 && "Unknown fp value type!"); 1725d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman LC = RTLIB::SINTTOFP_I128_PPCF128; 1726d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman } 1727d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman } else { 1728d91446de7a89a22c8ea1cbfd40fe2528467a4ccbDan Gohman assert(0 && "Unknown int value type!"); 1729cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 173041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 173141edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands assert(LC != RTLIB::UNKNOWN_LIBCALL && 173241edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands "Don't know how to expand this SINT_TO_FP!"); 173341edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands return MakeLibCall(LC, DestTy, &Source, 1, true); 1734cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1735cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 173669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_UINT_TO_FP(SDOperand Source, 173783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT DestTy) { 1738cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // We know the destination is legal, but that the input needs to be expanded. 173969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands assert(getTypeAction(Source.getValueType()) == ExpandInteger && 1740cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner "This is not an expansion!"); 174169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1742cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If this is unsigned, and not supported, first perform the conversion to 1743cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // signed, then adjust the result if the sign bit is set. 174469b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands SDOperand SignedConv = ExpandIntOp_SINT_TO_FP(Source, DestTy); 1745cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1746cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // The 64-bit value loaded will be incorrectly if the 'sign bit' of the 1747cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // incoming integer is set. To handle this, we dynamically test to see if 1748cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // it is set, and, if so, add a fudge factor. 1749cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Lo, Hi; 175069b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(Source, Lo, Hi); 175169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 17525b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel SDOperand SignSet = DAG.getSetCC(TLI.getSetCCResultType(Hi), Hi, 1753cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(0, Hi.getValueType()), 1754cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::SETLT); 17550bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner SDOperand Zero = DAG.getIntPtrConstant(0), Four = DAG.getIntPtrConstant(4); 1756cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand CstOffset = DAG.getNode(ISD::SELECT, Zero.getValueType(), 1757cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SignSet, Four, Zero); 1758cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner uint64_t FF = 0x5f800000ULL; 1759cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (TLI.isLittleEndian()) FF <<= 32; 1760cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Constant *FudgeFactor = ConstantInt::get((Type*)Type::Int64Ty, FF); 176169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1762cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 1763cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); 1764cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand FudgeInReg; 1765cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (DestTy == MVT::f32) 1766cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner FudgeInReg = DAG.getLoad(MVT::f32, DAG.getEntryNode(), CPIdx, NULL, 0); 17678e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands else if (DestTy.bitsGT(MVT::f32)) 1768cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // FIXME: Avoid the extend by construction the right constantpool? 1769cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner FudgeInReg = DAG.getExtLoad(ISD::EXTLOAD, DestTy, DAG.getEntryNode(), 1770cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner CPIdx, NULL, 0, MVT::f32); 177169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands else 1772cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(0 && "Unexpected conversion"); 177369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1774cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.getNode(ISD::FADD, DestTy, SignedConv, FudgeInReg); 1775cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1776cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 177769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_BR_CC(SDNode *N) { 1778051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands SDOperand NewLHS = N->getOperand(2), NewRHS = N->getOperand(3); 1779051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get(); 178011ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands IntegerExpandSetCCOperands(NewLHS, NewRHS, CCCode); 1781051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands 1782051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands // If ExpandSetCCOperands returned a scalar, we need to compare the result 1783051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands // against zero to select between true and false values. 1784051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands if (NewRHS.Val == 0) { 1785051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands NewRHS = DAG.getConstant(0, NewLHS.getValueType()); 1786051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands CCCode = ISD::SETNE; 1787051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands } 1788051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands 1789051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands // Update N to have the operands specified. 1790051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), N->getOperand(0), 1791051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands DAG.getCondCode(CCCode), NewLHS, NewRHS, 1792051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands N->getOperand(4)); 1793051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands} 1794051bb7b07504be9f848f7cce802e62ed24980bc5Duncan Sands 179511ac797f5ed142f11aafde3dd76c28a73d84282eDuncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_SELECT_CC(SDNode *N) { 179611ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands SDOperand NewLHS = N->getOperand(0), NewRHS = N->getOperand(1); 179711ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get(); 179811ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands IntegerExpandSetCCOperands(NewLHS, NewRHS, CCCode); 179911ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands 180011ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands // If ExpandSetCCOperands returned a scalar, we need to compare the result 180111ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands // against zero to select between true and false values. 180211ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands if (NewRHS.Val == 0) { 180311ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands NewRHS = DAG.getConstant(0, NewLHS.getValueType()); 180411ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands CCCode = ISD::SETNE; 180511ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands } 180611ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands 180711ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands // Update N to have the operands specified. 180811ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands return DAG.UpdateNodeOperands(SDOperand(N, 0), NewLHS, NewRHS, 180911ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands N->getOperand(2), N->getOperand(3), 181011ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands DAG.getCondCode(CCCode)); 181111ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands} 181211ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands 181369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_SETCC(SDNode *N) { 1814cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand NewLHS = N->getOperand(0), NewRHS = N->getOperand(1); 1815cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get(); 181611ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands IntegerExpandSetCCOperands(NewLHS, NewRHS, CCCode); 181769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1818cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If ExpandSetCCOperands returned a scalar, use it. 181911ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands if (NewRHS.Val == 0) { 182011ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands assert(NewLHS.getValueType() == N->getValueType(0) && 182111ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands "Unexpected setcc expansion!"); 182211ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands return NewLHS; 182311ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands } 1824cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1825cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Otherwise, update N to have the operands specified. 1826cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.UpdateNodeOperands(SDOperand(N, 0), NewLHS, NewRHS, 1827cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getCondCode(CCCode)); 1828cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1829cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 183011ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands/// IntegerExpandSetCCOperands - Expand the operands of a comparison. This code 183111ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands/// is shared among BR_CC, SELECT_CC, and SETCC handlers. 183211ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sandsvoid DAGTypeLegalizer::IntegerExpandSetCCOperands(SDOperand &NewLHS, 183311ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands SDOperand &NewRHS, 183411ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands ISD::CondCode &CCCode) { 1835cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand LHSLo, LHSHi, RHSLo, RHSHi; 183669b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(NewLHS, LHSLo, LHSHi); 183769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(NewRHS, RHSLo, RHSHi); 183841edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 183983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = NewLHS.getValueType(); 184041edfb8ae119d6cf6579046619dd2820ec876065Duncan Sands 1841cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (CCCode == ISD::SETEQ || CCCode == ISD::SETNE) { 184211ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands if (RHSLo == RHSHi) { 184311ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands if (ConstantSDNode *RHSCST = dyn_cast<ConstantSDNode>(RHSLo)) { 1844cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (RHSCST->isAllOnesValue()) { 1845cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Equality comparison to -1. 1846cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = DAG.getNode(ISD::AND, LHSLo.getValueType(), LHSLo, LHSHi); 1847cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = RHSLo; 1848cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1849cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 185011ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands } 185111ac797f5ed142f11aafde3dd76c28a73d84282eDuncan Sands } 185269b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1853cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSLo, RHSLo); 1854cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = DAG.getNode(ISD::XOR, LHSLo.getValueType(), LHSHi, RHSHi); 1855cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = DAG.getNode(ISD::OR, NewLHS.getValueType(), NewLHS, NewRHS); 1856cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = DAG.getConstant(0, NewLHS.getValueType()); 1857cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1858cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 185969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1860cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // If this is a comparison of the sign bit, just look at the top part. 1861cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // X > -1, x < 0 1862cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(NewRHS)) 1863002e5d0a170dadd5c307e0b00d8c7970835837e6Dan Gohman if ((CCCode == ISD::SETLT && CST->isNullValue()) || // X < 0 1864cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner (CCCode == ISD::SETGT && CST->isAllOnesValue())) { // X > -1 1865cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = LHSHi; 1866cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = RHSHi; 1867cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1868cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 186969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1870cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // FIXME: This generated code sucks. 1871cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::CondCode LowCC; 1872cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner switch (CCCode) { 1873cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner default: assert(0 && "Unknown integer setcc!"); 1874cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETLT: 1875cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETULT: LowCC = ISD::SETULT; break; 1876cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETGT: 1877cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETUGT: LowCC = ISD::SETUGT; break; 1878cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETLE: 1879cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETULE: LowCC = ISD::SETULE; break; 1880cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETGE: 1881cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner case ISD::SETUGE: LowCC = ISD::SETUGE; break; 1882cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 188369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1884cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison 1885cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Tmp2 = hi(op1) < hi(op2) // Signedness depends on operands 1886cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // dest = hi(op1) == hi(op2) ? Tmp1 : Tmp2; 188769b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1888cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // NOTE: on targets without efficient SELECT of bools, we can always use 1889cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // this identity: (B1 ? B2 : B3) --> (B1 & B2)|(!B1&B3) 1890cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TargetLowering::DAGCombinerInfo DagCombineInfo(DAG, false, true, NULL); 1891cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Tmp1, Tmp2; 18925b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp1 = TLI.SimplifySetCC(TLI.getSetCCResultType(LHSLo), LHSLo, RHSLo, LowCC, 1893cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner false, DagCombineInfo); 1894cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (!Tmp1.Val) 18955b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp1 = DAG.getSetCC(TLI.getSetCCResultType(LHSLo), LHSLo, RHSLo, LowCC); 18965b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp2 = TLI.SimplifySetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, 1897cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner CCCode, false, DagCombineInfo); 1898cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (!Tmp2.Val) 18995b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel Tmp2 = DAG.getNode(ISD::SETCC, TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, 1900cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getCondCode(CCCode)); 190169b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 1902cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ConstantSDNode *Tmp1C = dyn_cast<ConstantSDNode>(Tmp1.Val); 1903cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ConstantSDNode *Tmp2C = dyn_cast<ConstantSDNode>(Tmp2.Val); 1904002e5d0a170dadd5c307e0b00d8c7970835837e6Dan Gohman if ((Tmp1C && Tmp1C->isNullValue()) || 1905002e5d0a170dadd5c307e0b00d8c7970835837e6Dan Gohman (Tmp2C && Tmp2C->isNullValue() && 1906cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner (CCCode == ISD::SETLE || CCCode == ISD::SETGE || 1907cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner CCCode == ISD::SETUGE || CCCode == ISD::SETULE)) || 1908002e5d0a170dadd5c307e0b00d8c7970835837e6Dan Gohman (Tmp2C && Tmp2C->getAPIntValue() == 1 && 1909cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner (CCCode == ISD::SETLT || CCCode == ISD::SETGT || 1910cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner CCCode == ISD::SETUGT || CCCode == ISD::SETULT))) { 1911cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // low part is known false, returns high part. 1912cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For LE / GE, if high part is known false, ignore the low part. 1913cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // For LT / GT, if high part is known true, ignore the low part. 1914cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = Tmp2; 1915cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = SDOperand(); 1916cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return; 1917cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 191869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands 19195b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel NewLHS = TLI.SimplifySetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, 1920cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner ISD::SETEQ, false, DagCombineInfo); 1921cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner if (!NewLHS.Val) 19225b8f82e35b51bf007de07a7ca9347d804084ddf8Scott Michel NewLHS = DAG.getSetCC(TLI.getSetCCResultType(LHSHi), LHSHi, RHSHi, 192371a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner ISD::SETEQ); 1924cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS = DAG.getNode(ISD::SELECT, Tmp1.getValueType(), 1925cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewLHS, Tmp1, Tmp2); 1926cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner NewRHS = SDOperand(); 1927cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 1928cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 192969b01e92a29ce6d7e435171aeea3fbc987b81586Duncan SandsSDOperand DAGTypeLegalizer::ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo) { 1930ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands if (ISD::isNormalStore(N)) 1931ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands return ExpandOp_NormalStore(N, OpNo); 193278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 193378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!"); 1934cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner assert(OpNo == 1 && "Can only expand the stored value so far"); 1935cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 193683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = N->getOperand(1).getValueType(); 193783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToTransformTo(VT); 1938cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Ch = N->getChain(); 1939cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Ptr = N->getBasePtr(); 1940cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner int SVOffset = N->getSrcValueOffset(); 1941cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned Alignment = N->getAlignment(); 1942cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner bool isVolatile = N->isVolatile(); 1943cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SDOperand Lo, Hi; 1944cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1945a1ace76c70ae5332d6f33fce5c0c1e2fdb8cca11Duncan Sands assert(NVT.isByteSized() && "Expanded type not byte sized!"); 1946cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 194778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (N->getMemoryVT().bitsLE(NVT)) { 194869b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getValue(), Lo, Hi); 1949cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.getTruncStore(Ch, Lo, Ptr, N->getSrcValue(), SVOffset, 1950b625f2f8960de32bc973092aaee8ac62863006feDan Gohman N->getMemoryVT(), isVolatile, Alignment); 1951cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else if (TLI.isLittleEndian()) { 1952cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Little-endian - low bits are at low addresses. 195369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getValue(), Lo, Hi); 1954cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1955cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getStore(Ch, Lo, Ptr, N->getSrcValue(), SVOffset, 1956cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, Alignment); 1957cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1958cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = 195983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits(); 196083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NEVT = MVT::getIntegerVT(ExcessBits); 1961cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1962cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Increment the pointer to the other half. 196383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned IncrementSize = NVT.getSizeInBits()/8; 1964cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 19650bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(IncrementSize)); 1966cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getTruncStore(Ch, Hi, Ptr, N->getSrcValue(), 1967cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SVOffset+IncrementSize, NEVT, 1968cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, MinAlign(Alignment, IncrementSize)); 1969cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 1970cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } else { 1971cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Big-endian - high bits are at low addresses. Favor aligned stores at 1972cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // the cost of some bit-fiddling. 197369b01e92a29ce6d7e435171aeea3fbc987b81586Duncan Sands GetExpandedInteger(N->getValue(), Lo, Hi); 1974cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 197583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EVT = N->getMemoryVT(); 197683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned EBytes = EVT.getStoreSizeInBits()/8; 197783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned IncrementSize = NVT.getSizeInBits()/8; 1978cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner unsigned ExcessBits = (EBytes - IncrementSize)*8; 197983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT HiVT = MVT::getIntegerVT(EVT.getSizeInBits() - ExcessBits); 1980cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 198183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (ExcessBits < NVT.getSizeInBits()) { 1982cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Transfer high bits from the top of Lo to the bottom of Hi. 1983cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::SHL, NVT, Hi, 198483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits() - ExcessBits, 1985cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TLI.getShiftAmountTy())); 1986cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getNode(ISD::OR, NVT, Hi, 1987cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getNode(ISD::SRL, NVT, Lo, 1988cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner DAG.getConstant(ExcessBits, 1989cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner TLI.getShiftAmountTy()))); 1990cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 1991cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1992cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Store both the high bits and maybe some of the low bits. 1993cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Hi = DAG.getTruncStore(Ch, Hi, Ptr, N->getSrcValue(), 1994cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SVOffset, HiVT, isVolatile, Alignment); 1995cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner 1996cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Increment the pointer to the other half. 1997cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 19980bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(IncrementSize)); 1999cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner // Store the lowest ExcessBits bits in the second half. 2000cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner Lo = DAG.getTruncStore(Ch, Lo, Ptr, N->getSrcValue(), 2001cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner SVOffset+IncrementSize, 200283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT::getIntegerVT(ExcessBits), 2003cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner isVolatile, MinAlign(Alignment, IncrementSize)); 2004cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner return DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 2005cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner } 2006cc663a8112017f06e0cd4b6fe1546ccfcd5d05c3Chris Lattner} 2007