[Clang][ExtendLifetimes][4/4] Add extend_lifetimes pragma to Clang to selectively disable -fextend-lifetimes for functions

[StephenTozer]

Summary

This patch is part of a set of patches that add an -fextend-lifetimes flag to clang, which extends the lifetimes of local variables and parameters for improved debuggability. In addition to that flag, the patch series adds a new function attribute to disable the post-RA scheduler (which is applied by -fextend-lifetimes), a pragma to selectively disable -fextend-lifetimes, and an -fextend-this-ptr flag which functions as -fextend-lifetimes for this pointers only. All changes and tests in these patches were written by @wolfgangp, though I will be managing these reviews and addressing any comments raised. Discussion on the approach of this patch series as a whole should be directed to the 3rd patch, D157613, in order to simplify review.

---

This particular patch adds a new pragma, pragma clang extend_lifetimes disable/enable that can be used to toggle -fextend-lifetimes for subsequent functions:

It may be useful for developers to keep certain functions (e.g. very hot function that do not need debugging) from having their variable lifetimes extended (which will hurt performance). The way to do this is to add #pragma clang extend_lifetimes disable prior to those functions, and #pragma clang extend_lifetimes enable afterwards. This is helpful during developer builds where the intention is to repeatedly edit-compile-debug, but the developer likely does not want #pragma clang extend_lifetimes enable to be extending variable lifetimes during Release builds. Therefore these pragmas will only have an effect when -fextend-lifetimes is passed.

clang/include/clang/Basic/AttrDocs.td

def MSNoVTableDocs : Documentation {
   let Category = DocCatDecl;
   let Content = [{
 This attribute can be added to a class declaration or definition to signal to
 the compiler that constructors and destructors will not reference the virtual
 function table. It is only supported when using the Microsoft C++ ABI.
   }];
 }
 
+def ExtendLifetimesDisableDocs : Documentation {
+  let Category = DocCatFunction;
+  let Heading = "#pragma clang extend_lifetimes disable, #pragma clang extend_lifetimes enable";
+  let Content = [{
+The ``#pragma clang extend_lifetimes disable`` directive can be used to
+selectively disable the ``-fextend-lifetimes`` and ``-fextend-this-ptr`` flags.
+This may be useful in cases where one of these options is used for development
+but results in very poor codegen for some functions. Functions defined after
+this pragma will have extend lifetimes/`this` suppressed;
+``#pragma clang extend_lifetimes enable`` can be used to reenable the lifetime
+extension for subsequent functions definitions. The directive can be used as
+follows:
+
+.. code-block:: c++
+
+  #pragma clang extend_lifetimes disable
+  void foo(...) {} // -fextend-lifetimes disabled for foo,
+  void bar(...) {} // also disabled for bar.
+  #pragma clang extend_lifetimes enable
+  void baz(...) {} // -fextend-lifetimes reenabled for baz.
+
+This directive has no effect if neither ``-fextend-lifetimes` nor
+`-fextend-this-ptr` are passed.
+  }];
+}
+
 def OptnoneDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 The ``optnone`` attribute suppresses essentially all optimizations
 on a function or method, regardless of the optimization level applied to
 the compilation unit as a whole. This is particularly useful when you
 need to debug a particular function, but it is infeasible to build the
 entire application without optimization. Avoiding optimization on the

clang/include/clang/Basic/DiagnosticParseKinds.td

def err_pragma_pointers_to_members_unknown_kind : Error<
   "unexpected %0, expected to see one of %select{|'best_case', 'full_generality', }1"
   "'single_inheritance', 'multiple_inheritance', or 'virtual_inheritance'">;
 // - #pragma clang optimize on/off
 def err_pragma_optimize_invalid_argument : Error<
   "unexpected argument '%0' to '#pragma clang optimize'; "
   "expected 'on' or 'off'">;
 def err_pragma_optimize_extra_argument : Error<
   "unexpected extra argument '%0' to '#pragma clang optimize'">;
+// - #pragma clang extend_lifetimes enable/disable
+def err_pragma_extend_lifetimes_invalid_argument : Error<
+  "unexpected argument '%0' to '#pragma clang extend_lifetimes'; "
+  "expected 'enable' or 'disable'">;
+def err_pragma_extend_lifetimes_extra_argument : Error<
+  "unexpected extra argument '%0' to '#pragma clang extend_lifetimes'">;
 // - #pragma clang attribute
 def err_pragma_attribute_expected_push_pop_paren : Error<
   "expected 'push', 'pop', or '(' after '#pragma clang attribute'">;
 def err_pragma_attribute_invalid_argument : Error<
   "unexpected argument '%0' to '#pragma clang attribute'; "
   "expected 'push' or 'pop'">;
 def err_pragma_attribute_expected_attribute : Error<
   "expected an attribute after '('">;

clang/include/clang/Parse/Parser.h

class Parser : public CodeCompletionHandler {
   std::unique_ptr<PragmaHandler> MSRuntimeChecks;
   std::unique_ptr<PragmaHandler> MSIntrinsic;
   std::unique_ptr<PragmaHandler> MSFunction;
   std::unique_ptr<PragmaHandler> MSOptimize;
   std::unique_ptr<PragmaHandler> MSFenvAccess;
   std::unique_ptr<PragmaHandler> MSAllocText;
   std::unique_ptr<PragmaHandler> CUDAForceHostDeviceHandler;
   std::unique_ptr<PragmaHandler> OptimizeHandler;
+  std::unique_ptr<PragmaHandler> ExtendLifetimesHandler;
   std::unique_ptr<PragmaHandler> LoopHintHandler;
   std::unique_ptr<PragmaHandler> UnrollHintHandler;
   std::unique_ptr<PragmaHandler> NoUnrollHintHandler;
   std::unique_ptr<PragmaHandler> UnrollAndJamHintHandler;
   std::unique_ptr<PragmaHandler> NoUnrollAndJamHintHandler;
   std::unique_ptr<PragmaHandler> FPHandler;
   std::unique_ptr<PragmaHandler> STDCFenvAccessHandler;
   std::unique_ptr<PragmaHandler> STDCFenvRoundHandler;

clang/include/clang/Sema/Sema.h

public:
   /// #pragma attribute stack.
   const Decl *PragmaAttributeCurrentTargetDecl;
 
   /// This represents the last location of a "#pragma clang optimize off"
   /// directive if such a directive has not been closed by an "on" yet. If
   /// optimizations are currently "on", this is set to an invalid location.
   SourceLocation OptimizeOffPragmaLocation;
 
+  /// This represents the last location of a "#pragma clang extend_lifetimes
+  /// disable" directive if such a directive has not been closed by an "enable"
+  /// yet. If extend_lifetimes is currently enabled, this is set to an invalid
+  /// location.
+  SourceLocation ExtendLifetimesDisablePragmaLocation;
+
   /// The "on" or "off" argument passed by \#pragma optimize, that denotes
   /// whether the optimizations in the list passed to the pragma should be
   /// turned off or on. This boolean is true by default because command line
   /// options are honored when `#pragma optimize("", on)`.
   /// (i.e. `ModifyFnAttributeMSPragmaOptimze()` does nothing)
   bool MSPragmaOptimizeIsOn = true;
 
   /// Set of no-builtin functions listed by \#pragma function.

   /// '\#pragma clang attribute push' directives to the given declaration.
   void AddPragmaAttributes(Scope *S, Decl *D);
 
   void DiagnoseUnterminatedPragmaAttribute();
 
   /// Called on well formed \#pragma clang optimize.
   void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);
 
+  /// Called on well formed \#pragma clang extend_lifetimes.
+  void ActOnPragmaExtendLifetimes(bool Enable, SourceLocation PragmaLoc);
+
   /// #pragma optimize("[optimization-list]", on | off).
   void ActOnPragmaMSOptimize(SourceLocation Loc, bool IsOn);
 
   /// Call on well formed \#pragma function.
   void
   ActOnPragmaMSFunction(SourceLocation Loc,
                         const llvm::SmallVectorImpl<StringRef> &NoBuiltins);
 
   /// Get the location for the currently active "\#pragma clang optimize
   /// off". If this location is invalid, then the state of the pragma is "on".
   SourceLocation getOptimizeOffPragmaLocation() const {
     return OptimizeOffPragmaLocation;
   }
 
+  /// Get the location for the currently active "\#pragma extend_lifetimes
+  /// disable". If this location is invalid, then the state of the pragma is
+  /// "enabled".
+  SourceLocation getExtendLifetimesDisablePragmaLocation() const {
+    return ExtendLifetimesDisablePragmaLocation;
+  }
+
   /// Only called on function definitions; if there is a pragma in scope
   /// with the effect of a range-based optnone, consider marking the function
   /// with attribute optnone.
   void AddRangeBasedOptnone(FunctionDecl *FD);
 
   /// Only called on function definitions; if there is a `#pragma alloc_text`
   /// that decides which code section the function should be in, add
   /// attribute section to the function.
   void AddSectionMSAllocText(FunctionDecl *FD);
 
   /// Adds the 'optnone' attribute to the function declaration if there
   /// are no conflicts; Loc represents the location causing the 'optnone'
   /// attribute to be added (usually because of a pragma).
   void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc);
 
+  /// For function definitions, if there is a pragma in scope with the effect
+  /// of disabling extend_lifetimes, mark the function with attribute
+  /// ExtendLifetimesDisable.
+  void AddRangeBasedExtendLifetimesDisable(FunctionDecl *FD);
+
+  /// Adds the ExtendLifetimesDisable attribute to the function declaration.
+  void AddExtendLifetimesDisableAttribute(FunctionDecl *FD, SourceLocation Loc);
+
   /// Only called on function definitions; if there is a MSVC #pragma optimize
   /// in scope, consider changing the function's attributes based on the
   /// optimization list passed to the pragma.
   void ModifyFnAttributesMSPragmaOptimize(FunctionDecl *FD);
 
   /// Only called on function definitions; if there is a pragma in scope
   /// with the effect of a range-based no_builtin, consider marking the function
   /// with attribute no_builtin.

clang/lib/CodeGen/CGDecl.cpp

static bool extendLifetime(const ASTContext &Context, const Decl *FuncDecl,
   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 functions.
   if (FuncDecl->hasAttr<NoDebugAttr>())
     return false;
+  // pragma clang extend_lifetimes disable has been seen.
+  if (FuncDecl->hasAttr<ExtendLifetimesDisableAttr>())
+    return false;
   return true;
 }
 
 /// EmitAutoVarAlloca - Emit the alloca and debug information for a
 /// local variable.  Does not emit initialization or destruction.
 CodeGenFunction::AutoVarEmission
 CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
   QualType Ty = D.getType();

clang/lib/Parse/ParsePragma.cpp

PragmaOptimizeHandler(Sema &S)
     : PragmaHandler("optimize"), Actions(S) {}
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &FirstToken) override;
 
 private:
   Sema &Actions;
 };
 
+/// PragmaExtendLifetimesHandler - "\#pragma clang extend_lifetimes
+/// enable/disable".
+struct PragmaExtendLifetimesHandler : public PragmaHandler {
+  PragmaExtendLifetimesHandler(Sema &S)
+      : PragmaHandler("extend_lifetimes"), Actions(S) {}
+  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
+                    Token &FirstToken) override;
+
+private:
+  Sema &Actions;
+};
+
 struct PragmaLoopHintHandler : public PragmaHandler {
   PragmaLoopHintHandler() : PragmaHandler("loop") {}
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &FirstToken) override;
 };
 
 struct PragmaUnrollHintHandler : public PragmaHandler {
   PragmaUnrollHintHandler(const char *name) : PragmaHandler(name) {}
if (getLangOpts().CUDA) {
     CUDAForceHostDeviceHandler =
         std::make_unique<PragmaForceCUDAHostDeviceHandler>(Actions);
     PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get());
   }
 
   OptimizeHandler = std::make_unique<PragmaOptimizeHandler>(Actions);
   PP.AddPragmaHandler("clang", OptimizeHandler.get());
 
+  ExtendLifetimesHandler =
+      std::make_unique<PragmaExtendLifetimesHandler>(Actions);
+  PP.AddPragmaHandler("clang", ExtendLifetimesHandler.get());
+
   LoopHintHandler = std::make_unique<PragmaLoopHintHandler>();
   PP.AddPragmaHandler("clang", LoopHintHandler.get());
 
   UnrollHintHandler = std::make_unique<PragmaUnrollHintHandler>("unroll");
   PP.AddPragmaHandler(UnrollHintHandler.get());
   PP.AddPragmaHandler("GCC", UnrollHintHandler.get());
 
   NoUnrollHintHandler = std::make_unique<PragmaUnrollHintHandler>("nounroll");
void Parser::resetPragmaHandlers() {
   STDCCXLIMITHandler.reset();
 
   PP.RemovePragmaHandler("STDC", STDCUnknownHandler.get());
   STDCUnknownHandler.reset();
 
   PP.RemovePragmaHandler("clang", OptimizeHandler.get());
   OptimizeHandler.reset();
 
+  PP.RemovePragmaHandler("clang", ExtendLifetimesHandler.get());
+  ExtendLifetimesHandler.reset();
+
   PP.RemovePragmaHandler("clang", LoopHintHandler.get());
   LoopHintHandler.reset();
 
   PP.RemovePragmaHandler(UnrollHintHandler.get());
   PP.RemovePragmaHandler("GCC", UnrollHintHandler.get());
   UnrollHintHandler.reset();
 
   PP.RemovePragmaHandler(NoUnrollHintHandler.get());
if (Tok.isNot(tok::eod)) {
     PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument)
       << PP.getSpelling(Tok);
     return;
   }
 
   Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation());
 }
 
+// #pragma clang extend_lifetimes disable
+// #pragma clang extend_lifetimes enable
+void PragmaExtendLifetimesHandler::HandlePragma(Preprocessor &PP,
+                                                PragmaIntroducer Introducer,
+                                                Token &FirstToken) {
+  Token Tok;
+  PP.Lex(Tok);
+  if (Tok.is(tok::eod)) {
+    PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument)
+        << "clang extend_lifetimes" << /*Expected=*/true
+        << "'enable' or 'disable'";
+    return;
+  }
+  if (Tok.isNot(tok::identifier)) {
+    PP.Diag(Tok.getLocation(),
+            diag::err_pragma_extend_lifetimes_invalid_argument)
+        << PP.getSpelling(Tok);
+    return;
+  }
+  const IdentifierInfo *II = Tok.getIdentifierInfo();
+  // The only accepted values are 'enable' or 'disable'.
+  bool IsEnabled = false;
+  if (II->isStr("enable")) {
+    IsEnabled = true;
+  } else if (!II->isStr("disable")) {
+    PP.Diag(Tok.getLocation(),
+            diag::err_pragma_extend_lifetimes_invalid_argument)
+        << PP.getSpelling(Tok);
+    return;
+  }
+  PP.Lex(Tok);
+
+  if (Tok.isNot(tok::eod)) {
+    PP.Diag(Tok.getLocation(), diag::err_pragma_extend_lifetimes_extra_argument)
+        << PP.getSpelling(Tok);
+    return;
+  }
+
+  Actions.ActOnPragmaExtendLifetimes(IsEnabled, FirstToken.getLocation());
+}
+
 namespace {
 /// Used as the annotation value for tok::annot_pragma_fp.
 struct TokFPAnnotValue {
   enum FlagKinds { Contract, Reassociate, Exceptions, EvalMethod };
   enum FlagValues { On, Off, Fast };
 
   std::optional<LangOptions::FPModeKind> ContractValue;
   std::optional<LangOptions::FPModeKind> ReassociateValue;

clang/lib/Sema/SemaAttr.cpp

 
 void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
   if(On)
     OptimizeOffPragmaLocation = SourceLocation();
   else
     OptimizeOffPragmaLocation = PragmaLoc;
 }
 
+void Sema::ActOnPragmaExtendLifetimes(bool Enable, SourceLocation PragmaLoc) {
+  if (Enable)
+    ExtendLifetimesDisablePragmaLocation = SourceLocation();
+  else
+    ExtendLifetimesDisablePragmaLocation = PragmaLoc;
+}
+
 void Sema::ActOnPragmaMSOptimize(SourceLocation Loc, bool IsOn) {
   if (!CurContext->getRedeclContext()->isFileContext()) {
     Diag(Loc, diag::err_pragma_expected_file_scope) << "optimize";
     return;
   }
 
   MSPragmaOptimizeIsOn = IsOn;
 }
void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD,
   // Add attributes only if required. Optnone requires noinline as well, but if
   // either is already present then don't bother adding them.
   if (!FD->hasAttr<OptimizeNoneAttr>())
     FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc));
   if (!FD->hasAttr<NoInlineAttr>())
     FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc));
 }
 
+void Sema::AddRangeBasedExtendLifetimesDisable(FunctionDecl *FD) {
+  if (ExtendLifetimesDisablePragmaLocation.isValid())
+    AddExtendLifetimesDisableAttribute(FD,
+                                       ExtendLifetimesDisablePragmaLocation);
+}
+
+void Sema::AddExtendLifetimesDisableAttribute(FunctionDecl *FD,
+                                              SourceLocation Loc) {
+  // Add the attribute only if it is not already present.
+  if (!FD->hasAttr<ExtendLifetimesDisableAttr>())
+    FD->addAttr(ExtendLifetimesDisableAttr::CreateImplicit(Context, Loc));
+}
+
 void Sema::AddImplicitMSFunctionNoBuiltinAttr(FunctionDecl *FD) {
   SmallVector<StringRef> V(MSFunctionNoBuiltins.begin(),
                            MSFunctionNoBuiltins.end());
   if (!MSFunctionNoBuiltins.empty())
     FD->addAttr(NoBuiltinAttr::CreateImplicit(Context, V.data(), V.size()));
 }
 
 typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack;

clang/lib/Sema/SemaDecl.cpp

Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   // attributes (i.e. optnone and no_builtin) due to a pragma.
   if (D.isFunctionDefinition()) {
     AddRangeBasedOptnone(NewFD);
     AddImplicitMSFunctionNoBuiltinAttr(NewFD);
     AddSectionMSAllocText(NewFD);
     ModifyFnAttributesMSPragmaOptimize(NewFD);
   }
 
+  // Check if we have to apply the extendlifetimes disable pragma.
+  if (D.isFunctionDefinition())
+    AddRangeBasedExtendLifetimesDisable(NewFD);
+
   // If this is the first declaration of an extern C variable, update
   // the map of such variables.
   if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
       isIncompleteDeclExternC(*this, NewFD))
     RegisterLocallyScopedExternCDecl(NewFD, S);
 
   // Set this FunctionDecl's range up to the right paren.
   NewFD->setRangeEnd(D.getSourceRange().getEnd());

clang/lib/Sema/SemaLambda.cpp

CompleteLambdaCallOperator(
       IsLambdaStatic ? SC_Static : SC_None, Params, ExplicitResultType);
 
   CheckCXXDefaultArguments(Method);
 
   // This represents the function body for the lambda function, check if we
   // have to apply optnone due to a pragma.
   AddRangeBasedOptnone(Method);
 
+  // Check if we have to apply the extend_lifetimes disable pragma.
+  AddRangeBasedExtendLifetimesDisable(Method);
+
   // code_seg attribute on lambda apply to the method.
   if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(
           Method, /*IsDefinition=*/true))
     Method->addAttr(A);
 
   // Attributes on the lambda apply to the method.
   ProcessDeclAttributes(CurScope, Method, ParamInfo);
 

clang/test/CodeGen/pragma-extend-lifetimes.cpp

+// RUN: %clang %s --target=%itanium_abi_triple -S -O2 -emit-llvm -o - \
+// RUN:   | FileCheck %s --check-prefix=NO-EXTENSION --implicit-check-not="call void (...) @llvm.fake.use"
+// Check that we do not generate fake_use instructions without -fextend-this-ptr
+// or -fextend-lifetimes, even with `#pragma clang extend_lifetimes enable`
+// declared.
+
+// RUN: %clang %s --target=%itanium_abi_triple -S -O2 -emit-llvm -fextend-this-ptr -o - \
+// RUN:   | FileCheck %s --implicit-check-not="call void (...) @llvm.fake.use"
+// Check that we generate a fake_use instruction for this 'this' ptr in foo()
+// and baz(), but not for bar().
+
+// RUN: %clang %s --target=%itanium_abi_triple -S -O2 -emit-llvm -fextend-lifetimes -o - \
+// RUN:   | FileCheck %s --check-prefixes CHECK,ALL --implicit-check-not="call void (...) @llvm.fake.use"
+// Check that we generate a fake_use instruction for all parameters (including
+// the 'this' ptr) in foo() and baz(), but not for bar().
+
+class A {
+  void foo(int i);
+  void bar(int i);
+  void bat(int i);
+  void baz(int i);
+  void goo(int i);
+  void moo(int i);
+  void zoo(int i);
+  void fie(int i);
+};
+
+// NO-EXTENSION: define{{.*}}foo
+void A::foo(int i) {
+  // CHECK-LABEL: define{{.*}}foo
+  // ALL:         call void (...) @llvm.fake.use(i32 %
+  // CHECK:       call void (...) @llvm.fake.use(ptr nonnull %
+}
+
+#pragma clang extend_lifetimes disable
+void A::bar(int i) {
+  // CHECK-LABEL: define{{.*}}bar
+  // CHECK:       ret
+}
+
+void A::bat(int i) {
+// Make sure that a disabling pragma spans multiple function definitions.
+  // CHECK-LABEL: define{{.*}}bat
+  // CHECK:       ret
+}
+
+#pragma clang extend_lifetimes enable
+void A::baz(int i) {
+  // CHECK-LABEL: define{{.*}}baz
+  // ALL:         call void (...) @llvm.fake.use(i32 %
+  // CHECK:       call void (...) @llvm.fake.use(ptr nonnull %
+}
+
+void A::goo(int i) {
+// Make sure that a disabling pragma has no effect on the current function
+// when it appears in the middle.
+#pragma clang extend_lifetimes disable
+  // CHECK-LABEL: define{{.*}}goo
+  // ALL:         call void (...) @llvm.fake.use(i32 %
+  // CHECK:       call void (...) @llvm.fake.use(ptr nonnull %
+}
+
+void A::moo(int i) {
+// Make sure
+// 1) that a disabling pragma that appeared in the middle of the previous
+// function affects the current function.
+// 2) that an enabling pragma that appears in the middle of the current
+// function does not affect the current function.
+#pragma clang extend_lifetimes enable
+  // CHECK-LABEL: define{{.*}}moo
+  // CHECK:       ret
+}
+
+void A::zoo(int i) {
+// Finally, make sure that an enabling pragma that appeared in the middle of
+// the previous function affects the current function.
+  // CHECK-LABEL: define{{.*}}zoo
+  // ALL:         call void (...) @llvm.fake.use(i32 %
+  // CHECK:       call void (...) @llvm.fake.use(ptr nonnull %
+}
+
+void __attribute__((nodebug)) A::fie(int i) {
+  int j = 0;
+// Make sure that the nodebug attribute prevents extend-lifetimes from
+// taking effect.
+  // CHECK-LABEL: define{{.*}}fie
+}