Revert llvm#110102, llvm#124767, and dependent patches.

This reverts commits:
  de9b0dd
  8578b81
  822f74a
  8ad9e1e
  4424c44
  548ecde

Author: SLTozer

clang/docs/ReleaseNotes.rst

@@ -527,15 +527,15 @@ New Compiler Flags
   Clang to generate code that tries to preserve the liveness of source variables
   through optimizations, meaning that variables will typically be visible in a
   debugger more often. The flag has two levels: ``-fextend-variable-liveness``,
-  or ``-fextend-variable-liveness=all``, extends the liveness of all user
-  variables and the ``this`` pointer. Alternatively
-  ``-fextend-variable-liveness=this`` has the same behaviour but applies only to
-  the ``this`` variable in C++ class member functions, meaning its effect is a
-  strict subset of ``-fextend-variable-liveness``. Note that this flag modifies
-  the results of optimizations that Clang performs, which will result in reduced
-  performance in generated code; however, this feature will not extend the
-  liveness of some variables in cases where doing so would likely have a severe
-  impact on generated code performance.
+  or ``-fextend-variable-liveness=all``, extendes the liveness of all user
+  variables and the ``this`` pointer. Alternatively ``-fextend-this-ptr``, or
+  ``-fextend-variable-liveness=this``, has the same behaviour but applies only
+  to the ``this`` variable in C++ class member functions, meaning its effect is
+  a strict subset of ``-fextend-variable-liveness``. Note that this flag
+  modifies the results of optimizations that Clang performs, which will result
+  in reduced performance in generated code; however, this feature will not
+  extend the liveness of some variables in cases where doing so would likely
+  have a severe impact on generated code performance.
 
 - The ``-Warray-compare`` warning has been added to warn about array comparison
   on versions older than C++20.

clang/include/clang/Driver/Options.td

@@ -4352,11 +4352,19 @@ def stack_usage_file : Separate<["-"], "stack-usage-file">,
 def fextend_variable_liveness_EQ : Joined<["-"], "fextend-variable-liveness=">,
   Group<f_Group>, Visibility<[ClangOption, CC1Option]>,
   HelpText<"Extend the liveness of user variables through optimizations to "
-           "prevent stale or optimized-out variable values when debugging.">,
+           "prevent stale or optimized-out variable values when debugging. Can "
+           "be applied to all user variables, or just to the C++ 'this' ptr. "
+           "May choose not to extend the liveness of some variables, such as "
+           "non-scalars larger than 4 unsigned ints, or variables in any "
+           "inlined functions.">,
   Values<"all,this,none">,
   NormalizedValues<["All", "This", "None"]>,
   NormalizedValuesScope<"CodeGenOptions::ExtendVariableLivenessKind">,
   MarshallingInfoEnum<CodeGenOpts<"ExtendVariableLiveness">, "None">;
+def fextend_this_ptr_liveness : Flag<["-"], "fextend-this-ptr-liveness">,
+  Visibility<[ClangOption, CC1Option]>,
+  Alias<fextend_variable_liveness_EQ>, AliasArgs<["this"]>,
+  HelpText<"Alias for -fextend-variable-liveness=this.">;
 def fextend_variable_liveness : Flag<["-"], "fextend-variable-liveness">,
   Visibility<[ClangOption, CC1Option]>,
   Alias<fextend_variable_liveness_EQ>, AliasArgs<["all"]>,

clang/lib/CodeGen/CGCall.cpp

@@ -3581,26 +3581,15 @@ static llvm::StoreInst *findDominatingStoreToReturnValue(CodeGenFunction &CGF) {
     llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
     if (IP->empty()) return nullptr;
 
-    // Look at directly preceding instruction, skipping bitcasts, lifetime
-    // markers, and fake uses and their operands.
-    const llvm::Instruction *LoadIntoFakeUse = nullptr;
+    // Look at directly preceding instruction, skipping bitcasts and lifetime
+    // markers.
     for (llvm::Instruction &I : make_range(IP->rbegin(), IP->rend())) {
-      // Ignore instructions that are just loads for fake uses; the load should
-      // immediately precede the fake use, so we only need to remember the
-      // operand for the last fake use seen.
-      if (LoadIntoFakeUse == &I)
-        continue;
       if (isa<llvm::BitCastInst>(&I))
         continue;
-      if (auto *II = dyn_cast<llvm::IntrinsicInst>(&I)) {
+      if (auto *II = dyn_cast<llvm::IntrinsicInst>(&I))
         if (II->getIntrinsicID() == llvm::Intrinsic::lifetime_end)
           continue;
 
-        if (II->getIntrinsicID() == llvm::Intrinsic::fake_use) {
-          LoadIntoFakeUse = dyn_cast<llvm::Instruction>(II->getArgOperand(0));
-          continue;
-        }
-      }
       return GetStoreIfValid(&I);
     }
     return nullptr;

clang/lib/CodeGen/CGCleanup.cpp

@@ -112,15 +112,11 @@ void EHScopeStack::deallocate(size_t Size) {
   StartOfData += llvm::alignTo(Size, ScopeStackAlignment);
 }
 
-bool EHScopeStack::containsOnlyNoopCleanups(
+bool EHScopeStack::containsOnlyLifetimeMarkers(
     EHScopeStack::stable_iterator Old) const {
   for (EHScopeStack::iterator it = begin(); stabilize(it) != Old; it++) {
     EHCleanupScope *cleanup = dyn_cast<EHCleanupScope>(&*it);
-    // If this is anything other than a lifetime marker or fake use cleanup,
-    // then the scope stack does not contain only noop cleanups.
-    if (!cleanup)
-      return false;
-    if (!cleanup->isLifetimeMarker() && !cleanup->isFakeUse())
+    if (!cleanup || !cleanup->isLifetimeMarker())
       return false;
   }
 
@@ -158,7 +154,6 @@ void *EHScopeStack::pushCleanup(CleanupKind Kind, size_t Size) {
   bool IsNormalCleanup = Kind & NormalCleanup;
   bool IsEHCleanup = Kind & EHCleanup;
   bool IsLifetimeMarker = Kind & LifetimeMarker;
-  bool IsFakeUse = Kind & FakeUse;
 
   // Per C++ [except.terminate], it is implementation-defined whether none,
   // some, or all cleanups are called before std::terminate. Thus, when
@@ -181,8 +176,6 @@ void *EHScopeStack::pushCleanup(CleanupKind Kind, size_t Size) {
     InnermostEHScope = stable_begin();
   if (IsLifetimeMarker)
     Scope->setLifetimeMarker();
-  if (IsFakeUse)
-    Scope->setFakeUse();
 
   // With Windows -EHa, Invoke llvm.seh.scope.begin() for EHCleanup
   // If exceptions are disabled/ignored and SEH is not in use, then there is no

clang/lib/CodeGen/CGCleanup.h

@@ -87,10 +87,6 @@ class EHScope {
     LLVM_PREFERRED_TYPE(bool)
     unsigned IsLifetimeMarker : 1;
 
-    /// Whether this cleanup is a fake use
-    LLVM_PREFERRED_TYPE(bool)
-    unsigned IsFakeUse : 1;
-
     /// Whether the normal cleanup should test the activation flag.
     LLVM_PREFERRED_TYPE(bool)
     unsigned TestFlagInNormalCleanup : 1;
@@ -356,7 +352,6 @@ class alignas(8) EHCleanupScope : public EHScope {
     CleanupBits.IsEHCleanup = isEH;
     CleanupBits.IsActive = true;
     CleanupBits.IsLifetimeMarker = false;
-    CleanupBits.IsFakeUse = false;
     CleanupBits.TestFlagInNormalCleanup = false;
     CleanupBits.TestFlagInEHCleanup = false;
     CleanupBits.CleanupSize = cleanupSize;
@@ -389,9 +384,6 @@ class alignas(8) EHCleanupScope : public EHScope {
   bool isLifetimeMarker() const { return CleanupBits.IsLifetimeMarker; }
   void setLifetimeMarker() { CleanupBits.IsLifetimeMarker = true; }
 
-  bool isFakeUse() const { return CleanupBits.IsFakeUse; }
-  void setFakeUse() { CleanupBits.IsFakeUse = true; }
-
   bool hasActiveFlag() const { return ActiveFlag.isValid(); }
   Address getActiveFlag() const {
     return ActiveFlag;

clang/lib/CodeGen/CGDecl.cpp

@@ -1355,14 +1355,6 @@ void CodeGenFunction::EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr) {
   C->setDoesNotThrow();
 }
 
-void CodeGenFunction::EmitFakeUse(Address Addr) {
-  auto NL = ApplyDebugLocation::CreateEmpty(*this);
-  llvm::Value *V = Builder.CreateLoad(Addr, "fake.use");
-  llvm::CallInst *C = Builder.CreateCall(CGM.getLLVMFakeUseFn(), {V});
-  C->setDoesNotThrow();
-  C->setTailCallKind(llvm::CallInst::TCK_NoTail);
-}
-
 void CodeGenFunction::EmitAndRegisterVariableArrayDimensions(
     CGDebugInfo *DI, const VarDecl &D, bool EmitDebugInfo) {
   // For each dimension stores its QualType and corresponding
@@ -1422,39 +1414,6 @@ void CodeGenFunction::EmitAndRegisterVariableArrayDimensions(
   }
 }
 
-/// Return the maximum size of an aggregate for which we generate a fake use
-/// intrinsic when -fextend-variable-liveness is in effect.
-static uint64_t maxFakeUseAggregateSize(const ASTContext &C) {
-  return 4 * C.getTypeSize(C.UnsignedIntTy);
-}
-
-// Helper function to determine whether a variable's or parameter's lifetime
-// should be extended.
-static bool shouldExtendLifetime(const ASTContext &Context,
-                                 const Decl *FuncDecl, const VarDecl &D,
-                                 ImplicitParamDecl *CXXABIThisDecl) {
-  // When we're not inside a valid function it is unlikely that any
-  // lifetime extension is useful.
-  if (!FuncDecl)
-    return false;
-  if (FuncDecl->isImplicit())
-    return false;
-  // Do not extend compiler-created variables except for the this pointer.
-  if (D.isImplicit() && &D != CXXABIThisDecl)
-    return false;
-  QualType Ty = D.getType();
-  // No need to extend volatiles, they have a memory location.
-  if (Ty.isVolatileQualified())
-    return false;
-  // Don't extend variables that exceed a certain size.
-  if (Context.getTypeSize(Ty) > maxFakeUseAggregateSize(Context))
-    return false;
-  // Do not extend variables in nodebug or optnone functions.
-  if (FuncDecl->hasAttr<NoDebugAttr>() || FuncDecl->hasAttr<OptimizeNoneAttr>())
-    return false;
-  return true;
-}
-
 /// EmitAutoVarAlloca - Emit the alloca and debug information for a
 /// local variable.  Does not emit initialization or destruction.
 CodeGenFunction::AutoVarEmission
@@ -1707,18 +1666,6 @@ CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
                                          emission.getOriginalAllocatedAddress(),
                                          emission.getSizeForLifetimeMarkers());
 
-  // Analogous to lifetime markers, we use a 'cleanup' to emit fake.use
-  // calls for local variables. We are exempting volatile variables and
-  // non-scalars larger than 4 times the size of an unsigned int. Larger
-  // non-scalars are often allocated in memory and may create unnecessary
-  // overhead.
-  if (CGM.getCodeGenOpts().getExtendVariableLiveness() ==
-      CodeGenOptions::ExtendVariableLivenessKind::All) {
-    if (shouldExtendLifetime(getContext(), CurCodeDecl, D, CXXABIThisDecl))
-      EHStack.pushCleanup<FakeUse>(NormalFakeUse,
-                                   emission.getAllocatedAddress());
-  }
-
   return emission;
 }
 
@@ -2585,15 +2532,6 @@ llvm::Function *CodeGenModule::getLLVMLifetimeEndFn() {
   return LifetimeEndFn;
 }
 
-/// Lazily declare the @llvm.fake.use intrinsic.
-llvm::Function *CodeGenModule::getLLVMFakeUseFn() {
-  if (FakeUseFn)
-    return FakeUseFn;
-  FakeUseFn = llvm::Intrinsic::getOrInsertDeclaration(
-      &getModule(), llvm::Intrinsic::fake_use);
-  return FakeUseFn;
-}
-
 namespace {
   /// A cleanup to perform a release of an object at the end of a
   /// function.  This is used to balance out the incoming +1 of a
@@ -2787,18 +2725,6 @@ void CodeGenFunction::EmitParmDecl(const VarDecl &D, ParamValue Arg,
 
   setAddrOfLocalVar(&D, DeclPtr);
 
-  // Push a FakeUse 'cleanup' object onto the EHStack for the parameter,
-  // which may be the 'this' pointer. This causes the emission of a fake.use
-  // call with the parameter as argument at the end of the function.
-  if (CGM.getCodeGenOpts().getExtendVariableLiveness() ==
-          CodeGenOptions::ExtendVariableLivenessKind::All ||
-      (CGM.getCodeGenOpts().getExtendVariableLiveness() ==
-           CodeGenOptions::ExtendVariableLivenessKind::This &&
-       &D == CXXABIThisDecl)) {
-    if (shouldExtendLifetime(getContext(), CurCodeDecl, D, CXXABIThisDecl))
-      EHStack.pushCleanup<FakeUse>(NormalFakeUse, DeclPtr);
-  }
-
   // Emit debug info for param declarations in non-thunk functions.
   if (CGDebugInfo *DI = getDebugInfo()) {
     if (CGM.getCodeGenOpts().hasReducedDebugInfo() && !CurFuncIsThunk &&

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -404,9 +404,9 @@ void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
   // important to do this before we enter the return block or return
   // edges will be *really* confused.
   bool HasCleanups = EHStack.stable_begin() != PrologueCleanupDepth;
-  bool HasOnlyNoopCleanups =
-      HasCleanups && EHStack.containsOnlyNoopCleanups(PrologueCleanupDepth);
-  bool EmitRetDbgLoc = !HasCleanups || HasOnlyNoopCleanups;
+  bool HasOnlyLifetimeMarkers =
+      HasCleanups && EHStack.containsOnlyLifetimeMarkers(PrologueCleanupDepth);
+  bool EmitRetDbgLoc = !HasCleanups || HasOnlyLifetimeMarkers;
 
   std::optional<ApplyDebugLocation> OAL;
   if (HasCleanups) {

clang/lib/CodeGen/CodeGenFunction.h

@@ -723,20 +723,6 @@ class CodeGenFunction : public CodeGenTypeCache {
     }
   };
 
-  // We are using objects of this 'cleanup' class to emit fake.use calls
-  // for -fextend-variable-liveness. They are placed at the end of a variable's
-  // scope analogous to lifetime markers.
-  class FakeUse final : public EHScopeStack::Cleanup {
-    Address Addr;
-
-  public:
-    FakeUse(Address addr) : Addr(addr) {}
-
-    void Emit(CodeGenFunction &CGF, Flags flags) override {
-      CGF.EmitFakeUse(Addr);
-    }
-  };
-
   /// Header for data within LifetimeExtendedCleanupStack.
   struct LifetimeExtendedCleanupHeader {
     /// The size of the following cleanup object.
@@ -5089,8 +5075,6 @@ class CodeGenFunction : public CodeGenTypeCache {
 
   RValue EmitAtomicExpr(AtomicExpr *E);
 
-  void EmitFakeUse(Address Addr);
-
   //===--------------------------------------------------------------------===//
   //                         Annotations Emission
   //===--------------------------------------------------------------------===//

clang/lib/CodeGen/CodeGenModule.h

@@ -647,9 +647,6 @@ class CodeGenModule : public CodeGenTypeCache {
   /// void @llvm.lifetime.end(i64 %size, i8* nocapture <ptr>)
   llvm::Function *LifetimeEndFn = nullptr;
 
-  /// void @llvm.fake.use(...)
-  llvm::Function *FakeUseFn = nullptr;
-
   std::unique_ptr<SanitizerMetadata> SanitizerMD;
 
   llvm::MapVector<const Decl *, bool> DeferredEmptyCoverageMappingDecls;
@@ -1329,7 +1326,6 @@ class CodeGenModule : public CodeGenTypeCache {
 
   llvm::Function *getLLVMLifetimeStartFn();
   llvm::Function *getLLVMLifetimeEndFn();
-  llvm::Function *getLLVMFakeUseFn();
 
   // Make sure that this type is translated.
   void UpdateCompletedType(const TagDecl *TD);

clang/lib/CodeGen/EHScopeStack.h

@@ -87,11 +87,6 @@ enum CleanupKind : unsigned {
 
   LifetimeMarker = 0x8,
   NormalEHLifetimeMarker = LifetimeMarker | NormalAndEHCleanup,
-
-  // FakeUse needs to be recognized as a special cleanup similar to lifetime
-  // markers chiefly to be ignored in most contexts.
-  FakeUse = 0x10,
-  NormalFakeUse = FakeUse | NormalCleanup,
 };
 
 /// A stack of scopes which respond to exceptions, including cleanups
@@ -357,8 +352,8 @@ class EHScopeStack {
   void popTerminate();
 
   // Returns true iff the current scope is either empty or contains only
-  // noop cleanups, i.e. lifetime markers and fake uses.
-  bool containsOnlyNoopCleanups(stable_iterator Old) const;
+  // lifetime markers, i.e. no real cleanup code
+  bool containsOnlyLifetimeMarkers(stable_iterator Old) const;
 
   /// Determines whether the exception-scopes stack is empty.
   bool empty() const { return StartOfData == EndOfBuffer; }