Revert "[clang] Limit lifetimes of temporaries to the full expression (llvm#170517)"

This reverts commit 5daad5b.

That commit caused broken compilation for some cases, see
llvm#170517 (comment).

Author: mstorsjo

clang/docs/ReleaseNotes.rst

@@ -86,15 +86,6 @@ Potentially Breaking Changes
   options-related code has been moved out of the Driver into a separate library.
 - The ``clangFrontend`` library no longer depends on ``clangDriver``, which may
   break downstream projects that relied on this transitive dependency.
-- Clang is now more precise with regards to the lifetime of temporary objects
-  such as when aggregates are passed by value to a function, resulting in
-  better sharing of stack slots and reduced stack usage. This change can lead
-  to use-after-scope related issues in code that unintentionally relied on the
-  previous behavior. If recompiling with ``-fsanitize=address`` shows a
-  use-after-scope warning, then this is likely the case, and the report printed
-  should be able to help users pinpoint where the use-after-scope is occurring.
-  Users can use ``-Xclang -sloppy-temporary-lifetimes`` to retain the old
-  behavior until they are able to find and resolve issues in their code.
 
 C/C++ Language Potentially Breaking Changes
 -------------------------------------------

clang/include/clang/Basic/CodeGenOptions.def

@@ -475,10 +475,6 @@ ENUM_CODEGENOPT(ZeroCallUsedRegs, ZeroCallUsedRegsKind,
 /// non-deleting destructors. (No effect on Microsoft ABI.)
 CODEGENOPT(CtorDtorReturnThis, 1, 0, Benign)
 
-/// Set via -Xclang -sloppy-temporary-lifetimes to disable emission of lifetime
-/// marker intrinsic calls.
-CODEGENOPT(NoLifetimeMarkersForTemporaries, 1, 0, Benign)
-
 /// Enables emitting Import Call sections on supported targets that can be used
 /// by the Windows kernel to enable import call optimization.
 CODEGENOPT(ImportCallOptimization, 1, 0, Benign)

clang/include/clang/Options/Options.td

@@ -8317,11 +8317,6 @@ def import_call_optimization : Flag<["-"], "import-call-optimization">,
 def replaceable_function: Joined<["-"], "loader-replaceable-function=">,
   MarshallingInfoStringVector<CodeGenOpts<"LoaderReplaceableFunctionNames">>;
 
-def sloppy_temporary_lifetimes
-    : Flag<["-"], "sloppy-temporary-lifetimes">,
-      HelpText<"Don't emit lifetime markers for temporary objects">,
-      MarshallingInfoFlag<CodeGenOpts<"NoLifetimeMarkersForTemporaries">>;
-
 } // let Visibility = [CC1Option]
 
 //===----------------------------------------------------------------------===//

clang/lib/CodeGen/CGCall.cpp

@@ -4972,27 +4972,7 @@ void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E,
     return;
   }
 
-  AggValueSlot ArgSlot = AggValueSlot::ignored();
-  // For arguments with aggregate type, create an alloca to store
-  // the value.  If the argument's type has a destructor, that destructor
-  // will run at the end of the full-expression; emit matching lifetime
-  // markers.
-  //
-  // FIXME: For types which don't have a destructor, consider using a
-  // narrower lifetime bound.
-  if (hasAggregateEvaluationKind(E->getType())) {
-    RawAddress ArgSlotAlloca = Address::invalid();
-    ArgSlot = CreateAggTemp(E->getType(), "agg.tmp", &ArgSlotAlloca);
-
-    // Emit a lifetime start/end for this temporary at the end of the full
-    // expression.
-    if (!CGM.getCodeGenOpts().NoLifetimeMarkersForTemporaries &&
-        EmitLifetimeStart(ArgSlotAlloca.getPointer()))
-      pushFullExprCleanup<CallLifetimeEnd>(NormalEHLifetimeMarker,
-                                           ArgSlotAlloca);
-  }
-
-  args.add(EmitAnyExpr(E, ArgSlot), type);
+  args.add(EmitAnyExprToTemp(E), type);
 }
 
 QualType CodeGenFunction::getVarArgType(const Expr *Arg) {

clang/test/CodeGen/lifetime-call-temp.c

@@ -26,8 +26,6 @@ const char * f(S s)
 // CHECK: [[T2:%.*]] = alloca %class.T, align 4
 // CHECK: [[T3:%.*]] = alloca %class.T, align 4
 //
-// CHECK: [[AGG:%.*]] = alloca %class.S, align 4
-//
 // FIXME: We could defer starting the lifetime of the return object of concat
 // until the call.
 // CHECK: call void @llvm.lifetime.start.p0(ptr [[T1]])
@@ -36,12 +34,10 @@ const char * f(S s)
 // CHECK: [[T4:%.*]] = call noundef ptr @_ZN1TC1EPKc(ptr {{[^,]*}} [[T2]], ptr noundef @.str)
 //
 // CHECK: call void @llvm.lifetime.start.p0(ptr [[T3]])
-// CHECK: call void @llvm.lifetime.start.p0(ptr [[AGG]])
 // CHECK: [[T5:%.*]] = call noundef ptr @_ZN1TC1E1S(ptr {{[^,]*}} [[T3]], [2 x i32] %{{.*}})
 //
 // CHECK: call void @_ZNK1T6concatERKS_(ptr dead_on_unwind writable sret(%class.T) align 4 [[T1]], ptr {{[^,]*}} [[T2]], ptr noundef nonnull align 4 dereferenceable(16) [[T3]])
 // CHECK: [[T6:%.*]] = call noundef ptr @_ZNK1T3strEv(ptr {{[^,]*}} [[T1]])
-// CHECK: call void @llvm.lifetime.end.p0(ptr [[AGG]])
 //
 // CHECK: call void @llvm.lifetime.end.p0(
 // CHECK: call void @llvm.lifetime.end.p0(

clang/test/CodeGen/lifetime-invoke-c.c

@@ -49,7 +49,6 @@ void foo() {
 }
 
 // CHECK: cleanup.cont:{{.*}}
-// CHECK-NEXT: call void @llvm.lifetime.start.p0(ptr [[AGG:%agg.tmp]])
 // CHECK-NEXT: load i8
 // CHECK-NEXT: trunc
 // CHECK-NEXT: store i1 false
@@ -58,6 +57,3 @@ void foo() {
 // CHECK-NOT: call void @llvm.lifetime
 // CHECK: call void @llvm.coro.await.suspend.void(
 // CHECK-NEXT: %{{[0-9]+}} = call i8 @llvm.coro.suspend(
-
-// CHECK-LABEL: cond.end:
-// check call @llvm.lifetime.end.p0(ptr [[AGG]])