[llvm] aec36a4 - [GlobalISel] Use ComputeValueTypes to implement computeValueLLTs (NFC) (#168172)

[via llvm-commits]

Author: Sergei Barannikov
Date: 2025-12-31T15:20:21+03:00
New Revision: aec36a4273c19b9e473771ad9a78d394d59f045b

URL: https://github.com/llvm/llvm-project/commit/aec36a4273c19b9e473771ad9a78d394d59f045b
DIFF: https://github.com/llvm/llvm-project/commit/aec36a4273c19b9e473771ad9a78d394d59f045b.diff

LOG: [GlobalISel] Use ComputeValueTypes to implement computeValueLLTs (NFC) (#168172)

Also add an overload returning TypeSize offsets. For now, it is only
called from the other overload.

Added: 
    

Modified: 
    llvm/include/llvm/CodeGen/Analysis.h
    llvm/lib/CodeGen/Analysis.cpp

Removed: 
    


################################################################################
diff  --git a/llvm/include/llvm/CodeGen/Analysis.h b/llvm/include/llvm/CodeGen/Analysis.h
index 2f1364d199710..debbaa80bd2d2 100644
--- a/llvm/include/llvm/CodeGen/Analysis.h
+++ b/llvm/include/llvm/CodeGen/Analysis.h
@@ -88,9 +88,13 @@ void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty,
 /// with the in-memory offsets of each of the individual values.
 ///
 void computeValueLLTs(const DataLayout &DL, Type &Ty,
-                      SmallVectorImpl<LLT> &ValueTys,
-                      SmallVectorImpl<uint64_t> *Offsets = nullptr,
-                      uint64_t StartingOffset = 0);
+                      SmallVectorImpl<LLT> &ValueLLTs,
+                      SmallVectorImpl<TypeSize> *Offsets = nullptr,
+                      TypeSize StartingOffset = TypeSize::getZero());
+void computeValueLLTs(const DataLayout &DL, Type &Ty,
+                      SmallVectorImpl<LLT> &ValueLLTs,
+                      SmallVectorImpl<uint64_t> *FixedOffsets,
+                      uint64_t FixedStartingOffset = 0);
 
 /// ExtractTypeInfo - Returns the type info, possibly bitcast, encoded in V.
 GlobalValue *ExtractTypeInfo(Value *V);

diff  --git a/llvm/lib/CodeGen/Analysis.cpp b/llvm/lib/CodeGen/Analysis.cpp
index f5fbfb7e5e21d..94ab6c6514869 100644
--- a/llvm/lib/CodeGen/Analysis.cpp
+++ b/llvm/lib/CodeGen/Analysis.cpp
@@ -123,6 +123,9 @@ void llvm::ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL,
                            TypeSize StartingOffset) {
   SmallVector<Type *> Types;
   ComputeValueTypes(DL, Ty, Types, Offsets, StartingOffset);
+  ValueVTs.reserve(Types.size());
+  if (MemVTs)
+    MemVTs->reserve(Types.size());
   for (Type *Ty : Types) {
     ValueVTs.push_back(TLI.getValueType(DL, Ty));
     if (MemVTs)
@@ -139,6 +142,7 @@ void llvm::ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL,
   if (FixedOffsets) {
     SmallVector<TypeSize, 4> Offsets;
     ComputeValueVTs(TLI, DL, Ty, ValueVTs, MemVTs, &Offsets, Offset);
+    FixedOffsets->reserve(Offsets.size());
     for (TypeSize Offset : Offsets)
       FixedOffsets->push_back(Offset.getFixedValue());
   } else {
@@ -147,38 +151,30 @@ void llvm::ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL,
 }
 
 void llvm::computeValueLLTs(const DataLayout &DL, Type &Ty,
-                            SmallVectorImpl<LLT> &ValueTys,
-                            SmallVectorImpl<uint64_t> *Offsets,
-                            uint64_t StartingOffset) {
-  // Given a struct type, recursively traverse the elements.
-  if (StructType *STy = dyn_cast<StructType>(&Ty)) {
-    // If the Offsets aren't needed, don't query the struct layout. This allows
-    // us to support structs with scalable vectors for operations that don't
-    // need offsets.
-    const StructLayout *SL = Offsets ? DL.getStructLayout(STy) : nullptr;
-    for (unsigned I = 0, E = STy->getNumElements(); I != E; ++I) {
-      uint64_t EltOffset = SL ? SL->getElementOffset(I) : 0;
-      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();
-    for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i)
-      computeValueLLTs(DL, *EltTy, ValueTys, Offsets,
-                       StartingOffset + i * EltSize);
-    return;
+                            SmallVectorImpl<LLT> &ValueLLTs,
+                            SmallVectorImpl<TypeSize> *Offsets,
+                            TypeSize StartingOffset) {
+  SmallVector<Type *> ValTys;
+  ComputeValueTypes(DL, &Ty, ValTys, Offsets, StartingOffset);
+  ValueLLTs.reserve(ValTys.size());
+  for (Type *ValTy : ValTys)
+    ValueLLTs.push_back(getLLTForType(*ValTy, DL));
+}
+
+void llvm::computeValueLLTs(const DataLayout &DL, Type &Ty,
+                            SmallVectorImpl<LLT> &ValueLLTs,
+                            SmallVectorImpl<uint64_t> *FixedOffsets,
+                            uint64_t FixedStartingOffset) {
+  TypeSize StartingOffset = TypeSize::getFixed(FixedStartingOffset);
+  if (FixedOffsets) {
+    SmallVector<TypeSize, 4> Offsets;
+    computeValueLLTs(DL, Ty, ValueLLTs, &Offsets, StartingOffset);
+    FixedOffsets->reserve(Offsets.size());
+    for (TypeSize Offset : Offsets)
+      FixedOffsets->push_back(Offset.getFixedValue());
+  } else {
+    computeValueLLTs(DL, Ty, ValueLLTs, nullptr, StartingOffset);
   }
-  // Interpret void as zero return values.
-  if (Ty.isVoidTy())
-    return;
-  // Base case: we can get an LLT for this LLVM IR type.
-  ValueTys.push_back(getLLTForType(Ty, DL));
-  if (Offsets)
-    Offsets->push_back(StartingOffset);
 }
 
 /// ExtractTypeInfo - Returns the type info, possibly bitcast, encoded in V.