1 //===-- SystemZSelectionDAGInfo.cpp - SystemZ SelectionDAG Info -----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the SystemZSelectionDAGInfo class.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "systemz-selectiondag-info"
15 #include "SystemZTargetMachine.h"
16 #include "llvm/CodeGen/SelectionDAG.h"
20 SystemZSelectionDAGInfo::
21 SystemZSelectionDAGInfo(const SystemZTargetMachine &TM)
22 : TargetSelectionDAGInfo(TM) {
25 SystemZSelectionDAGInfo::~SystemZSelectionDAGInfo() {
28 SDValue SystemZSelectionDAGInfo::
29 EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc DL, SDValue Chain,
30 SDValue Dst, SDValue Src, SDValue Size, unsigned Align,
31 bool IsVolatile, bool AlwaysInline,
32 MachinePointerInfo DstPtrInfo,
33 MachinePointerInfo SrcPtrInfo) const {
37 if (ConstantSDNode *CSize = dyn_cast<ConstantSDNode>(Size)) {
38 uint64_t Bytes = CSize->getZExtValue();
39 if (Bytes >= 1 && Bytes <= 0x100) {
41 return DAG.getNode(SystemZISD::MVC, DL, MVT::Other,
42 Chain, Dst, Src, Size);
48 // Handle a memset of 1, 2, 4 or 8 bytes with the operands given by
49 // Chain, Dst, ByteVal and Size. These cases are expected to use
50 // MVI, MVHHI, MVHI and MVGHI respectively.
51 static SDValue memsetStore(SelectionDAG &DAG, SDLoc DL, SDValue Chain,
52 SDValue Dst, uint64_t ByteVal, uint64_t Size,
54 MachinePointerInfo DstPtrInfo) {
55 uint64_t StoreVal = ByteVal;
56 for (unsigned I = 1; I < Size; ++I)
57 StoreVal |= ByteVal << (I * 8);
58 return DAG.getStore(Chain, DL,
59 DAG.getConstant(StoreVal, MVT::getIntegerVT(Size * 8)),
60 Dst, DstPtrInfo, false, false, Align);
63 SDValue SystemZSelectionDAGInfo::
64 EmitTargetCodeForMemset(SelectionDAG &DAG, SDLoc DL, SDValue Chain,
65 SDValue Dst, SDValue Byte, SDValue Size,
66 unsigned Align, bool IsVolatile,
67 MachinePointerInfo DstPtrInfo) const {
68 EVT DstVT = Dst.getValueType();
73 if (ConstantSDNode *CSize = dyn_cast<ConstantSDNode>(Size)) {
74 uint64_t Bytes = CSize->getZExtValue();
77 if (ConstantSDNode *CByte = dyn_cast<ConstantSDNode>(Byte)) {
78 // Handle cases that can be done using at most two of
79 // MVI, MVHI, MVHHI and MVGHI. The latter two can only be
80 // used if ByteVal is all zeros or all ones; in other casees,
81 // we can move at most 2 halfwords.
82 uint64_t ByteVal = CByte->getZExtValue();
83 if (ByteVal == 0 || ByteVal == 255 ?
84 Bytes <= 16 && CountPopulation_64(Bytes) <= 2 :
86 unsigned Size1 = Bytes == 16 ? 8 : 1 << findLastSet(Bytes);
87 unsigned Size2 = Bytes - Size1;
88 SDValue Chain1 = memsetStore(DAG, DL, Chain, Dst, ByteVal, Size1,
92 Dst = DAG.getNode(ISD::ADD, DL, DstVT, Dst,
93 DAG.getConstant(Size1, DstVT));
94 DstPtrInfo = DstPtrInfo.getWithOffset(Size1);
95 SDValue Chain2 = memsetStore(DAG, DL, Chain, Dst, ByteVal, Size2,
96 std::min(Align, Size1), DstPtrInfo);
97 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2);
100 // Handle one and two bytes using STC.
102 SDValue Chain1 = DAG.getStore(Chain, DL, Byte, Dst, DstPtrInfo,
103 false, false, Align);
106 SDValue Dst2 = DAG.getNode(ISD::ADD, DL, DstVT, Dst,
107 DAG.getConstant(1, DstVT));
108 SDValue Chain2 = DAG.getStore(Chain, DL, Byte, Dst2,
109 DstPtrInfo.getWithOffset(1),
111 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2);
114 assert(Bytes >= 2 && "Should have dealt with 0- and 1-byte cases already");
115 if (Bytes <= 0x101) {
116 // Copy the byte to the first location and then use MVC to copy
118 Chain = DAG.getStore(Chain, DL, Byte, Dst, DstPtrInfo,
119 false, false, Align);
120 SDValue Dst2 = DAG.getNode(ISD::ADD, DL, DstVT, Dst,
121 DAG.getConstant(1, DstVT));
122 return DAG.getNode(SystemZISD::MVC, DL, MVT::Other, Chain, Dst2, Dst,
123 DAG.getConstant(Bytes - 1, MVT::i32));
129 std::pair<SDValue, SDValue> SystemZSelectionDAGInfo::
130 EmitTargetCodeForMemcmp(SelectionDAG &DAG, SDLoc DL, SDValue Chain,
131 SDValue Src1, SDValue Src2, SDValue Size,
132 MachinePointerInfo Op1PtrInfo,
133 MachinePointerInfo Op2PtrInfo) const {
134 if (ConstantSDNode *CSize = dyn_cast<ConstantSDNode>(Size)) {
135 uint64_t Bytes = CSize->getZExtValue();
136 if (Bytes >= 1 && Bytes <= 0x100) {
138 SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
139 Chain = DAG.getNode(SystemZISD::CLC, DL, VTs, Chain,
141 SDValue Glue = Chain.getValue(1);
142 // IPM inserts the CC value into bits 29 and 28, with 0 meaning "equal",
143 // 1 meaning "greater" and 2 meaning "less". Convert them into an
144 // integer that is respectively equal, greater or less than 0.
145 SDValue IPM = DAG.getNode(SystemZISD::IPM, DL, MVT::i32, Glue);
146 SDValue SHL = DAG.getNode(ISD::SHL, DL, MVT::i32, IPM,
147 DAG.getConstant(2, MVT::i32));
148 SDValue SRA = DAG.getNode(ISD::SRA, DL, MVT::i32, SHL,
149 DAG.getConstant(30, MVT::i32));
150 return std::make_pair(SRA, Chain);
153 return std::make_pair(SDValue(), SDValue());