1 //===- lib/CodeGen/GlobalISel/LegalizerInfo.cpp - Legalizer ---------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Implement an interface to specify and query how an illegal operation on a
11 // given type should be expanded.
12 //
13 // Issues to be resolved:
14 //   + Make it fast.
15 //   + Support weird types like i3, <7 x i3>, ...
16 //   + Operations with more than one type (ICMP, CMPXCHG, intrinsics, ...)
17 //
18 //===----------------------------------------------------------------------===//
19 
20 #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
21 #include "llvm/ADT/SmallBitVector.h"
22 #include "llvm/CodeGen/MachineInstr.h"
23 #include "llvm/CodeGen/MachineOperand.h"
24 #include "llvm/CodeGen/MachineRegisterInfo.h"
25 #include "llvm/CodeGen/TargetOpcodes.h"
26 #include "llvm/MC/MCInstrDesc.h"
27 #include "llvm/Support/Debug.h"
28 #include "llvm/Support/ErrorHandling.h"
29 #include "llvm/Support/LowLevelTypeImpl.h"
30 #include "llvm/Support/MathExtras.h"
31 #include <algorithm>
32 #include <map>
33 
34 using namespace llvm;
35 using namespace LegalizeActions;
36 
37 #define DEBUG_TYPE "legalizer-info"
38 
39 raw_ostream &LegalityQuery::print(raw_ostream &OS) const {
40   OS << Opcode << ", {";
41   for (const auto &Type : Types) {
42     OS << Type << ", ";
43   }
44   OS << "}";
45   return OS;
46 }
47 
48 LegalizeActionStep LegalizeRuleSet::apply(const LegalityQuery &Query) const {
49   DEBUG(dbgs() << "Applying legalizer ruleset to: "; Query.print(dbgs());
50         dbgs() << "\n");
51   if (Rules.empty()) {
52     DEBUG(dbgs() << ".. fallback to legacy rules (no rules defined)\n");
53     return {LegalizeAction::UseLegacyRules, 0, LLT{}};
54   }
55   for (const auto &Rule : Rules) {
56     if (Rule.match(Query)) {
57       DEBUG(dbgs() << ".. match\n");
58       std::pair<unsigned, LLT> Mutation = Rule.determineMutation(Query);
59       DEBUG(dbgs() << ".. .. " << (unsigned)Rule.getAction() << ", "
60                    << Mutation.first << ", " << Mutation.second << "\n");
61       assert((Query.Types[Mutation.first] != Mutation.second ||
62               Rule.getAction() == MoreElements ||
63               Rule.getAction() == FewerElements) &&
64              "Simple loop detected");
65       return {Rule.getAction(), Mutation.first, Mutation.second};
66     } else
67       DEBUG(dbgs() << ".. no match\n");
68   }
69   DEBUG(dbgs() << ".. unsupported\n");
70   return {LegalizeAction::Unsupported, 0, LLT{}};
71 }
72 
73 LegalizerInfo::LegalizerInfo() : TablesInitialized(false) {
74   // Set defaults.
75   // FIXME: these two (G_ANYEXT and G_TRUNC?) can be legalized to the
76   // fundamental load/store Jakob proposed. Once loads & stores are supported.
77   setScalarAction(TargetOpcode::G_ANYEXT, 1, {{1, Legal}});
78   setScalarAction(TargetOpcode::G_ZEXT, 1, {{1, Legal}});
79   setScalarAction(TargetOpcode::G_SEXT, 1, {{1, Legal}});
80   setScalarAction(TargetOpcode::G_TRUNC, 0, {{1, Legal}});
81   setScalarAction(TargetOpcode::G_TRUNC, 1, {{1, Legal}});
82 
83   setScalarAction(TargetOpcode::G_INTRINSIC, 0, {{1, Legal}});
84   setScalarAction(TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS, 0, {{1, Legal}});
85 
86   setLegalizeScalarToDifferentSizeStrategy(
87       TargetOpcode::G_IMPLICIT_DEF, 0, narrowToSmallerAndUnsupportedIfTooSmall);
88   setLegalizeScalarToDifferentSizeStrategy(
89       TargetOpcode::G_ADD, 0, widenToLargerTypesAndNarrowToLargest);
90   setLegalizeScalarToDifferentSizeStrategy(
91       TargetOpcode::G_OR, 0, widenToLargerTypesAndNarrowToLargest);
92   setLegalizeScalarToDifferentSizeStrategy(
93       TargetOpcode::G_LOAD, 0, narrowToSmallerAndUnsupportedIfTooSmall);
94   setLegalizeScalarToDifferentSizeStrategy(
95       TargetOpcode::G_STORE, 0, narrowToSmallerAndUnsupportedIfTooSmall);
96 
97   setLegalizeScalarToDifferentSizeStrategy(
98       TargetOpcode::G_BRCOND, 0, widenToLargerTypesUnsupportedOtherwise);
99   setLegalizeScalarToDifferentSizeStrategy(
100       TargetOpcode::G_INSERT, 0, narrowToSmallerAndUnsupportedIfTooSmall);
101   setLegalizeScalarToDifferentSizeStrategy(
102       TargetOpcode::G_EXTRACT, 0, narrowToSmallerAndUnsupportedIfTooSmall);
103   setLegalizeScalarToDifferentSizeStrategy(
104       TargetOpcode::G_EXTRACT, 1, narrowToSmallerAndUnsupportedIfTooSmall);
105   setScalarAction(TargetOpcode::G_FNEG, 0, {{1, Lower}});
106 }
107 
108 void LegalizerInfo::computeTables() {
109   assert(TablesInitialized == false);
110 
111   for (unsigned OpcodeIdx = 0; OpcodeIdx <= LastOp - FirstOp; ++OpcodeIdx) {
112     const unsigned Opcode = FirstOp + OpcodeIdx;
113     for (unsigned TypeIdx = 0; TypeIdx != SpecifiedActions[OpcodeIdx].size();
114          ++TypeIdx) {
115       // 0. Collect information specified through the setAction API, i.e.
116       // for specific bit sizes.
117       // For scalar types:
118       SizeAndActionsVec ScalarSpecifiedActions;
119       // For pointer types:
120       std::map<uint16_t, SizeAndActionsVec> AddressSpace2SpecifiedActions;
121       // For vector types:
122       std::map<uint16_t, SizeAndActionsVec> ElemSize2SpecifiedActions;
123       for (auto LLT2Action : SpecifiedActions[OpcodeIdx][TypeIdx]) {
124         const LLT Type = LLT2Action.first;
125         const LegalizeAction Action = LLT2Action.second;
126 
127         auto SizeAction = std::make_pair(Type.getSizeInBits(), Action);
128         if (Type.isPointer())
129           AddressSpace2SpecifiedActions[Type.getAddressSpace()].push_back(
130               SizeAction);
131         else if (Type.isVector())
132           ElemSize2SpecifiedActions[Type.getElementType().getSizeInBits()]
133               .push_back(SizeAction);
134         else
135           ScalarSpecifiedActions.push_back(SizeAction);
136       }
137 
138       // 1. Handle scalar types
139       {
140         // Decide how to handle bit sizes for which no explicit specification
141         // was given.
142         SizeChangeStrategy S = &unsupportedForDifferentSizes;
143         if (TypeIdx < ScalarSizeChangeStrategies[OpcodeIdx].size() &&
144             ScalarSizeChangeStrategies[OpcodeIdx][TypeIdx] != nullptr)
145           S = ScalarSizeChangeStrategies[OpcodeIdx][TypeIdx];
146         std::sort(ScalarSpecifiedActions.begin(), ScalarSpecifiedActions.end());
147         checkPartialSizeAndActionsVector(ScalarSpecifiedActions);
148         setScalarAction(Opcode, TypeIdx, S(ScalarSpecifiedActions));
149       }
150 
151       // 2. Handle pointer types
152       for (auto PointerSpecifiedActions : AddressSpace2SpecifiedActions) {
153         std::sort(PointerSpecifiedActions.second.begin(),
154                   PointerSpecifiedActions.second.end());
155         checkPartialSizeAndActionsVector(PointerSpecifiedActions.second);
156         // For pointer types, we assume that there isn't a meaningfull way
157         // to change the number of bits used in the pointer.
158         setPointerAction(
159             Opcode, TypeIdx, PointerSpecifiedActions.first,
160             unsupportedForDifferentSizes(PointerSpecifiedActions.second));
161       }
162 
163       // 3. Handle vector types
164       SizeAndActionsVec ElementSizesSeen;
165       for (auto VectorSpecifiedActions : ElemSize2SpecifiedActions) {
166         std::sort(VectorSpecifiedActions.second.begin(),
167                   VectorSpecifiedActions.second.end());
168         const uint16_t ElementSize = VectorSpecifiedActions.first;
169         ElementSizesSeen.push_back({ElementSize, Legal});
170         checkPartialSizeAndActionsVector(VectorSpecifiedActions.second);
171         // For vector types, we assume that the best way to adapt the number
172         // of elements is to the next larger number of elements type for which
173         // the vector type is legal, unless there is no such type. In that case,
174         // legalize towards a vector type with a smaller number of elements.
175         SizeAndActionsVec NumElementsActions;
176         for (SizeAndAction BitsizeAndAction : VectorSpecifiedActions.second) {
177           assert(BitsizeAndAction.first % ElementSize == 0);
178           const uint16_t NumElements = BitsizeAndAction.first / ElementSize;
179           NumElementsActions.push_back({NumElements, BitsizeAndAction.second});
180         }
181         setVectorNumElementAction(
182             Opcode, TypeIdx, ElementSize,
183             moreToWiderTypesAndLessToWidest(NumElementsActions));
184       }
185       std::sort(ElementSizesSeen.begin(), ElementSizesSeen.end());
186       SizeChangeStrategy VectorElementSizeChangeStrategy =
187           &unsupportedForDifferentSizes;
188       if (TypeIdx < VectorElementSizeChangeStrategies[OpcodeIdx].size() &&
189           VectorElementSizeChangeStrategies[OpcodeIdx][TypeIdx] != nullptr)
190         VectorElementSizeChangeStrategy =
191             VectorElementSizeChangeStrategies[OpcodeIdx][TypeIdx];
192       setScalarInVectorAction(
193           Opcode, TypeIdx, VectorElementSizeChangeStrategy(ElementSizesSeen));
194     }
195   }
196 
197   TablesInitialized = true;
198 }
199 
200 // FIXME: inefficient implementation for now. Without ComputeValueVTs we're
201 // probably going to need specialized lookup structures for various types before
202 // we have any hope of doing well with something like <13 x i3>. Even the common
203 // cases should do better than what we have now.
204 std::pair<LegalizeAction, LLT>
205 LegalizerInfo::getAspectAction(const InstrAspect &Aspect) const {
206   assert(TablesInitialized && "backend forgot to call computeTables");
207   // These *have* to be implemented for now, they're the fundamental basis of
208   // how everything else is transformed.
209   if (Aspect.Type.isScalar() || Aspect.Type.isPointer())
210     return findScalarLegalAction(Aspect);
211   assert(Aspect.Type.isVector());
212   return findVectorLegalAction(Aspect);
213 }
214 
215 /// Helper function to get LLT for the given type index.
216 static LLT getTypeFromTypeIdx(const MachineInstr &MI,
217                               const MachineRegisterInfo &MRI, unsigned OpIdx,
218                               unsigned TypeIdx) {
219   assert(TypeIdx < MI.getNumOperands() && "Unexpected TypeIdx");
220   // G_UNMERGE_VALUES has variable number of operands, but there is only
221   // one source type and one destination type as all destinations must be the
222   // same type. So, get the last operand if TypeIdx == 1.
223   if (MI.getOpcode() == TargetOpcode::G_UNMERGE_VALUES && TypeIdx == 1)
224     return MRI.getType(MI.getOperand(MI.getNumOperands() - 1).getReg());
225   return MRI.getType(MI.getOperand(OpIdx).getReg());
226 }
227 
228 unsigned LegalizerInfo::getOpcodeIdxForOpcode(unsigned Opcode) const {
229   assert(Opcode >= FirstOp && Opcode <= LastOp && "Unsupported opcode");
230   return Opcode - FirstOp;
231 }
232 
233 unsigned LegalizerInfo::getActionDefinitionsIdx(unsigned Opcode) const {
234   unsigned OpcodeIdx = getOpcodeIdxForOpcode(Opcode);
235   if (unsigned Alias = RulesForOpcode[OpcodeIdx].getAlias()) {
236     DEBUG(dbgs() << ".. opcode " << Opcode << " is aliased to " << Alias
237                  << "\n");
238     OpcodeIdx = getOpcodeIdxForOpcode(Alias);
239     DEBUG(dbgs() << ".. opcode " << Alias << " is aliased to "
240                  << RulesForOpcode[OpcodeIdx].getAlias() << "\n");
241     assert(RulesForOpcode[OpcodeIdx].getAlias() == 0 && "Cannot chain aliases");
242   }
243 
244   return OpcodeIdx;
245 }
246 
247 const LegalizeRuleSet &
248 LegalizerInfo::getActionDefinitions(unsigned Opcode) const {
249   unsigned OpcodeIdx = getActionDefinitionsIdx(Opcode);
250   return RulesForOpcode[OpcodeIdx];
251 }
252 
253 LegalizeRuleSet &LegalizerInfo::getActionDefinitionsBuilder(unsigned Opcode) {
254   unsigned OpcodeIdx = getActionDefinitionsIdx(Opcode);
255   auto &Result = RulesForOpcode[OpcodeIdx];
256   assert(!Result.isAliasedByAnother() && "Modifying this opcode will modify aliases");
257   return Result;
258 }
259 
260 LegalizeRuleSet &LegalizerInfo::getActionDefinitionsBuilder(
261     std::initializer_list<unsigned> Opcodes) {
262   unsigned Representative = *Opcodes.begin();
263 
264   for (auto I = Opcodes.begin() + 1, E = Opcodes.end(); I != E; ++I)
265     aliasActionDefinitions(Representative, *I);
266 
267   auto &Return = getActionDefinitionsBuilder(Representative);
268   Return.setIsAliasedByAnother();
269   return Return;
270 }
271 
272 void LegalizerInfo::aliasActionDefinitions(unsigned OpcodeTo,
273                                            unsigned OpcodeFrom) {
274   assert(OpcodeTo != OpcodeFrom && "Cannot alias to self");
275   assert(OpcodeTo >= FirstOp && OpcodeTo <= LastOp && "Unsupported opcode");
276   const unsigned OpcodeFromIdx = getOpcodeIdxForOpcode(OpcodeFrom);
277   RulesForOpcode[OpcodeFromIdx].aliasTo(OpcodeTo);
278 }
279 
280 LegalizeActionStep
281 LegalizerInfo::getAction(const LegalityQuery &Query) const {
282   LegalizeActionStep Step = getActionDefinitions(Query.Opcode).apply(Query);
283   if (Step.Action != LegalizeAction::UseLegacyRules) {
284     return Step;
285   }
286 
287   for (unsigned i = 0; i < Query.Types.size(); ++i) {
288     auto Action = getAspectAction({Query.Opcode, i, Query.Types[i]});
289     if (Action.first != Legal) {
290       DEBUG(dbgs() << ".. (legacy) Type " << i << " Action="
291                    << (unsigned)Action.first << ", " << Action.second << "\n");
292       return {Action.first, i, Action.second};
293     } else
294       DEBUG(dbgs() << ".. (legacy) Type " << i << " Legal\n");
295   }
296   DEBUG(dbgs() << ".. (legacy) Legal\n");
297   return {Legal, 0, LLT{}};
298 }
299 
300 LegalizeActionStep
301 LegalizerInfo::getAction(const MachineInstr &MI,
302                          const MachineRegisterInfo &MRI) const {
303   SmallVector<LLT, 2> Types;
304   SmallBitVector SeenTypes(8);
305   const MCOperandInfo *OpInfo = MI.getDesc().OpInfo;
306   // FIXME: probably we'll need to cache the results here somehow?
307   for (unsigned i = 0; i < MI.getDesc().getNumOperands(); ++i) {
308     if (!OpInfo[i].isGenericType())
309       continue;
310 
311     // We must only record actions once for each TypeIdx; otherwise we'd
312     // try to legalize operands multiple times down the line.
313     unsigned TypeIdx = OpInfo[i].getGenericTypeIndex();
314     if (SeenTypes[TypeIdx])
315       continue;
316 
317     SeenTypes.set(TypeIdx);
318 
319     LLT Ty = getTypeFromTypeIdx(MI, MRI, i, TypeIdx);
320     Types.push_back(Ty);
321   }
322   return getAction({MI.getOpcode(), Types});
323 }
324 
325 bool LegalizerInfo::isLegal(const MachineInstr &MI,
326                             const MachineRegisterInfo &MRI) const {
327   return getAction(MI, MRI).Action == Legal;
328 }
329 
330 bool LegalizerInfo::legalizeCustom(MachineInstr &MI, MachineRegisterInfo &MRI,
331                                    MachineIRBuilder &MIRBuilder) const {
332   return false;
333 }
334 
335 LegalizerInfo::SizeAndActionsVec
336 LegalizerInfo::increaseToLargerTypesAndDecreaseToLargest(
337     const SizeAndActionsVec &v, LegalizeAction IncreaseAction,
338     LegalizeAction DecreaseAction) {
339   SizeAndActionsVec result;
340   unsigned LargestSizeSoFar = 0;
341   if (v.size() >= 1 && v[0].first != 1)
342     result.push_back({1, IncreaseAction});
343   for (size_t i = 0; i < v.size(); ++i) {
344     result.push_back(v[i]);
345     LargestSizeSoFar = v[i].first;
346     if (i + 1 < v.size() && v[i + 1].first != v[i].first + 1) {
347       result.push_back({LargestSizeSoFar + 1, IncreaseAction});
348       LargestSizeSoFar = v[i].first + 1;
349     }
350   }
351   result.push_back({LargestSizeSoFar + 1, DecreaseAction});
352   return result;
353 }
354 
355 LegalizerInfo::SizeAndActionsVec
356 LegalizerInfo::decreaseToSmallerTypesAndIncreaseToSmallest(
357     const SizeAndActionsVec &v, LegalizeAction DecreaseAction,
358     LegalizeAction IncreaseAction) {
359   SizeAndActionsVec result;
360   if (v.size() == 0 || v[0].first != 1)
361     result.push_back({1, IncreaseAction});
362   for (size_t i = 0; i < v.size(); ++i) {
363     result.push_back(v[i]);
364     if (i + 1 == v.size() || v[i + 1].first != v[i].first + 1) {
365       result.push_back({v[i].first + 1, DecreaseAction});
366     }
367   }
368   return result;
369 }
370 
371 LegalizerInfo::SizeAndAction
372 LegalizerInfo::findAction(const SizeAndActionsVec &Vec, const uint32_t Size) {
373   assert(Size >= 1);
374   // Find the last element in Vec that has a bitsize equal to or smaller than
375   // the requested bit size.
376   // That is the element just before the first element that is bigger than Size.
377   auto VecIt = std::upper_bound(
378       Vec.begin(), Vec.end(), Size,
379       [](const uint32_t Size, const SizeAndAction lhs) -> bool {
380         return Size < lhs.first;
381       });
382   assert(VecIt != Vec.begin() && "Does Vec not start with size 1?");
383   --VecIt;
384   int VecIdx = VecIt - Vec.begin();
385 
386   LegalizeAction Action = Vec[VecIdx].second;
387   switch (Action) {
388   case Legal:
389   case Lower:
390   case Libcall:
391   case Custom:
392     return {Size, Action};
393   case FewerElements:
394     // FIXME: is this special case still needed and correct?
395     // Special case for scalarization:
396     if (Vec == SizeAndActionsVec({{1, FewerElements}}))
397       return {1, FewerElements};
398     LLVM_FALLTHROUGH;
399   case NarrowScalar: {
400     // The following needs to be a loop, as for now, we do allow needing to
401     // go over "Unsupported" bit sizes before finding a legalizable bit size.
402     // e.g. (s8, WidenScalar), (s9, Unsupported), (s32, Legal). if Size==8,
403     // we need to iterate over s9, and then to s32 to return (s32, Legal).
404     // If we want to get rid of the below loop, we should have stronger asserts
405     // when building the SizeAndActionsVecs, probably not allowing
406     // "Unsupported" unless at the ends of the vector.
407     for (int i = VecIdx - 1; i >= 0; --i)
408       if (!needsLegalizingToDifferentSize(Vec[i].second) &&
409           Vec[i].second != Unsupported)
410         return {Vec[i].first, Action};
411     llvm_unreachable("");
412   }
413   case WidenScalar:
414   case MoreElements: {
415     // See above, the following needs to be a loop, at least for now.
416     for (std::size_t i = VecIdx + 1; i < Vec.size(); ++i)
417       if (!needsLegalizingToDifferentSize(Vec[i].second) &&
418           Vec[i].second != Unsupported)
419         return {Vec[i].first, Action};
420     llvm_unreachable("");
421   }
422   case Unsupported:
423     return {Size, Unsupported};
424   case NotFound:
425   case UseLegacyRules:
426     llvm_unreachable("NotFound");
427   }
428   llvm_unreachable("Action has an unknown enum value");
429 }
430 
431 std::pair<LegalizeAction, LLT>
432 LegalizerInfo::findScalarLegalAction(const InstrAspect &Aspect) const {
433   assert(Aspect.Type.isScalar() || Aspect.Type.isPointer());
434   if (Aspect.Opcode < FirstOp || Aspect.Opcode > LastOp)
435     return {NotFound, LLT()};
436   const unsigned OpcodeIdx = getOpcodeIdxForOpcode(Aspect.Opcode);
437   if (Aspect.Type.isPointer() &&
438       AddrSpace2PointerActions[OpcodeIdx].find(Aspect.Type.getAddressSpace()) ==
439           AddrSpace2PointerActions[OpcodeIdx].end()) {
440     return {NotFound, LLT()};
441   }
442   const SmallVector<SizeAndActionsVec, 1> &Actions =
443       Aspect.Type.isPointer()
444           ? AddrSpace2PointerActions[OpcodeIdx]
445                 .find(Aspect.Type.getAddressSpace())
446                 ->second
447           : ScalarActions[OpcodeIdx];
448   if (Aspect.Idx >= Actions.size())
449     return {NotFound, LLT()};
450   const SizeAndActionsVec &Vec = Actions[Aspect.Idx];
451   // FIXME: speed up this search, e.g. by using a results cache for repeated
452   // queries?
453   auto SizeAndAction = findAction(Vec, Aspect.Type.getSizeInBits());
454   return {SizeAndAction.second,
455           Aspect.Type.isScalar() ? LLT::scalar(SizeAndAction.first)
456                                  : LLT::pointer(Aspect.Type.getAddressSpace(),
457                                                 SizeAndAction.first)};
458 }
459 
460 std::pair<LegalizeAction, LLT>
461 LegalizerInfo::findVectorLegalAction(const InstrAspect &Aspect) const {
462   assert(Aspect.Type.isVector());
463   // First legalize the vector element size, then legalize the number of
464   // lanes in the vector.
465   if (Aspect.Opcode < FirstOp || Aspect.Opcode > LastOp)
466     return {NotFound, Aspect.Type};
467   const unsigned OpcodeIdx = getOpcodeIdxForOpcode(Aspect.Opcode);
468   const unsigned TypeIdx = Aspect.Idx;
469   if (TypeIdx >= ScalarInVectorActions[OpcodeIdx].size())
470     return {NotFound, Aspect.Type};
471   const SizeAndActionsVec &ElemSizeVec =
472       ScalarInVectorActions[OpcodeIdx][TypeIdx];
473 
474   LLT IntermediateType;
475   auto ElementSizeAndAction =
476       findAction(ElemSizeVec, Aspect.Type.getScalarSizeInBits());
477   IntermediateType =
478       LLT::vector(Aspect.Type.getNumElements(), ElementSizeAndAction.first);
479   if (ElementSizeAndAction.second != Legal)
480     return {ElementSizeAndAction.second, IntermediateType};
481 
482   auto i = NumElements2Actions[OpcodeIdx].find(
483       IntermediateType.getScalarSizeInBits());
484   if (i == NumElements2Actions[OpcodeIdx].end()) {
485     return {NotFound, IntermediateType};
486   }
487   const SizeAndActionsVec &NumElementsVec = (*i).second[TypeIdx];
488   auto NumElementsAndAction =
489       findAction(NumElementsVec, IntermediateType.getNumElements());
490   return {NumElementsAndAction.second,
491           LLT::vector(NumElementsAndAction.first,
492                       IntermediateType.getScalarSizeInBits())};
493 }
494