[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

4

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

9

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())

1328

Does ConstantInt take TypeSize Size as argument?

1554

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

4

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

18

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]])

[craig.topper]

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

4

Lifetime markers aren't emitted with -O0.

[HsiangKai]

Simplify the test case.

[sdesmalen]

LGTM, thanks @HsiangKai

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

4

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

 //===--- CGDecl.cpp - Emit LLVM Code for declarations ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This contains code to emit Decl nodes as LLVM code.
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;
 
   assert(Addr->getType()->getPointerAddressSpace() ==
              CGM.getDataLayout().getAllocaAddrSpace() &&
          "Pointer should be in alloca address space");
-  llvm::Value *SizeV = llvm::ConstantInt::get(Int64Ty, Size);
+  llvm::Value *SizeV = llvm::ConstantInt::get(Int64Ty, Size.isScalable() ? -1 : Size.getFixedValue());
   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) {
         // declaration. We also have to do it in C if there's a jump to an
         // earlier point in the current block because non-VLA lifetimes begin as
         // soon as the containing block is entered, not when its variables
         // 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 =
+          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.cpp

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -std=c++11 -triple riscv64 -target-feature +experimental-v \
+// RUN:   -O1 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s
+
+#include <riscv_vector.h>
+
+vint32m1_t Baz();
+
+// CHECK-LABEL: @_Z4Testv(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A:%.*]] = alloca <vscale x 2 x i32>*, align 8
+// CHECK-NEXT:    [[REF_TMP:%.*]] = 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 8, i8* [[TMP0]]) #[[ATTR3:[0-9]+]]
+// CHECK-NEXT:    [[TMP1:%.*]] = bitcast <vscale x 2 x i32>* [[REF_TMP]] to i8*
+// CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[TMP1]]) #[[ATTR3]]
+// CHECK-NEXT:    [[CALL:%.*]] = call <vscale x 2 x i32> @_Z3Bazv()
+// CHECK-NEXT:    store <vscale x 2 x i32> [[CALL]], <vscale x 2 x i32>* [[REF_TMP]], align 4, !tbaa [[TBAA4:![0-9]+]]
+// CHECK-NEXT:    store <vscale x 2 x i32>* [[REF_TMP]], <vscale x 2 x i32>** [[A]], align 8, !tbaa [[TBAA8:![0-9]+]]
+// CHECK-NEXT:    [[TMP2:%.*]] = load <vscale x 2 x i32>*, <vscale x 2 x i32>** [[A]], align 8, !tbaa [[TBAA8]]
+// CHECK-NEXT:    [[TMP3:%.*]] = load <vscale x 2 x i32>, <vscale x 2 x i32>* [[TMP2]], align 4, !tbaa [[TBAA4]]
+// CHECK-NEXT:    [[TMP4:%.*]] = bitcast <vscale x 2 x i32>* [[REF_TMP]] to i8*
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[TMP4]]) #[[ATTR3]]
+// CHECK-NEXT:    [[TMP5:%.*]] = bitcast <vscale x 2 x i32>** [[A]] to i8*
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 8, i8* [[TMP5]]) #[[ATTR3]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[TMP3]]
+//
+vint32m1_t Test() {
+  const vint32m1_t &a = Baz();
+  return a;
+}