[NFC] Only expose getXXXSize functions in TypeSize

[gchatelet]

Summary

Currently 'TypeSize' exposes two functions that serve the same purpose:

• getFixedSize / getFixedValue
• getKnownMinSize / getKnownMinValue

source : https://github.com/llvm/llvm-project/blob/bf82070ea465969e9ae86a31dfcbf94c2a7b4c4c/llvm/include/llvm/Support/TypeSize.h#L337-L338

This patch offers to remove one of the two and stick to a single function in the code base.

[sdesmalen]

llvm/include/llvm/Support/TypeSize.h

319–322

They're both only used once below, so I think you can remove the private interface and just call the parent class' method directly?

[gchatelet]

llvm/include/llvm/Support/TypeSize.h

319–322

I could but then the methods would still be visible. Another option is to mark the functions protected in FixedOrScalableQuantity and make them public only in ElementCount.

[sdesmalen]

llvm/include/llvm/Support/TypeSize.h

319–322

Ah of course, I didn't realise they were inherited. In that case I'm happy with this approach, because for TypeSize we made a stylistic exception to have something called getKnownMinSize, whereas in other circumstances the default getKnownMinValue is appropriate.

[gchatelet]

• Make functions private with the using keyword

[gchatelet]

llvm/include/llvm/Support/TypeSize.h

319–322

I forgot that I could use using to make the functions private. It's better than redefining them.

[gchatelet]

Thx for the review @sdesmalen

[courbet]

I think we should keep a single one, but just to bikeshed, a TypeSize has a Value, not a Size, so I would keep getFixedValue.

llvm/include/llvm/Support/TypeSize.h

319–322

Well that does not really make it private because you can cast to base and call.

[gchatelet]

I've reverted the patch so we can discuss further whether we want to keep the Size version of the Value version.

[foad]

This caused a build failure in clang: lib/CodeGen/CGDecl.cpp:1344:46: error: 'getFixedValue' is a private member of 'llvm::TypeSize'

[gchatelet]

In D141134#4031635, @foad wrote:

This caused a build failure in clang: lib/CodeGen/CGDecl.cpp:1344:46: error: 'getFixedValue' is a private member of 'llvm::TypeSize'

Yep just noticed as well, thx for the heads up @foad.

[gchatelet]

sdesmalen@ do you feel strongly about the getXXXSize version of the functions?
I tend to agree with courbet@ that getXXXValue is more correct (semantically speaking). Also it makes the implementation simpler.

[gchatelet]

rebase after revert

[sdesmalen]

In D141134#4035501, @gchatelet wrote:

sdesmalen@ do you feel strongly about the getXXXSize version of the functions?
I tend to agree with courbet@ that getXXXValue is more correct (semantically speaking). Also it makes the implementation simpler.

I agree that having one interface for the same thing is better than two, so dropping the getXXXSize() interfaces in favour of getXXXValue() makes sense to me. Thanks for checking!

[gchatelet]

• Fix missing clang change

[gchatelet]

I've created https://reviews.llvm.org/D141267 to get a feel of what it looks like to only keep the Size version.

[gchatelet]

So i've submitted the following patches which remove the usage of TypeSize::getFixedSize() and TypeSize::getKnownMinSize()

• rG6916ebd02650: [clang][NFC] Use the TypeSize::getXXXValue() instead of TypeSize::getXXXSize).Wed, Jan 11, 5:08 PM
• rGca8485578652: [mlir][NFC] Use TypeSize::getFixedValue() instead of TypeSize::getFixedSize().Wed, Jan 11, 5:22 PM
• rGfbd207fd6f6b: [NFC] Use TypeSize::getKnownMinValue() instead of TypeSize::getKnownMinSize().Wed, Jan 11, 5:29 PM
• rG48f5d77eeed4: [NFC] Use TypeSize::getKnownMinValue() instead of TypeSize::getKnownMinSize().Wed, Jan 11, 5:37 PM
• rG8fd5558b2976: [NFC] Use TypeSize::geFixedValue() instead of TypeSize::getFixedSize().Wed, Jan 11, 5:49 PM

I've also marked the functions deprecated so downstream users can fix their codebase.

• rG1dcaa2bdf230: Marking TypeSize getFixedSize() and getKnownMinSize() deprecated.

I'm marking this patch as closed.

llvm/include/llvm/Support/TypeSize.h

constexpr bool isVector() const {
     return (isScalable() && getKnownMinValue() != 0) || getKnownMinValue() > 1;
   }
 };
 
 // Stores the size of a type. If the type is of fixed size, it will represent
 // the exact size. If the type is a scalable vector, it will represent the known
 // minimum size.
 class TypeSize : public details::FixedOrScalableQuantity<TypeSize, uint64_t> {
+  using UP = details::FixedOrScalableQuantity<TypeSize, uint64_t>;
+
   TypeSize(const FixedOrScalableQuantity<TypeSize, uint64_t> &V)
       : FixedOrScalableQuantity(V) {}
 
+  // Make 'getFixedValue' private, it is exposed as 'getFixedSize' below.
+  using UP::getFixedValue;
+  // Make 'getKnownMinValue' private, it is exposed as 'getKnownMinSize' below.
+  using UP::getKnownMinValue;
+
 public:
   constexpr TypeSize(ScalarTy Quantity, bool Scalable)
       : FixedOrScalableQuantity(Quantity, Scalable) {}
 
   static constexpr TypeSize getFixed(ScalarTy ExactSize) {
     return TypeSize(ExactSize, false);
   }
   static constexpr TypeSize getScalable(ScalarTy MinimunSize) {

 
 /// Returns a TypeSize with a known minimum size that is the next integer
 /// (mod 2**64) that is greater than or equal to \p Quantity and is a multiple
 /// of \p Align. \p Align must be non-zero.
 ///
 /// Similar to the alignTo functions in MathExtras.h
 inline constexpr TypeSize alignTo(TypeSize Size, uint64_t Align) {
   assert(Align != 0u && "Align must be non-zero");
-  return {(Size.getKnownMinValue() + Align - 1) / Align * Align,
+  return {(Size.getKnownMinSize() + Align - 1) / Align * Align,
           Size.isScalable()};
 }
 
 /// Stream operator function for `FixedOrScalableQuantity`.
 template <typename LeafTy, typename ScalarTy>
 inline raw_ostream &
 operator<<(raw_ostream &OS,
            const details::FixedOrScalableQuantity<LeafTy, ScalarTy> &PS) {

llvm/lib/Analysis/ConstantFolding.cpp

if (Offset <= -1 * static_cast<int64_t>(BytesLoaded))
     return PoisonValue::get(IntType);
 
   // TODO: We should be able to support scalable types.
   TypeSize InitializerSize = DL.getTypeAllocSize(C->getType());
   if (InitializerSize.isScalable())
     return nullptr;
 
   // If we're not accessing anything in this constant, the result is undefined.
-  if (Offset >= (int64_t)InitializerSize.getFixedValue())
+  if (Offset >= (int64_t)InitializerSize.getFixedSize())
     return PoisonValue::get(IntType);
 
   unsigned char RawBytes[32] = {0};
   unsigned char *CurPtr = RawBytes;
   unsigned BytesLeft = BytesLoaded;
 
   // If we're loading off the beginning of the global, some bytes may be valid.
   if (Offset < 0) {

llvm/lib/Analysis/Loads.cpp

bool llvm::isSafeToLoadUnconditionally(Value *V, Type *Ty, Align Alignment,
                                        const DataLayout &DL,
                                        Instruction *ScanFrom,
                                        AssumptionCache *AC,
                                        const DominatorTree *DT,
                                        const TargetLibraryInfo *TLI) {
   TypeSize TySize = DL.getTypeStoreSize(Ty);
   if (TySize.isScalable())
     return false;
-  APInt Size(DL.getIndexTypeSizeInBits(V->getType()), TySize.getFixedValue());
+  APInt Size(DL.getIndexTypeSizeInBits(V->getType()), TySize.getFixedSize());
   return isSafeToLoadUnconditionally(V, Alignment, Size, DL, ScanFrom, AC, DT,
                                      TLI);
 }
 
 /// DefMaxInstsToScan - the default number of maximum instructions
 /// to scan in the block, used by FindAvailableLoadedValue().
 /// FindAvailableLoadedValue() was introduced in r60148, to improve jump
 /// threading in part by eliminating partially redundant loads.

llvm/lib/CodeGen/Analysis.cpp

for (StructType::element_iterator EB = STy->element_begin(),
       ComputeValueVTs(TLI, DL, *EI, ValueVTs, MemVTs, Offsets,
                       StartingOffset + EltOffset);
     }
     return;
   }
   // Given an array type, recursively traverse the elements.
   if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
     Type *EltTy = ATy->getElementType();
-    uint64_t EltSize = DL.getTypeAllocSize(EltTy).getFixedValue();
+    uint64_t EltSize = DL.getTypeAllocSize(EltTy).getFixedSize();
     for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i)
       ComputeValueVTs(TLI, DL, EltTy, ValueVTs, MemVTs, Offsets,
                       StartingOffset + i * EltSize);
     return;
   }
   // Interpret void as zero return values.
   if (Ty->isVoidTy())
     return;
for (unsigned I = 0, E = STy->getNumElements(); I != E; ++I) {
       computeValueLLTs(DL, *STy->getElementType(I), ValueTys, Offsets,
                        StartingOffset + EltOffset);
     }
     return;
   }
   // Given an array type, recursively traverse the elements.
   if (ArrayType *ATy = dyn_cast<ArrayType>(&Ty)) {
     Type *EltTy = ATy->getElementType();
-    uint64_t EltSize = DL.getTypeAllocSize(EltTy).getFixedValue();
+    uint64_t EltSize = DL.getTypeAllocSize(EltTy).getFixedSize();
     for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i)
       computeValueLLTs(DL, *EltTy, ValueTys, Offsets,
                        StartingOffset + i * EltSize);
     return;
   }
   // Interpret void as zero return values.
   if (Ty.isVoidTy())
     return;

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitAlloca(const AllocaInst &I) {
   EVT IntPtr = TLI.getPointerTy(DAG.getDataLayout(), I.getAddressSpace());
   if (AllocSize.getValueType() != IntPtr)
     AllocSize = DAG.getZExtOrTrunc(AllocSize, dl, IntPtr);
 
   if (TySize.isScalable())
     AllocSize = DAG.getNode(ISD::MUL, dl, IntPtr, AllocSize,
                             DAG.getVScale(dl, IntPtr,
                                           APInt(IntPtr.getScalarSizeInBits(),
-                                                TySize.getKnownMinValue())));
+                                                TySize.getKnownMinSize())));
   else
     AllocSize =
         DAG.getNode(ISD::MUL, dl, IntPtr, AllocSize,
-                    DAG.getConstant(TySize.getFixedValue(), dl, IntPtr));
+                    DAG.getConstant(TySize.getFixedSize(), dl, IntPtr));
 
   // Handle alignment.  If the requested alignment is less than or equal to
   // the stack alignment, ignore it.  If the size is greater than or equal to
   // the stack alignment, we note this in the DYNAMIC_STACKALLOC node.
   Align StackAlign = DAG.getSubtarget().getFrameLowering()->getStackAlign();
   if (*Alignment <= StackAlign)
     Alignment = std::nullopt;
 

llvm/lib/CodeGen/StackProtector.cpp

case Instruction::GetElementPtr: {
         return true;
       TypeSize OffsetSize = TypeSize::Fixed(Offset.getLimitedValue());
       if (!TypeSize::isKnownGT(AllocSize, OffsetSize))
         return true;
       // Adjust AllocSize to be the space remaining after this offset.
       // We can't subtract a fixed size from a scalable one, so in that case
       // assume the scalable value is of minimum size.
       TypeSize NewAllocSize =
-          TypeSize::Fixed(AllocSize.getKnownMinValue()) - OffsetSize;
+          TypeSize::Fixed(AllocSize.getKnownMinSize()) - OffsetSize;
       if (HasAddressTaken(I, NewAllocSize))
         return true;
       break;
     }
     case Instruction::BitCast:
     case Instruction::Select:
     case Instruction::AddrSpaceCast:
       if (HasAddressTaken(I, AllocSize))

llvm/lib/IR/DataLayout.cpp

if (!isAligned(TyAlign, StructSize)) {
       StructSize = alignTo(StructSize, TyAlign);
     }
 
     // Keep track of maximum alignment constraint.
     StructAlignment = std::max(TyAlign, StructAlignment);
 
     getMemberOffsets()[i] = StructSize;
     // Consume space for this data item
-    StructSize += DL.getTypeAllocSize(Ty).getFixedValue();
+    StructSize += DL.getTypeAllocSize(Ty).getFixedSize();
   }
 
   // Add padding to the end of the struct so that it could be put in an array
   // and all array elements would be aligned correctly.
   if (!isAligned(StructAlignment, StructSize)) {
     IsPadded = true;
     StructSize = alignTo(StructSize, StructAlignment);
   }

llvm/lib/Target/AArch64/AArch64ISelLowering.h

public:
   bool hasAndNot(SDValue Y) const override {
     EVT VT = Y.getValueType();
 
     if (!VT.isVector())
       return hasAndNotCompare(Y);
 
     TypeSize TS = VT.getSizeInBits();
     // TODO: We should be able to use bic/bif too for SVE.
-    return !TS.isScalable() && TS.getFixedValue() >= 64; // vector 'bic'
+    return !TS.isScalable() && TS.getFixedSize() >= 64; // vector 'bic'
   }
 
   bool shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd(
       SDValue X, ConstantSDNode *XC, ConstantSDNode *CC, SDValue Y,
       unsigned OldShiftOpcode, unsigned NewShiftOpcode,
       SelectionDAG &DAG) const override;
 
   bool shouldExpandShift(SelectionDAG &DAG, SDNode *N) const override;

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

if (SrcVTSize == TypeSize::Fixed(VTSize))
       continue;
 
     // This stage of the search produces a source with the same element type as
     // the original, but with a total width matching the BUILD_VECTOR output.
     EVT EltVT = SrcVT.getVectorElementType();
     unsigned NumSrcElts = VTSize / EltVT.getFixedSizeInBits();
     EVT DestVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumSrcElts);
 
-    if (SrcVTSize.getFixedValue() < VTSize) {
+    if (SrcVTSize.getFixedSize() < VTSize) {
       assert(2 * SrcVTSize == VTSize);
       // We can pad out the smaller vector for free, so if it's part of a
       // shuffle...
       Src.ShuffleVec =
           DAG.getNode(ISD::CONCAT_VECTORS, dl, DestVT, Src.ShuffleVec,
                       DAG.getUNDEF(Src.ShuffleVec.getValueType()));
       continue;
     }
 
-    if (SrcVTSize.getFixedValue() != 2 * VTSize) {
+    if (SrcVTSize.getFixedSize() != 2 * VTSize) {
       LLVM_DEBUG(
           dbgs() << "Reshuffle failed: result vector too small to extract\n");
       return SDValue();
     }
 
     if (Src.MaxElt - Src.MinElt >= NumSrcElts) {
       LLVM_DEBUG(
           dbgs() << "Reshuffle failed: span too large for a VEXT to cope\n");

llvm/lib/Target/AMDGPU/AMDGPULowerModuleLDSPass.cpp

chooseBestVariableForModuleStrategy(const DataLayout &DL,
     for (auto &K : LDSVars) {
       GlobalVariable *GV = K.first;
       if (K.second.size() <= 1) {
         // A variable reachable by only one kernel is best lowered with kernel
         // strategy
         continue;
       }
       CandidateTy Candidate(GV, K.second.size(),
-                      DL.getTypeAllocSize(GV->getValueType()).getFixedValue());
+                      DL.getTypeAllocSize(GV->getValueType()).getFixedSize());
       if (MostUsed < Candidate)
         MostUsed = Candidate;
     }
 
     return MostUsed.GV;
   }
 
   bool runOnModule(Module &M) override {

llvm/lib/Target/Hexagon/HexagonVectorCombine.cpp

auto HexagonVectorCombine::getSizeOf(const Value *Val, SizeKind Kind) const
   return getSizeOf(Val->getType(), Kind);
 }
 
 auto HexagonVectorCombine::getSizeOf(const Type *Ty, SizeKind Kind) const
     -> int {
   auto *NcTy = const_cast<Type *>(Ty);
   switch (Kind) {
   case Store:
-    return DL.getTypeStoreSize(NcTy).getFixedValue();
+    return DL.getTypeStoreSize(NcTy).getFixedSize();
   case Alloc:
-    return DL.getTypeAllocSize(NcTy).getFixedValue();
+    return DL.getTypeAllocSize(NcTy).getFixedSize();
   }
   llvm_unreachable("Unhandled SizeKind enum");
 }
 
 auto HexagonVectorCombine::getTypeAlignment(Type *Ty) const -> int {
   // The actual type may be shorter than the HVX vector, so determine
   // the alignment based on subtarget info.
   if (HST.isTypeForHVX(Ty))

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

RISCVTargetLowering::RISCVTargetLowering(const TargetMachine &TM,
   if (Subtarget.hasVInstructions()) {
     auto addRegClassForRVV = [this](MVT VT) {
       // Disable the smallest fractional LMUL types if ELEN is less than
       // RVVBitsPerBlock.
       unsigned MinElts = RISCV::RVVBitsPerBlock / Subtarget.getELEN();
       if (VT.getVectorMinNumElements() < MinElts)
         return;
 
-      unsigned Size = VT.getSizeInBits().getKnownMinValue();
+      unsigned Size = VT.getSizeInBits().getKnownMinSize();
       const TargetRegisterClass *RC;
       if (Size <= RISCV::RVVBitsPerBlock)
         RC = &RISCV::VRRegClass;
       else if (Size == 2 * RISCV::RVVBitsPerBlock)
         RC = &RISCV::VRM2RegClass;
       else if (Size == 4 * RISCV::RVVBitsPerBlock)
         RC = &RISCV::VRM4RegClass;
       else if (Size == 8 * RISCV::RVVBitsPerBlock)
case ISD::SETULE:
     CC = ISD::getSetCCSwappedOperands(CC);
     std::swap(LHS, RHS);
     break;
   }
 }
 
 RISCVII::VLMUL RISCVTargetLowering::getLMUL(MVT VT) {
   assert(VT.isScalableVector() && "Expecting a scalable vector type");
-  unsigned KnownSize = VT.getSizeInBits().getKnownMinValue();
+  unsigned KnownSize = VT.getSizeInBits().getKnownMinSize();
   if (VT.getVectorElementType() == MVT::i1)
     KnownSize *= 8;
 
   switch (KnownSize) {
   default:
     llvm_unreachable("Invalid LMUL.");
   case 8:
     return RISCVII::VLMUL::LMUL_F8;
case Intrinsic::riscv_vslide1down_mask: {
 
     // Double the VL since we halved SEW.
     SDValue AVL = getVLOperand(Op);
     SDValue I32VL;
 
     // Optimize for constant AVL
     if (isa<ConstantSDNode>(AVL)) {
       unsigned EltSize = VT.getScalarSizeInBits();
-      unsigned MinSize = VT.getSizeInBits().getKnownMinValue();
+      unsigned MinSize = VT.getSizeInBits().getKnownMinSize();
 
       unsigned VectorBitsMax = Subtarget.getRealMaxVLen();
       unsigned MaxVLMAX =
           RISCVTargetLowering::computeVLMAX(VectorBitsMax, EltSize, MinSize);
 
       unsigned VectorBitsMin = Subtarget.getRealMinVLen();
       unsigned MinVLMAX =
           RISCVTargetLowering::computeVLMAX(VectorBitsMin, EltSize, MinSize);
SDValue RISCVTargetLowering::lowerVECTOR_REVERSE(SDValue Op,
   MVT VecVT = Op.getSimpleValueType();
   if (VecVT.getVectorElementType() == MVT::i1) {
     MVT WidenVT = MVT::getVectorVT(MVT::i8, VecVT.getVectorElementCount());
     SDValue Op1 = DAG.getNode(ISD::ZERO_EXTEND, DL, WidenVT, Op.getOperand(0));
     SDValue Op2 = DAG.getNode(ISD::VECTOR_REVERSE, DL, WidenVT, Op1);
     return DAG.getNode(ISD::TRUNCATE, DL, VecVT, Op2);
   }
   unsigned EltSize = VecVT.getScalarSizeInBits();
-  unsigned MinSize = VecVT.getSizeInBits().getKnownMinValue();
+  unsigned MinSize = VecVT.getSizeInBits().getKnownMinSize();
   unsigned VectorBitsMax = Subtarget.getRealMaxVLen();
   unsigned MaxVLMAX =
     RISCVTargetLowering::computeVLMAX(VectorBitsMax, EltSize, MinSize);
 
   unsigned GatherOpc = RISCVISD::VRGATHER_VV_VL;
   MVT IntVT = VecVT.changeVectorElementTypeToInteger();
 
   // If this is SEW=8 and VLMAX is potentially more than 256, we need

llvm/lib/Target/RISCV/RISCVTargetTransformInfo.cpp

if (isa<VectorType>(Dst) && isa<VectorType>(Src)) {
     }
   }
   return BaseT::getCastInstrCost(Opcode, Dst, Src, CCH, CostKind, I);
 }
 
 unsigned RISCVTTIImpl::getEstimatedVLFor(VectorType *Ty) {
   if (isa<ScalableVectorType>(Ty)) {
     const unsigned EltSize = DL.getTypeSizeInBits(Ty->getElementType());
-    const unsigned MinSize = DL.getTypeSizeInBits(Ty).getKnownMinValue();
+    const unsigned MinSize = DL.getTypeSizeInBits(Ty).getKnownMinSize();
     const unsigned VectorBits = *getVScaleForTuning() * RISCV::RVVBitsPerBlock;
     return RISCVTargetLowering::computeVLMAX(VectorBits, EltSize, MinSize);
   }
   return cast<FixedVectorType>(Ty)->getNumElements();
 }
 
 InstructionCost
 RISCVTTIImpl::getMinMaxReductionCost(VectorType *Ty, VectorType *CondTy,
void RISCVTTIImpl::getPeelingPreferences(Loop *L, ScalarEvolution &SE,
                                          TTI::PeelingPreferences &PP) {
   BaseT::getPeelingPreferences(L, SE, PP);
 }
 
 unsigned RISCVTTIImpl::getRegUsageForType(Type *Ty) {
   TypeSize Size = DL.getTypeSizeInBits(Ty);
   if (Ty->isVectorTy()) {
     if (Size.isScalable() && ST->hasVInstructions())
-      return divideCeil(Size.getKnownMinValue(), RISCV::RVVBitsPerBlock);
+      return divideCeil(Size.getKnownMinSize(), RISCV::RVVBitsPerBlock);
 
     if (ST->useRVVForFixedLengthVectors())
       return divideCeil(Size, ST->getRealMinVLen());
   }
 
   return BaseT::getRegUsageForType(Ty);
 }
 
 unsigned RISCVTTIImpl::getMaximumVF(unsigned ElemWidth, unsigned Opcode) const {
   // This interface is currently only used by SLP.  Returning 1 (which is the
   // default value for SLPMaxVF) disables SLP. We currently have a cost modeling
   // problem w/ constant materialization which causes SLP to perform majorly
   // unprofitable transformations.
   // TODO: Figure out constant materialization cost modeling and remove.
   return SLPMaxVF;
 }

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

if (!GuaranteedToExecute &&
       // We won't be able to prove dereferenceability for negative offsets.
       if (Off < 0)
         return false;
 
       // If the offset is not aligned, an aligned base pointer won't help.
       if (!isAligned(I->getAlign(), Off))
         return false;
 
-      NeededDerefBytes = std::max(NeededDerefBytes, Off + Size.getFixedValue());
+      NeededDerefBytes = std::max(NeededDerefBytes, Off + Size.getFixedSize());
       NeededAlign = std::max(NeededAlign, I->getAlign());
     }
 
     Part.Alignment = std::max(Part.Alignment, I->getAlign());
     return true;
   };
 
   // Look for loads and stores that are guaranteed to execute on entry.

llvm/utils/TableGen/CodeGenDAGPatterns.cpp

for (unsigned M : Modes) {
     Changed |= berase_if(WS, std::bind(NoLength, VN, std::placeholders::_1));
   }
   return Changed;
 }
 
 namespace {
 struct TypeSizeComparator {
   bool operator()(const TypeSize &LHS, const TypeSize &RHS) const {
-    return std::make_tuple(LHS.isScalable(), LHS.getKnownMinValue()) <
-           std::make_tuple(RHS.isScalable(), RHS.getKnownMinValue());
+    return std::make_tuple(LHS.isScalable(), LHS.getKnownMinSize()) <
+           std::make_tuple(RHS.isScalable(), RHS.getKnownMinSize());
   }
 };
 } // end anonymous namespace
 
 /// 1. Ensure that for each type T in A, there exists a type U in B,
 ///    such that T and U have equal size in bits.
 /// 2. Ensure that for each type U in B, there exists a type T in A
 ///    such that T and U have equal size in bits (reverse of 1).