[Assignment Tracking] Give -fexperimental-assignment-tracking flag 3 options

[Orlando]

Summary

Without this patch assignment tracking is enabled with -fexperimental-assignment-tracking and disabled with -fno-experimental-assignment-tracking (default). This patch removes the -fno- version and changes -fexperimental-assignment-tracking to take 3 values: enabled, disabled (default), and forced.

clang -Xclang -fexperimental-assignment-tracking=enabled enables the feature if some other conditions are met and =forced enables it without any further checks.

If enabled is specified the feature will remain disabled if any of the following are true: it's an LTO or ThinLTO build, optimisations are not enabled, or lldb debugger tuning has been specified. See this short RFC for more info.

[jryans]

clang/lib/CodeGen/BackendUtil.cpp

855

Do we know any details on the connection between assignment tracking and that LLDB issue...? The LLDB issue as written at the moment seems quite general and appears to pre-date assignment tracking...

Ah, I suppose it's this bit from your earlier RFC:

LLDB doesn’t appear to interpret variable locations made up of DW_OP_piece (generated in expressions using DW_OP_LLVM_fragment) correctly if parts of the variable have no location.

Hmm, I guess to me it feels like we're being a bit too conservative by disabling assignment tracking for this LLDB issue, but I'm not sure what LLDB people would say about it.

If we do proceed with disabling assignment tracking when LLDB tuning is used, it would be good to at least update the LLDB issue with more details about this and to highlight there's now an entire new analysis that's waiting on this issue to be fixed.

[Orlando]

clang/lib/CodeGen/BackendUtil.cpp

855

If we do proceed with disabling assignment tracking when LLDB tuning is used, it would be good to at least update the LLDB issue with more details about this and to highlight there's now an entire new analysis that's waiting on this issue to be fixed.

That sounds reasonable to me - I have pinged the issue with this information! Thanks for raising this point.

[jmorse]

I agree with @jryans analysis, otherwise LGTM, you might want to wait a bit for input from @probinson who enjoys looking at clang-switch tests.

clang/test/CodeGen/assignment-tracking/flag.cpp

59–63

NB: the "DISABLE" prefix should check for something, at least "-cc1", to ensure that empty inputs aren't vacuously accepted.

[probinson]

What @jmorse said.

clang/include/clang/Basic/CodeGenOptions.h

public:
   };
 
   enum FiniteLoopsKind {
     Language, // Not specified, use language standard.
     Always,   // All loops are assumed to be finite.
     Never,    // No loop is assumed to be finite.
   };
 
+  enum AssignmentTrackingOpts {
+    Disabled,
+    Enabled,
+    Forced,
+  };
+
   /// The code model to use (-mcmodel).
   std::string CodeModel;
 
   /// The filename with path we use for coverage data files. The runtime
   /// allows further manipulation with the GCOV_PREFIX and GCOV_PREFIX_STRIP
   /// environment variables.
   std::string CoverageDataFile;
 

clang/include/clang/Basic/CodeGenOptions.def

 VALUE_CODEGENOPT(StackAlignment    , 32, 0) ///< Overrides default stack
                                             ///< alignment, if not 0.
 VALUE_CODEGENOPT(StackProbeSize    , 32, 4096) ///< Overrides default stack
                                                ///< probe size, even if 0.
 VALUE_CODEGENOPT(WarnStackSize     , 32, UINT_MAX) ///< Set via -fwarn-stack-size.
 CODEGENOPT(NoStackArgProbe, 1, 0) ///< Set when -mno-stack-arg-probe is used
 CODEGENOPT(DebugStrictDwarf, 1, 1) ///< Whether or not to use strict DWARF info.
 
-CODEGENOPT(EnableAssignmentTracking, 1,0) ///< Enable the Assignment Tracking
-                                          ///< debug info feature.
+/// Control the Assignment Tracking debug info feature.
+ENUM_CODEGENOPT(AssignmentTrackingMode, AssignmentTrackingOpts, 2, AssignmentTrackingOpts::Disabled)
 
 CODEGENOPT(DebugColumnInfo, 1, 0) ///< Whether or not to use column information
                                   ///< in debug info.
 
 CODEGENOPT(DebugTypeExtRefs, 1, 0) ///< Whether or not debug info should contain
                                    ///< external references to a PCH or module.
 
 CODEGENOPT(DebugExplicitImport, 1, 0)  ///< Whether or not debug info should

clang/include/clang/Driver/Options.td

 def fdenormal_fp_math_f32_EQ : Joined<["-"], "fdenormal-fp-math-f32=">,
    Group<f_Group>;
 
 def fctor_dtor_return_this : Flag<["-"], "fctor-dtor-return-this">,
   HelpText<"Change the C++ ABI to returning `this` pointer from constructors "
            "and non-deleting destructors. (No effect on Microsoft ABI)">,
   MarshallingInfoFlag<CodeGenOpts<"CtorDtorReturnThis">>;
 
-defm experimental_assignment_tracking :
-  BoolOption<"f", "experimental-assignment-tracking",
-  CodeGenOpts<"EnableAssignmentTracking">, DefaultFalse,
-  PosFlag<SetTrue, [CC1Option]>, NegFlag<SetFalse>, BothFlags<[CoreOption]>>,
-  Group<f_Group>;
+def experimental_assignment_tracking_EQ : Joined<["-"], "fexperimental-assignment-tracking=">,
+  Group<f_Group>, CodeGenOpts<"EnableAssignmentTracking">,
+  NormalizedValuesScope<"CodeGenOptions::AssignmentTrackingOpts">,
+  Values<"disabled,enabled,forced">, NormalizedValues<["Disabled","Enabled","Forced"]>,
+  MarshallingInfoEnum<CodeGenOpts<"AssignmentTrackingMode">, "Disabled">;
 
 } // let Flags = [CC1Option, NoDriverOption]
 
 //===----------------------------------------------------------------------===//
 // Dependency Output Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, NoDriverOption] in {

clang/lib/CodeGen/BackendUtil.cpp

void EmitAssemblyHelper::RunOptimizationPipeline(
   PrintPassOpts.SkipAnalyses = DebugPassStructure;
   StandardInstrumentations SI(
       TheModule->getContext(),
       (CodeGenOpts.DebugPassManager || DebugPassStructure),
       /*VerifyEach*/ false, PrintPassOpts);
   SI.registerCallbacks(PIC, &MAM);
   PassBuilder PB(TM.get(), PTO, PGOOpt, &PIC);
 
-  if (CodeGenOpts.EnableAssignmentTracking) {
+  // Handle the assignment tracking feature options.
+  switch (CodeGenOpts.getAssignmentTrackingMode()) {
+  case CodeGenOptions::AssignmentTrackingOpts::Forced:
     PB.registerPipelineStartEPCallback(
         [&](ModulePassManager &MPM, OptimizationLevel Level) {
           MPM.addPass(AssignmentTrackingPass());
         });
+    break;
+  case CodeGenOptions::AssignmentTrackingOpts::Enabled:
+    // Disable assignment tracking in LTO builds for now as the performance
+    // cost is too high. Disable for LLDB tuning due to llvm.org/PR43126.
+    if (!CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.PrepareForLTO &&
+        CodeGenOpts.getDebuggerTuning() != llvm::DebuggerKind::LLDB) {
+      PB.registerPipelineStartEPCallback(
+          [&](ModulePassManager &MPM, OptimizationLevel Level) {
+            // Only use assignment tracking if optimisations are enabled.
+            if (Level != OptimizationLevel::O0)
+              MPM.addPass(AssignmentTrackingPass());
+          });
+    }
+    break;
+  case CodeGenOptions::AssignmentTrackingOpts::Disabled:
+    break;
   }
 
   // Enable verify-debuginfo-preserve-each for new PM.
   DebugifyEachInstrumentation Debugify;
   DebugInfoPerPass DebugInfoBeforePass;
   if (CodeGenOpts.EnableDIPreservationVerify) {
     Debugify.setDebugifyMode(DebugifyMode::OriginalDebugInfo);
     Debugify.setDebugInfoBeforePass(DebugInfoBeforePass);

clang/test/CodeGen/assignment-tracking/assignment-tracking.cpp

 // RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone -O0 \
-// RUN:     -emit-llvm  -fexperimental-assignment-tracking %s -o -               \
+// RUN:     -emit-llvm  -fexperimental-assignment-tracking=forced %s -o -        \
 // RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
 
 // Based on llvm/test/DebugInfo/Generic/track-assignments.ll - check that using
 // -Xclang -fexperimental-assignment-tracking results in emitting (or, as it is
 // set up currently, telling llvm to create) assignment tracking metadata.
 //
 // See the original test for more info.
 

clang/test/CodeGen/assignment-tracking/flag.cpp

 //// Explicitly enabled:
-// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone -O0 \
-// RUN:     -emit-llvm  -fexperimental-assignment-tracking %s -o -               \
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm  -fexperimental-assignment-tracking=enabled %s -o - -O1 \
 // RUN: | FileCheck %s --check-prefixes=ENABLE
+
+//// Explicitly disabled:
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm  %s -o - -fexperimental-assignment-tracking=disabled -O1\
+// RUN: | FileCheck %s --check-prefixes=DISABLE
+
 //// Disabled by default:
-// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone -O0 \
-// RUN:     -emit-llvm  %s -o -                                                  \
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm  %s -o - -O1                                            \
 // RUN: | FileCheck %s --check-prefixes=DISABLE
-//// Explicitly disabled:
-// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone -O0 \
-// RUN:     -emit-llvm  %s -o - -fno-experimental-assignment-tracking            \
+
+//// Disabled at O0 unless forced.
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm %s -o - -fexperimental-assignment-tracking=enabled      \
+// RUN:     -O0                                                                \
+// RUN: | FileCheck %s --check-prefixes=DISABLE
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm %s -o - -fexperimental-assignment-tracking=forced       \
+// RUN:     -O0                                                                \
+// RUN: | FileCheck %s --check-prefixes=ENABLE
+
+//// Disabled for LTO and thinLTO unless forced.
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm %s -o - -fexperimental-assignment-tracking=enabled      \
+// RUN:     -O1 -flto=full                                                     \
 // RUN: | FileCheck %s --check-prefixes=DISABLE
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm %s -o - -fexperimental-assignment-tracking=enabled      \
+// RUN:     -O1 -flto=thin                                                     \
+// RUN: | FileCheck %s --check-prefixes=DISABLE
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm %s -o - -fexperimental-assignment-tracking=forced       \
+// RUN:     -O1 -flto=full                                                     \
+// RUN: | FileCheck %s --check-prefixes=ENABLE
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm %s -o - -fexperimental-assignment-tracking=forced       \
+// RUN:     -O1 -flto=thin                                                     \
+// RUN: | FileCheck %s --check-prefixes=ENABLE
 
-// Check some assignment-tracking stuff appears in the output when the flag
-// -fexperimental-assignment-tracking is used, that it doesn't when
-// -fno-experimental-assignment-tracking is used or neither flag is specified.
+//// Disabled for LLDB debugger tuning unless forced.
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm %s -o - -fexperimental-assignment-tracking=enabled      \
+// RUN:     -O1 -debugger-tuning=lldb                                          \
+// RUN: | FileCheck %s --check-prefixes=DISABLE
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone   \
+// RUN:     -emit-llvm %s -o - -fexperimental-assignment-tracking=forced       \
+// RUN:     -O1 -debugger-tuning=lldb                                          \
+// RUN: | FileCheck %s --check-prefixes=ENABLE
 
-// ENABLE: DIAssignID
-// ENABLE: dbg.assign
+// Check the assignment-tracking module flag appears in the output when the
+// flag -fexperimental-assignment-tracking is set to 'enabled' (in some cases)
+// or 'forced' (always), and is does not appear when the flag is set to
+// 'disabled' (default).
 
-// DISABLE-NOT: DIAssignID
-// DISABLE-NOT: dbg.assign
+// ENABLE: "debug-info-assignment-tracking"
+// DISABLE-NOT: "debug-info-assignment-tracking"
+//// Check there's actually any output at all.
+// DISABLE: llvm.module.flags
 
 void fun(int a) {}

clang/test/CodeGen/assignment-tracking/memcpy-fragment.cpp

 // RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone -O0 \
-// RUN:     -emit-llvm  -fexperimental-assignment-tracking %s -o -               \
+// RUN:     -emit-llvm  -fexperimental-assignment-tracking=forced %s -o -        \
 // RUN: | FileCheck %s
 
 // Check that the (debug) codegen looks right with assignment tracking
 // enabled. Each fragment that is written to should have a dbg.assign that has
 // the DIAssignID of the write as an argument. The fragment offset and size
 // should match the offset into the base storage and size of the store. Each of
 // the scenarios below results in slightly different arguments generated for
 // the memcpy.

clang/test/CodeGen/assignment-tracking/nested-scope.cpp

 // RUN: %clang_cc1 -triple x86_64-none-linux-gnu -debug-info-kind=standalone -O0 \
-// RUN:     -emit-llvm  -fexperimental-assignment-tracking %s -o -               \
+// RUN:     -emit-llvm  -fexperimental-assignment-tracking=forced %s -o -        \
 // RUN: | FileCheck %s
 
 // Check that dbg.assign intrinsics get a !dbg with with the same scope as
 // their variable.
 
 // CHECK: call void @llvm.dbg.assign({{.+}}, metadata [[local:![0-9]+]], {{.+}}, {{.+}}, {{.+}}), !dbg [[dbg:![0-9]+]]
 // CHECK-DAG: [[local]] = !DILocalVariable(name: "local", scope: [[scope:![0-9]+]],
 // CHECK-DAG: [[dbg]] = !DILocation({{.+}}, scope: [[scope]])