1//===-- X86InstrFoldTables.cpp - X86 Instruction Folding Tables -----------===//
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 contains the X86 memory folding tables.
10//
11//===----------------------------------------------------------------------===//
12
13#include "X86InstrFoldTables.h"
14#include "X86InstrInfo.h"
15#include "llvm/ADT/STLExtras.h"
16#include <atomic>
17#include <vector>
18
19using namespace llvm;
20
21// These tables are sorted by their RegOp value allowing them to be binary
22// searched at runtime without the need for additional storage. The enum values
23// are currently emitted in X86GenInstrInfo.inc in alphabetical order. Which
24// makes sorting these tables a simple matter of alphabetizing the table.
25#include "X86GenFoldTables.inc"
26
27// Table to map instructions safe to broadcast using a different width from the
28// element width.
29static const X86FoldTableEntry BroadcastSizeTable2[] = {
30 { .KeyOp: X86::VANDNPDZ128rr, .DstOp: X86::VANDNPSZ128rmb, .Flags: TB_BCAST_SS },
31 { .KeyOp: X86::VANDNPDZ256rr, .DstOp: X86::VANDNPSZ256rmb, .Flags: TB_BCAST_SS },
32 { .KeyOp: X86::VANDNPDZrr, .DstOp: X86::VANDNPSZrmb, .Flags: TB_BCAST_SS },
33 { .KeyOp: X86::VANDNPSZ128rr, .DstOp: X86::VANDNPDZ128rmb, .Flags: TB_BCAST_SD },
34 { .KeyOp: X86::VANDNPSZ256rr, .DstOp: X86::VANDNPDZ256rmb, .Flags: TB_BCAST_SD },
35 { .KeyOp: X86::VANDNPSZrr, .DstOp: X86::VANDNPDZrmb, .Flags: TB_BCAST_SD },
36 { .KeyOp: X86::VANDPDZ128rr, .DstOp: X86::VANDPSZ128rmb, .Flags: TB_BCAST_SS },
37 { .KeyOp: X86::VANDPDZ256rr, .DstOp: X86::VANDPSZ256rmb, .Flags: TB_BCAST_SS },
38 { .KeyOp: X86::VANDPDZrr, .DstOp: X86::VANDPSZrmb, .Flags: TB_BCAST_SS },
39 { .KeyOp: X86::VANDPSZ128rr, .DstOp: X86::VANDPDZ128rmb, .Flags: TB_BCAST_SD },
40 { .KeyOp: X86::VANDPSZ256rr, .DstOp: X86::VANDPDZ256rmb, .Flags: TB_BCAST_SD },
41 { .KeyOp: X86::VANDPSZrr, .DstOp: X86::VANDPDZrmb, .Flags: TB_BCAST_SD },
42 { .KeyOp: X86::VORPDZ128rr, .DstOp: X86::VORPSZ128rmb, .Flags: TB_BCAST_SS },
43 { .KeyOp: X86::VORPDZ256rr, .DstOp: X86::VORPSZ256rmb, .Flags: TB_BCAST_SS },
44 { .KeyOp: X86::VORPDZrr, .DstOp: X86::VORPSZrmb, .Flags: TB_BCAST_SS },
45 { .KeyOp: X86::VORPSZ128rr, .DstOp: X86::VORPDZ128rmb, .Flags: TB_BCAST_SD },
46 { .KeyOp: X86::VORPSZ256rr, .DstOp: X86::VORPDZ256rmb, .Flags: TB_BCAST_SD },
47 { .KeyOp: X86::VORPSZrr, .DstOp: X86::VORPDZrmb, .Flags: TB_BCAST_SD },
48 { .KeyOp: X86::VPANDDZ128rr, .DstOp: X86::VPANDQZ128rmb, .Flags: TB_BCAST_Q },
49 { .KeyOp: X86::VPANDDZ256rr, .DstOp: X86::VPANDQZ256rmb, .Flags: TB_BCAST_Q },
50 { .KeyOp: X86::VPANDDZrr, .DstOp: X86::VPANDQZrmb, .Flags: TB_BCAST_Q },
51 { .KeyOp: X86::VPANDNDZ128rr, .DstOp: X86::VPANDNQZ128rmb, .Flags: TB_BCAST_Q },
52 { .KeyOp: X86::VPANDNDZ256rr, .DstOp: X86::VPANDNQZ256rmb, .Flags: TB_BCAST_Q },
53 { .KeyOp: X86::VPANDNDZrr, .DstOp: X86::VPANDNQZrmb, .Flags: TB_BCAST_Q },
54 { .KeyOp: X86::VPANDNQZ128rr, .DstOp: X86::VPANDNDZ128rmb, .Flags: TB_BCAST_D },
55 { .KeyOp: X86::VPANDNQZ256rr, .DstOp: X86::VPANDNDZ256rmb, .Flags: TB_BCAST_D },
56 { .KeyOp: X86::VPANDNQZrr, .DstOp: X86::VPANDNDZrmb, .Flags: TB_BCAST_D },
57 { .KeyOp: X86::VPANDQZ128rr, .DstOp: X86::VPANDDZ128rmb, .Flags: TB_BCAST_D },
58 { .KeyOp: X86::VPANDQZ256rr, .DstOp: X86::VPANDDZ256rmb, .Flags: TB_BCAST_D },
59 { .KeyOp: X86::VPANDQZrr, .DstOp: X86::VPANDDZrmb, .Flags: TB_BCAST_D },
60 { .KeyOp: X86::VPORDZ128rr, .DstOp: X86::VPORQZ128rmb, .Flags: TB_BCAST_Q },
61 { .KeyOp: X86::VPORDZ256rr, .DstOp: X86::VPORQZ256rmb, .Flags: TB_BCAST_Q },
62 { .KeyOp: X86::VPORDZrr, .DstOp: X86::VPORQZrmb, .Flags: TB_BCAST_Q },
63 { .KeyOp: X86::VPORQZ128rr, .DstOp: X86::VPORDZ128rmb, .Flags: TB_BCAST_D },
64 { .KeyOp: X86::VPORQZ256rr, .DstOp: X86::VPORDZ256rmb, .Flags: TB_BCAST_D },
65 { .KeyOp: X86::VPORQZrr, .DstOp: X86::VPORDZrmb, .Flags: TB_BCAST_D },
66 { .KeyOp: X86::VPXORDZ128rr, .DstOp: X86::VPXORQZ128rmb, .Flags: TB_BCAST_Q },
67 { .KeyOp: X86::VPXORDZ256rr, .DstOp: X86::VPXORQZ256rmb, .Flags: TB_BCAST_Q },
68 { .KeyOp: X86::VPXORDZrr, .DstOp: X86::VPXORQZrmb, .Flags: TB_BCAST_Q },
69 { .KeyOp: X86::VPXORQZ128rr, .DstOp: X86::VPXORDZ128rmb, .Flags: TB_BCAST_D },
70 { .KeyOp: X86::VPXORQZ256rr, .DstOp: X86::VPXORDZ256rmb, .Flags: TB_BCAST_D },
71 { .KeyOp: X86::VPXORQZrr, .DstOp: X86::VPXORDZrmb, .Flags: TB_BCAST_D },
72 { .KeyOp: X86::VXORPDZ128rr, .DstOp: X86::VXORPSZ128rmb, .Flags: TB_BCAST_SS },
73 { .KeyOp: X86::VXORPDZ256rr, .DstOp: X86::VXORPSZ256rmb, .Flags: TB_BCAST_SS },
74 { .KeyOp: X86::VXORPDZrr, .DstOp: X86::VXORPSZrmb, .Flags: TB_BCAST_SS },
75 { .KeyOp: X86::VXORPSZ128rr, .DstOp: X86::VXORPDZ128rmb, .Flags: TB_BCAST_SD },
76 { .KeyOp: X86::VXORPSZ256rr, .DstOp: X86::VXORPDZ256rmb, .Flags: TB_BCAST_SD },
77 { .KeyOp: X86::VXORPSZrr, .DstOp: X86::VXORPDZrmb, .Flags: TB_BCAST_SD },
78};
79
80static const X86FoldTableEntry BroadcastSizeTable3[] = {
81 { .KeyOp: X86::VPTERNLOGDZ128rri, .DstOp: X86::VPTERNLOGQZ128rmbi, .Flags: TB_BCAST_Q },
82 { .KeyOp: X86::VPTERNLOGDZ256rri, .DstOp: X86::VPTERNLOGQZ256rmbi, .Flags: TB_BCAST_Q },
83 { .KeyOp: X86::VPTERNLOGDZrri, .DstOp: X86::VPTERNLOGQZrmbi, .Flags: TB_BCAST_Q },
84 { .KeyOp: X86::VPTERNLOGQZ128rri, .DstOp: X86::VPTERNLOGDZ128rmbi, .Flags: TB_BCAST_D },
85 { .KeyOp: X86::VPTERNLOGQZ256rri, .DstOp: X86::VPTERNLOGDZ256rmbi, .Flags: TB_BCAST_D },
86 { .KeyOp: X86::VPTERNLOGQZrri, .DstOp: X86::VPTERNLOGDZrmbi, .Flags: TB_BCAST_D },
87};
88
89static const X86FoldTableEntry *
90lookupFoldTableImpl(ArrayRef<X86FoldTableEntry> Table, unsigned RegOp) {
91#ifndef NDEBUG
92#define CHECK_SORTED_UNIQUE(TABLE) \
93 assert(llvm::is_sorted(TABLE) && #TABLE " is not sorted"); \
94 assert(std::adjacent_find(std::begin(Table), std::end(Table)) == \
95 std::end(Table) && \
96 #TABLE " is not unique");
97
98 // Make sure the tables are sorted.
99 static std::atomic<bool> FoldTablesChecked(false);
100 if (!FoldTablesChecked.load(std::memory_order_relaxed)) {
101 CHECK_SORTED_UNIQUE(Table2Addr)
102 CHECK_SORTED_UNIQUE(Table0)
103 CHECK_SORTED_UNIQUE(Table1)
104 CHECK_SORTED_UNIQUE(Table2)
105 CHECK_SORTED_UNIQUE(Table3)
106 CHECK_SORTED_UNIQUE(Table4)
107 CHECK_SORTED_UNIQUE(BroadcastTable1)
108 CHECK_SORTED_UNIQUE(BroadcastTable2)
109 CHECK_SORTED_UNIQUE(BroadcastTable3)
110 CHECK_SORTED_UNIQUE(BroadcastTable4)
111 CHECK_SORTED_UNIQUE(BroadcastSizeTable2)
112 CHECK_SORTED_UNIQUE(BroadcastSizeTable3)
113 CHECK_SORTED_UNIQUE(MemUnfoldTable)
114 FoldTablesChecked.store(true, std::memory_order_relaxed);
115 }
116#endif
117
118 const X86FoldTableEntry *Data = llvm::lower_bound(Range&: Table, Value&: RegOp);
119 if (Data != Table.end() && Data->KeyOp == RegOp &&
120 !(Data->Flags & TB_NO_FORWARD))
121 return Data;
122 return nullptr;
123}
124
125const X86FoldTableEntry *llvm::lookupTwoAddrFoldTable(unsigned RegOp) {
126 return lookupFoldTableImpl(Table: Table2Addr, RegOp);
127}
128
129const X86FoldTableEntry *llvm::lookupFoldTable(unsigned RegOp, unsigned OpNum) {
130 ArrayRef<X86FoldTableEntry> FoldTable;
131 if (OpNum == 0)
132 FoldTable = ArrayRef(Table0);
133 else if (OpNum == 1)
134 FoldTable = ArrayRef(Table1);
135 else if (OpNum == 2)
136 FoldTable = ArrayRef(Table2);
137 else if (OpNum == 3)
138 FoldTable = ArrayRef(Table3);
139 else if (OpNum == 4)
140 FoldTable = ArrayRef(Table4);
141 else
142 return nullptr;
143
144 return lookupFoldTableImpl(Table: FoldTable, RegOp);
145}
146
147bool llvm::isNonFoldableWithSameMask(unsigned RegOp) {
148 // NonFoldableWithSameMask table stores instruction opcodes that are unsafe
149 // for masked-load folding when the same mask is used.
150 ArrayRef<unsigned> Table(NonFoldableWithSameMaskTable);
151 auto I = llvm::lower_bound(Range&: Table, Value&: RegOp);
152 return I != Table.end() && *I == RegOp;
153}
154
155const X86FoldTableEntry *llvm::lookupBroadcastFoldTable(unsigned RegOp,
156 unsigned OpNum) {
157 ArrayRef<X86FoldTableEntry> FoldTable;
158 if (OpNum == 1)
159 FoldTable = ArrayRef(BroadcastTable1);
160 else if (OpNum == 2)
161 FoldTable = ArrayRef(BroadcastTable2);
162 else if (OpNum == 3)
163 FoldTable = ArrayRef(BroadcastTable3);
164 else if (OpNum == 4)
165 FoldTable = ArrayRef(BroadcastTable4);
166 else
167 return nullptr;
168
169 return lookupFoldTableImpl(Table: FoldTable, RegOp);
170}
171
172const X86FoldTableEntry *llvm::lookupUnfoldTable(unsigned MemOp) {
173 ArrayRef<X86FoldTableEntry> Table(MemUnfoldTable);
174 auto I = llvm::lower_bound(Range&: Table, Value&: MemOp);
175 if (I != Table.end() && I->KeyOp == MemOp)
176 return &*I;
177 return nullptr;
178}
179
180namespace {
181
182// This class stores the memory -> broadcast folding tables. It is instantiated
183// as a function scope static variable to lazily init the folding table.
184struct X86BroadcastFoldTable {
185 // Stores memory broadcast folding tables entries sorted by opcode.
186 std::vector<X86FoldTableEntry> Table;
187
188 X86BroadcastFoldTable() {
189 // Broadcast tables.
190 for (const X86FoldTableEntry &Reg2Bcst : BroadcastTable2) {
191 unsigned RegOp = Reg2Bcst.KeyOp;
192 unsigned BcstOp = Reg2Bcst.DstOp;
193 if (const X86FoldTableEntry *Reg2Mem = lookupFoldTable(RegOp, OpNum: 2)) {
194 unsigned MemOp = Reg2Mem->DstOp;
195 uint16_t Flags =
196 Reg2Mem->Flags | Reg2Bcst.Flags | TB_INDEX_2 | TB_FOLDED_LOAD;
197 Table.push_back(x: {.KeyOp: MemOp, .DstOp: BcstOp, .Flags: Flags});
198 }
199 }
200 for (const X86FoldTableEntry &Reg2Bcst : BroadcastSizeTable2) {
201 unsigned RegOp = Reg2Bcst.KeyOp;
202 unsigned BcstOp = Reg2Bcst.DstOp;
203 if (const X86FoldTableEntry *Reg2Mem = lookupFoldTable(RegOp, OpNum: 2)) {
204 unsigned MemOp = Reg2Mem->DstOp;
205 uint16_t Flags =
206 Reg2Mem->Flags | Reg2Bcst.Flags | TB_INDEX_2 | TB_FOLDED_LOAD;
207 Table.push_back(x: {.KeyOp: MemOp, .DstOp: BcstOp, .Flags: Flags});
208 }
209 }
210
211 for (const X86FoldTableEntry &Reg2Bcst : BroadcastTable3) {
212 unsigned RegOp = Reg2Bcst.KeyOp;
213 unsigned BcstOp = Reg2Bcst.DstOp;
214 if (const X86FoldTableEntry *Reg2Mem = lookupFoldTable(RegOp, OpNum: 3)) {
215 unsigned MemOp = Reg2Mem->DstOp;
216 uint16_t Flags =
217 Reg2Mem->Flags | Reg2Bcst.Flags | TB_INDEX_3 | TB_FOLDED_LOAD;
218 Table.push_back(x: {.KeyOp: MemOp, .DstOp: BcstOp, .Flags: Flags});
219 }
220 }
221 for (const X86FoldTableEntry &Reg2Bcst : BroadcastSizeTable3) {
222 unsigned RegOp = Reg2Bcst.KeyOp;
223 unsigned BcstOp = Reg2Bcst.DstOp;
224 if (const X86FoldTableEntry *Reg2Mem = lookupFoldTable(RegOp, OpNum: 3)) {
225 unsigned MemOp = Reg2Mem->DstOp;
226 uint16_t Flags =
227 Reg2Mem->Flags | Reg2Bcst.Flags | TB_INDEX_3 | TB_FOLDED_LOAD;
228 Table.push_back(x: {.KeyOp: MemOp, .DstOp: BcstOp, .Flags: Flags});
229 }
230 }
231
232 for (const X86FoldTableEntry &Reg2Bcst : BroadcastTable4) {
233 unsigned RegOp = Reg2Bcst.KeyOp;
234 unsigned BcstOp = Reg2Bcst.DstOp;
235 if (const X86FoldTableEntry *Reg2Mem = lookupFoldTable(RegOp, OpNum: 4)) {
236 unsigned MemOp = Reg2Mem->DstOp;
237 uint16_t Flags =
238 Reg2Mem->Flags | Reg2Bcst.Flags | TB_INDEX_4 | TB_FOLDED_LOAD;
239 Table.push_back(x: {.KeyOp: MemOp, .DstOp: BcstOp, .Flags: Flags});
240 }
241 }
242
243 // Sort the memory->broadcast fold table.
244 array_pod_sort(Start: Table.begin(), End: Table.end());
245 }
246};
247} // namespace
248
249bool llvm::matchBroadcastSize(const X86FoldTableEntry &Entry,
250 unsigned BroadcastBits) {
251 switch (Entry.Flags & TB_BCAST_MASK) {
252 case TB_BCAST_W:
253 case TB_BCAST_SH:
254 return BroadcastBits == 16;
255 case TB_BCAST_D:
256 case TB_BCAST_SS:
257 return BroadcastBits == 32;
258 case TB_BCAST_Q:
259 case TB_BCAST_SD:
260 return BroadcastBits == 64;
261 }
262 return false;
263}
264
265const X86FoldTableEntry *
266llvm::lookupBroadcastFoldTableBySize(unsigned MemOp, unsigned BroadcastBits) {
267 static X86BroadcastFoldTable BroadcastFoldTable;
268 auto &Table = BroadcastFoldTable.Table;
269 for (auto I = llvm::lower_bound(Range&: Table, Value&: MemOp);
270 I != Table.end() && I->KeyOp == MemOp; ++I) {
271 if (matchBroadcastSize(Entry: *I, BroadcastBits))
272 return &*I;
273 }
274 return nullptr;
275}
276