1 //===-- SystemZSelectionDAGInfo.cpp - SystemZ SelectionDAG Info -----------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the SystemZSelectionDAGInfo class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "SystemZTargetMachine.h" 14 #include "llvm/CodeGen/SelectionDAG.h" 15 16 using namespace llvm; 17 18 #define DEBUG_TYPE "systemz-selectiondag-info" 19 20 static SDVTList getMemMemVTs(unsigned Op, SelectionDAG &DAG) { 21 return Op == SystemZISD::CLC ? DAG.getVTList(MVT::i32, MVT::Other) 22 : DAG.getVTList(MVT::Other); 23 } 24 25 // Emit a mem-mem operation after subtracting one from size, which will be 26 // added back during pseudo expansion. As the Reg case emitted here may be 27 // converted by DAGCombiner into having an Imm length, they are both emitted 28 // the same way. 29 static SDValue emitMemMemImm(SelectionDAG &DAG, const SDLoc &DL, unsigned Op, 30 SDValue Chain, SDValue Dst, SDValue Src, 31 uint64_t Size) { 32 return DAG.getNode(Op, DL, getMemMemVTs(Op, DAG), Chain, Dst, Src, 33 DAG.getConstant(Size - 1, DL, Src.getValueType())); 34 } 35 36 static SDValue emitMemMemReg(SelectionDAG &DAG, const SDLoc &DL, unsigned Op, 37 SDValue Chain, SDValue Dst, SDValue Src, 38 SDValue Size) { 39 SDValue LenMinus1 = DAG.getNode(ISD::ADD, DL, MVT::i64, 40 DAG.getZExtOrTrunc(Size, DL, MVT::i64), 41 DAG.getConstant(-1, DL, MVT::i64)); 42 return DAG.getNode(Op, DL, getMemMemVTs(Op, DAG), Chain, Dst, Src, LenMinus1); 43 } 44 45 SDValue SystemZSelectionDAGInfo::EmitTargetCodeForMemcpy( 46 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dst, SDValue Src, 47 SDValue Size, Align Alignment, bool IsVolatile, bool AlwaysInline, 48 MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo) const { 49 if (IsVolatile) 50 return SDValue(); 51 52 if (auto *CSize = dyn_cast<ConstantSDNode>(Size)) 53 return emitMemMemImm(DAG, DL, SystemZISD::MVC, Chain, Dst, Src, 54 CSize->getZExtValue()); 55 56 return emitMemMemReg(DAG, DL, SystemZISD::MVC, Chain, Dst, Src, Size); 57 } 58 59 // Handle a memset of 1, 2, 4 or 8 bytes with the operands given by 60 // Chain, Dst, ByteVal and Size. These cases are expected to use 61 // MVI, MVHHI, MVHI and MVGHI respectively. 62 static SDValue memsetStore(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, 63 SDValue Dst, uint64_t ByteVal, uint64_t Size, 64 unsigned Align, MachinePointerInfo DstPtrInfo) { 65 uint64_t StoreVal = ByteVal; 66 for (unsigned I = 1; I < Size; ++I) 67 StoreVal |= ByteVal << (I * 8); 68 return DAG.getStore( 69 Chain, DL, DAG.getConstant(StoreVal, DL, MVT::getIntegerVT(Size * 8)), 70 Dst, DstPtrInfo, Align); 71 } 72 73 SDValue SystemZSelectionDAGInfo::EmitTargetCodeForMemset( 74 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dst, 75 SDValue Byte, SDValue Size, Align Alignment, bool IsVolatile, 76 MachinePointerInfo DstPtrInfo) const { 77 EVT PtrVT = Dst.getValueType(); 78 79 if (IsVolatile) 80 return SDValue(); 81 82 auto *CByte = dyn_cast<ConstantSDNode>(Byte); 83 if (auto *CSize = dyn_cast<ConstantSDNode>(Size)) { 84 uint64_t Bytes = CSize->getZExtValue(); 85 if (Bytes == 0) 86 return SDValue(); 87 if (CByte) { 88 // Handle cases that can be done using at most two of 89 // MVI, MVHI, MVHHI and MVGHI. The latter two can only be 90 // used if ByteVal is all zeros or all ones; in other casees, 91 // we can move at most 2 halfwords. 92 uint64_t ByteVal = CByte->getZExtValue(); 93 if (ByteVal == 0 || ByteVal == 255 ? 94 Bytes <= 16 && countPopulation(Bytes) <= 2 : 95 Bytes <= 4) { 96 unsigned Size1 = Bytes == 16 ? 8 : 1 << findLastSet(Bytes); 97 unsigned Size2 = Bytes - Size1; 98 SDValue Chain1 = memsetStore(DAG, DL, Chain, Dst, ByteVal, Size1, 99 Alignment.value(), DstPtrInfo); 100 if (Size2 == 0) 101 return Chain1; 102 Dst = DAG.getNode(ISD::ADD, DL, PtrVT, Dst, 103 DAG.getConstant(Size1, DL, PtrVT)); 104 DstPtrInfo = DstPtrInfo.getWithOffset(Size1); 105 SDValue Chain2 = memsetStore( 106 DAG, DL, Chain, Dst, ByteVal, Size2, 107 std::min((unsigned)Alignment.value(), Size1), DstPtrInfo); 108 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2); 109 } 110 } else { 111 // Handle one and two bytes using STC. 112 if (Bytes <= 2) { 113 SDValue Chain1 = 114 DAG.getStore(Chain, DL, Byte, Dst, DstPtrInfo, Alignment); 115 if (Bytes == 1) 116 return Chain1; 117 SDValue Dst2 = DAG.getNode(ISD::ADD, DL, PtrVT, Dst, 118 DAG.getConstant(1, DL, PtrVT)); 119 SDValue Chain2 = DAG.getStore(Chain, DL, Byte, Dst2, 120 DstPtrInfo.getWithOffset(1), Align(1)); 121 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2); 122 } 123 } 124 assert(Bytes >= 2 && "Should have dealt with 0- and 1-byte cases already"); 125 126 // Handle the special case of a memset of 0, which can use XC. 127 if (CByte && CByte->getZExtValue() == 0) 128 return emitMemMemImm(DAG, DL, SystemZISD::XC, Chain, Dst, Dst, Bytes); 129 130 // Copy the byte to the first location and then use MVC to copy 131 // it to the rest. 132 Chain = DAG.getStore(Chain, DL, Byte, Dst, DstPtrInfo, Alignment); 133 SDValue DstPlus1 = DAG.getNode(ISD::ADD, DL, PtrVT, Dst, 134 DAG.getConstant(1, DL, PtrVT)); 135 return emitMemMemImm(DAG, DL, SystemZISD::MVC, Chain, DstPlus1, Dst, 136 Bytes - 1); 137 } 138 139 // Variable length 140 if (CByte && CByte->getZExtValue() == 0) 141 // Handle the special case of a variable length memset of 0 with XC. 142 return emitMemMemReg(DAG, DL, SystemZISD::XC, Chain, Dst, Dst, Size); 143 144 return SDValue(); 145 } 146 147 // Convert the current CC value into an integer that is 0 if CC == 0, 148 // greater than zero if CC == 1 and less than zero if CC >= 2. 149 // The sequence starts with IPM, which puts CC into bits 29 and 28 150 // of an integer and clears bits 30 and 31. 151 static SDValue addIPMSequence(const SDLoc &DL, SDValue CCReg, 152 SelectionDAG &DAG) { 153 SDValue IPM = DAG.getNode(SystemZISD::IPM, DL, MVT::i32, CCReg); 154 SDValue SHL = DAG.getNode(ISD::SHL, DL, MVT::i32, IPM, 155 DAG.getConstant(30 - SystemZ::IPM_CC, DL, MVT::i32)); 156 SDValue SRA = DAG.getNode(ISD::SRA, DL, MVT::i32, SHL, 157 DAG.getConstant(30, DL, MVT::i32)); 158 return SRA; 159 } 160 161 std::pair<SDValue, SDValue> SystemZSelectionDAGInfo::EmitTargetCodeForMemcmp( 162 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src1, 163 SDValue Src2, SDValue Size, MachinePointerInfo Op1PtrInfo, 164 MachinePointerInfo Op2PtrInfo) const { 165 SDValue CCReg; 166 // Swap operands to invert CC == 1 vs. CC == 2 cases. 167 if (auto *CSize = dyn_cast<ConstantSDNode>(Size)) { 168 uint64_t Bytes = CSize->getZExtValue(); 169 assert(Bytes > 0 && "Caller should have handled 0-size case"); 170 CCReg = emitMemMemImm(DAG, DL, SystemZISD::CLC, Chain, Src2, Src1, Bytes); 171 } else 172 CCReg = emitMemMemReg(DAG, DL, SystemZISD::CLC, Chain, Src2, Src1, Size); 173 Chain = CCReg.getValue(1); 174 return std::make_pair(addIPMSequence(DL, CCReg, DAG), Chain); 175 } 176 177 std::pair<SDValue, SDValue> SystemZSelectionDAGInfo::EmitTargetCodeForMemchr( 178 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src, 179 SDValue Char, SDValue Length, MachinePointerInfo SrcPtrInfo) const { 180 // Use SRST to find the character. End is its address on success. 181 EVT PtrVT = Src.getValueType(); 182 SDVTList VTs = DAG.getVTList(PtrVT, MVT::i32, MVT::Other); 183 Length = DAG.getZExtOrTrunc(Length, DL, PtrVT); 184 Char = DAG.getZExtOrTrunc(Char, DL, MVT::i32); 185 Char = DAG.getNode(ISD::AND, DL, MVT::i32, Char, 186 DAG.getConstant(255, DL, MVT::i32)); 187 SDValue Limit = DAG.getNode(ISD::ADD, DL, PtrVT, Src, Length); 188 SDValue End = DAG.getNode(SystemZISD::SEARCH_STRING, DL, VTs, Chain, 189 Limit, Src, Char); 190 SDValue CCReg = End.getValue(1); 191 Chain = End.getValue(2); 192 193 // Now select between End and null, depending on whether the character 194 // was found. 195 SDValue Ops[] = { 196 End, DAG.getConstant(0, DL, PtrVT), 197 DAG.getTargetConstant(SystemZ::CCMASK_SRST, DL, MVT::i32), 198 DAG.getTargetConstant(SystemZ::CCMASK_SRST_FOUND, DL, MVT::i32), CCReg}; 199 End = DAG.getNode(SystemZISD::SELECT_CCMASK, DL, PtrVT, Ops); 200 return std::make_pair(End, Chain); 201 } 202 203 std::pair<SDValue, SDValue> SystemZSelectionDAGInfo::EmitTargetCodeForStrcpy( 204 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dest, 205 SDValue Src, MachinePointerInfo DestPtrInfo, MachinePointerInfo SrcPtrInfo, 206 bool isStpcpy) const { 207 SDVTList VTs = DAG.getVTList(Dest.getValueType(), MVT::Other); 208 SDValue EndDest = DAG.getNode(SystemZISD::STPCPY, DL, VTs, Chain, Dest, Src, 209 DAG.getConstant(0, DL, MVT::i32)); 210 return std::make_pair(isStpcpy ? EndDest : Dest, EndDest.getValue(1)); 211 } 212 213 std::pair<SDValue, SDValue> SystemZSelectionDAGInfo::EmitTargetCodeForStrcmp( 214 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src1, 215 SDValue Src2, MachinePointerInfo Op1PtrInfo, 216 MachinePointerInfo Op2PtrInfo) const { 217 SDVTList VTs = DAG.getVTList(Src1.getValueType(), MVT::i32, MVT::Other); 218 // Swap operands to invert CC == 1 vs. CC == 2 cases. 219 SDValue Unused = DAG.getNode(SystemZISD::STRCMP, DL, VTs, Chain, Src2, Src1, 220 DAG.getConstant(0, DL, MVT::i32)); 221 SDValue CCReg = Unused.getValue(1); 222 Chain = Unused.getValue(2); 223 return std::make_pair(addIPMSequence(DL, CCReg, DAG), Chain); 224 } 225 226 // Search from Src for a null character, stopping once Src reaches Limit. 227 // Return a pair of values, the first being the number of nonnull characters 228 // and the second being the out chain. 229 // 230 // This can be used for strlen by setting Limit to 0. 231 static std::pair<SDValue, SDValue> getBoundedStrlen(SelectionDAG &DAG, 232 const SDLoc &DL, 233 SDValue Chain, SDValue Src, 234 SDValue Limit) { 235 EVT PtrVT = Src.getValueType(); 236 SDVTList VTs = DAG.getVTList(PtrVT, MVT::i32, MVT::Other); 237 SDValue End = DAG.getNode(SystemZISD::SEARCH_STRING, DL, VTs, Chain, 238 Limit, Src, DAG.getConstant(0, DL, MVT::i32)); 239 Chain = End.getValue(2); 240 SDValue Len = DAG.getNode(ISD::SUB, DL, PtrVT, End, Src); 241 return std::make_pair(Len, Chain); 242 } 243 244 std::pair<SDValue, SDValue> SystemZSelectionDAGInfo::EmitTargetCodeForStrlen( 245 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src, 246 MachinePointerInfo SrcPtrInfo) const { 247 EVT PtrVT = Src.getValueType(); 248 return getBoundedStrlen(DAG, DL, Chain, Src, DAG.getConstant(0, DL, PtrVT)); 249 } 250 251 std::pair<SDValue, SDValue> SystemZSelectionDAGInfo::EmitTargetCodeForStrnlen( 252 SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src, 253 SDValue MaxLength, MachinePointerInfo SrcPtrInfo) const { 254 EVT PtrVT = Src.getValueType(); 255 MaxLength = DAG.getZExtOrTrunc(MaxLength, DL, PtrVT); 256 SDValue Limit = DAG.getNode(ISD::ADD, DL, PtrVT, Src, MaxLength); 257 return getBoundedStrlen(DAG, DL, Chain, Src, Limit); 258 } 259