[Clang][CodeGen] Set the size of llvm.lifetime to unknown for scalable types.

[HsiangKai]

Summary

If the memory object is scalable type, we do not know the exact size of
it at compile time. Set the size of lifetime marker to unknown if the
object is scalable one.

[craig.topper]

Am I mistaken, or does this test already pass without these changes?

[HsiangKai]

In D102822#2770175, @craig.topper wrote:

Am I mistaken, or does this test already pass without these changes?

You are right. I didn't confirm it. I need to update the test case. Thanks.

[HsiangKai]

Update the test case.

[HsiangKai]

Ping.

[craig.topper]

clang/test/CodeGen/RISCV/riscv-v-lifetime.cpp

3 ↗

(On Diff #346656)

Probably best to add -disable-llvm-passes so we don't run the optimizer.

8 ↗

(On Diff #346656)

Are the templates needed? This was enough to fail for me

vint32m1_t Baz();                                                                                                                                                                                                               
                                                                                                                                                                                                                                
vint32m1_t Test() {                                                                                                                                                                                                             
  const vint32m1_t &a = Baz();                                                                                                                                                                                                  
  return a;                                                                                                                                                                                                                     
}

Or do the templates test additional code paths?

[sdesmalen]

clang/lib/CodeGen/CGDecl.cpp

1327

Instead of updating Size here, can you change line 1332 to be:

llvm::Value *SizeV = llvm::ConstantInt::get(Int64Ty, Size.isScalable() ? -1 : Size.getFixedValue())

1332

Does ConstantInt take TypeSize Size as argument?

1558

nit: Given you have to update this line, maybe also to capitalize size -> Size?

[HsiangKai]

Address comments.

[HsiangKai]

clang format.

[sdesmalen]

clang/test/CodeGen/RISCV/riscv-v-lifetime.cpp

17 ↗

(On Diff #349751)

nit: I'm not sure if there is any policy on this, but for this test you can just as well have 6 CHECK lines, instead of auto-generating all of them, which makes the test a bit easier to read.

// CHECK-LABEL: @_Z4Testv
// CHECK-NEXT:    [[ALLOCA:%.*]] = alloca <vscale x 2 x i32>, align 4
// CHECK-NEXT:    [[BC1:%.*]] = bitcast <vscale x 2 x i32>* [[ALLOCA]] to i8*
// CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[BC1]])
// CHECK-NEXT:    [[BC2:%.*]] = bitcast <vscale x 2 x i32>* [[ALLOCA]] to i8*
// CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[BC2]])

3 ↗

(On Diff #346656)

nit: Does -O1 still have any effect if -disable-llvm-passes is also set?

[craig.topper]

clang/test/CodeGen/RISCV/riscv-v-lifetime.cpp

3 ↗

(On Diff #346656)

Lifetime markers aren't emitted with -O0.

[HsiangKai]

Simplify the test case.

[sdesmalen]

LGTM, thanks @HsiangKai

clang/test/CodeGen/RISCV/riscv-v-lifetime.cpp

3 ↗

(On Diff #346656)

I didn't know that, thanks!

clang/lib/CodeGen/CGCall.cpp

#endif
   Address SRetAlloca = Address::invalid();
   llvm::Value *UnusedReturnSizePtr = nullptr;
   if (RetAI.isIndirect() || RetAI.isInAlloca() || RetAI.isCoerceAndExpand()) {
     if (!ReturnValue.isNull()) {
       SRetPtr = ReturnValue.getValue();
     } else {
       SRetPtr = CreateMemTemp(RetTy, "tmp", &SRetAlloca);
       if (HaveInsertPoint() && ReturnValue.isUnused()) {
-        uint64_t size =
+        llvm::TypeSize size =
             CGM.getDataLayout().getTypeAllocSize(ConvertTypeForMem(RetTy));
         UnusedReturnSizePtr = EmitLifetimeStart(size, SRetAlloca.getPointer());
       }
     }
     if (IRFunctionArgs.hasSRetArg()) {
       IRCallArgs[IRFunctionArgs.getSRetArgNo()] = SRetPtr.getPointer();
     } else if (RetAI.isInAlloca()) {
       Address Addr =
case ABIArgInfo::IndirectAliased: {
 
         if (NeedCopy) {
           // Create an aligned temporary, and copy to it.
           Address AI = CreateMemTempWithoutCast(
               I->Ty, ArgInfo.getIndirectAlign(), "byval-temp");
           IRCallArgs[FirstIRArg] = AI.getPointer();
 
           // Emit lifetime markers for the temporary alloca.
-          uint64_t ByvalTempElementSize =
+          llvm::TypeSize ByvalTempElementSize =
               CGM.getDataLayout().getTypeAllocSize(AI.getElementType());
           llvm::Value *LifetimeSize =
               EmitLifetimeStart(ByvalTempElementSize, AI.getPointer());
 
           // Add cleanup code to emit the end lifetime marker after the call.
           if (LifetimeSize) // In case we disabled lifetime markers.
             CallLifetimeEndAfterCall.emplace_back(AI, LifetimeSize);
 

clang/lib/CodeGen/CGDecl.cpp

void CodeGenFunction::EmitAutoVarDecl(const VarDecl &D) {
   AutoVarEmission emission = EmitAutoVarAlloca(D);
   EmitAutoVarInit(emission);
   EmitAutoVarCleanups(emission);
 }
 
 /// Emit a lifetime.begin marker if some criteria are satisfied.
 /// \return a pointer to the temporary size Value if a marker was emitted, null
 /// otherwise
-llvm::Value *CodeGenFunction::EmitLifetimeStart(uint64_t Size,
+llvm::Value *CodeGenFunction::EmitLifetimeStart(llvm::TypeSize Size,
                                                 llvm::Value *Addr) {
   if (!ShouldEmitLifetimeMarkers)
     return nullptr;
 
+  // Use -1 as the unknown size.
+  if (Size.isScalable())
+    Size = llvm::TypeSize::Fixed(-1);
+
   assert(Addr->getType()->getPointerAddressSpace() ==
              CGM.getDataLayout().getAllocaAddrSpace() &&
          "Pointer should be in alloca address space");
   llvm::Value *SizeV = llvm::ConstantInt::get(Int64Ty, Size);
   Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
   llvm::CallInst *C =
       Builder.CreateCall(CGM.getLLVMLifetimeStartFn(), {SizeV, Addr});
   C->setDoesNotThrow();
   return SizeV;
 }
 
 void CodeGenFunction::EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr) {
if (NRVO) {
         // actually come into scope; suppressing the lifetime annotations
         // completely in this case is unnecessarily pessimistic, but again, this
         // is rare.
         if (!Bypasses.IsBypassed(&D) &&
             !(!getLangOpts().CPlusPlus && hasLabelBeenSeenInCurrentScope())) {
           llvm::TypeSize size =
               CGM.getDataLayout().getTypeAllocSize(allocaTy);
           emission.SizeForLifetimeMarkers =
-              size.isScalable() ? EmitLifetimeStart(-1, AllocaAddr.getPointer())
-                                : EmitLifetimeStart(size.getFixedSize(),
-                                                    AllocaAddr.getPointer());
+              EmitLifetimeStart(size, AllocaAddr.getPointer());
         }
       } else {
         assert(!emission.useLifetimeMarkers());
       }
     }
   } else {
     EnsureInsertPoint();
 

clang/lib/CodeGen/CGExprAgg.cpp

void AggExprEmitter::withReturnValueSlot(
 
   EHScopeStack::stable_iterator LifetimeEndBlock;
   llvm::Value *LifetimeSizePtr = nullptr;
   llvm::IntrinsicInst *LifetimeStartInst = nullptr;
   if (!UseTemp) {
     RetAddr = Dest.getAddress();
   } else {
     RetAddr = CGF.CreateMemTemp(RetTy, "tmp", &RetAllocaAddr);
-    uint64_t Size =
+    llvm::TypeSize Size =
         CGF.CGM.getDataLayout().getTypeAllocSize(CGF.ConvertTypeForMem(RetTy));
     LifetimeSizePtr = CGF.EmitLifetimeStart(Size, RetAllocaAddr.getPointer());
     if (LifetimeSizePtr) {
       LifetimeStartInst =
           cast<llvm::IntrinsicInst>(std::prev(Builder.GetInsertPoint()));
       assert(LifetimeStartInst->getIntrinsicID() ==
                  llvm::Intrinsic::lifetime_start &&
              "Last insertion wasn't a lifetime.start?");

clang/lib/CodeGen/CodeGenFunction.h

public:
   void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType,
                         Address Ptr);
 
   void EmitSehCppScopeBegin();
   void EmitSehCppScopeEnd();
   void EmitSehTryScopeBegin();
   void EmitSehTryScopeEnd();
 
-  llvm::Value *EmitLifetimeStart(uint64_t Size, llvm::Value *Addr);
+  llvm::Value *EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr);
   void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr);
 
   llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
   void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
 
   void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
                       QualType DeleteTy, llvm::Value *NumElements = nullptr,
                       CharUnits CookieSize = CharUnits());

clang/test/CodeGen/RISCV/riscv-v-lifetime.c

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +experimental-v -emit-llvm \
+// RUN:   -O1 -o - %s | FileCheck %s
+
+#include <riscv_vector.h>
+
+extern void use(vint32m1_t *a);
+
+// CHECK-LABEL: @inlined(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A:%.*]] = alloca <vscale x 2 x i32>, align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = bitcast <vscale x 2 x i32>* [[A]] to i8*
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull [[TMP0]]) #[[ATTR4:[0-9]+]]
+// CHECK-NEXT:    call void @use(<vscale x 2 x i32>* nonnull [[A]]) #[[ATTR4]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull [[TMP0]]) #[[ATTR4]]
+// CHECK-NEXT:    ret void
+//
+__attribute__((always_inline)) void inlined() {
+  vint32m1_t a;
+  use(&a);
+}
+
+// CHECK-LABEL: @lifetime_test(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_I:%.*]] = alloca <vscale x 2 x i32>, align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = bitcast <vscale x 2 x i32>* [[A_I]] to i8*
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull [[TMP0]]) #[[ATTR4]]
+// CHECK-NEXT:    call void @use(<vscale x 2 x i32>* nonnull [[A_I]]) #[[ATTR4]]
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull [[TMP0]]) #[[ATTR4]]
+// CHECK-NEXT:    ret void
+//
+void lifetime_test() {
+  inlined();
+}