[Assignment Tracking][2/*] Add flags to enable Assignment Tracking

[Orlando]

Summary

The Assignment Tracking debug-info feature is outlined in this RFC. This first series of patches adds documentation, the changes necessary to start emitting and using the new metadata, and updates clang with an option to enable the feature. Working with the new metadata in the middle and back end will come later. There are still a few rough edges but I'm putting these patches up now hoping to get feedback on the design and implementation from the upstream community.

---

Add flags to enable Assignment Tracking:

Enable in clang: -Xclang -fexperimental-assignment-tracking

Enable in llvm tools: -experimental-assignment-tracking

When assignment tracking is enabled in clang it will pass on the flag to enable the feature in lllvm. It's undefined behaviour to read IR that contains assignment tracking primitives without specifying the feature flags.

Tests will come with later patches that add assignment tracking features.

[Orlando]

+ Add context to diff

[jmorse]

I get the feeling that this is creating two places to store the flag rather than one -- there's the EnableAssignmentTracking flag which ends up in TargetOptions I think(?), I believe MarshallingInfoFlag<CodeGenOpts<"EnableAssignmentTracking">>; causes the Xclang flag to be stored there. Then there's the cl::opt flag which is controlled by the same. This raises the future possibility that one could be on, but the other off -- I suspect you'll need to pick one and stick with it.

NB: I've gone off putting things in TargetOptions after finding that they're hard to control (i.e.: impossible) during LTO:

https://lists.llvm.org/pipermail/llvm-dev/2020-December/147090.html

Because the arguments are parsed after TargetOptions is created.

clang/include/clang/Basic/CodeGenOptions.def

320

This wants a docu-comment, as in the surrounding flags.

[Orlando]

In D132221#3758381, @jmorse wrote:

I get the feeling that this is creating two places to store the flag rather than one -- there's the EnableAssignmentTracking flag which ends up in TargetOptions I think(?), I believe MarshallingInfoFlag<CodeGenOpts<"EnableAssignmentTracking">>; causes the Xclang flag to be stored there.

I thought that it was putting it in CodeGenOptions, meaning we can check the value of the flag here in Clang - used in D132226 (the if condition).

I'm not trying to push back on any suggested changes, I am just slightly lost on this side of LLVM. It could well be that storing in CodeGenOptions is undesirable too, but I thought it was worth checking.

[jmorse]

In D132221#3777166, @Orlando wrote:

In D132221#3758381, @jmorse wrote:

I get the feeling that this is creating two places to store the flag rather than one -- there's the EnableAssignmentTracking flag which ends up in TargetOptions I think(?), I believe MarshallingInfoFlag<CodeGenOpts<"EnableAssignmentTracking">>; causes the Xclang flag to be stored there.

I thought that it was putting it in CodeGenOptions, meaning we can check the value of the flag here in Clang - used in D132226 (the if condition).

Uuuuuuuhhhh. Yeah you're right, that makes sense. Carry on. LGTM, wants the comment nit fixing though.

I'm not trying to push back on any suggested changes, I am just slightly lost on this side of LLVM. It could well be that storing in CodeGenOptions is undesirable too, but I thought it was worth checking.

clang/include/clang/Basic/CodeGenOptions.def

VALUE_CODEGENOPT(LoopAlignment     , 32, 0) ///< Overrides default loop
                                             ///< alignment, if not 0.
 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)
+
 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
                                        ///< contain explicit imports for

clang/include/clang/Driver/Options.td

def cfguard : Flag<["-"], "cfguard">,
     MarshallingInfoFlag<CodeGenOpts<"ControlFlowGuard">>;
 def ehcontguard : Flag<["-"], "ehcontguard">,
     HelpText<"Emit Windows EH Continuation Guard tables">,
     MarshallingInfoFlag<CodeGenOpts<"EHContGuard">>;
 
 def fdenormal_fp_math_f32_EQ : Joined<["-"], "fdenormal-fp-math-f32=">,
    Group<f_Group>;
 
+def fexperimental_assignment_tracking :
+  Flag<["-"], "fexperimental-assignment-tracking">, Group<f_Group>,
+  HelpText<"Enable assignment tracking debug info">,
+  MarshallingInfoFlag<CodeGenOpts<"EnableAssignmentTracking">>;
+
 //===----------------------------------------------------------------------===//
 // Dependency Output Options
 //===----------------------------------------------------------------------===//
 
 def sys_header_deps : Flag<["-"], "sys-header-deps">,
   HelpText<"Include system headers in dependency output">,
   MarshallingInfoFlag<DependencyOutputOpts<"IncludeSystemHeaders">>;
 def module_file_deps : Flag<["-"], "module-file-deps">,

clang/lib/Driver/ToolChains/Clang.cpp

 
   // Setup statistics file output.
   SmallString<128> StatsFile = getStatsFileName(Args, Output, Input, D);
   if (!StatsFile.empty())
     CmdArgs.push_back(Args.MakeArgString(Twine("-stats-file=") + StatsFile));
 
   // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
   // parser.
+  for (auto Arg : Args.filtered(options::OPT_Xclang)) {
+    Arg->claim();
     // -finclude-default-header flag is for preprocessor,
     // do not pass it to other cc1 commands when save-temps is enabled
     if (C.getDriver().isSaveTempsEnabled() &&
         !isa<PreprocessJobAction>(JA)) {
-    for (auto Arg : Args.filtered(options::OPT_Xclang)) {
-      Arg->claim();
-      if (StringRef(Arg->getValue()) != "-finclude-default-header")
-        CmdArgs.push_back(Arg->getValue());
+      if (StringRef(Arg->getValue()) == "-finclude-default-header")
+        continue;
     }
+    if (StringRef(Arg->getValue()) == "-fexperimental-assignment-tracking") {
+      // Add the llvm version of this flag too.
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back("-experimental-assignment-tracking");
     }
-  else {
-    Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
+    CmdArgs.push_back(Arg->getValue());
   }
   for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
     A->claim();
 
     // We translate this by hand to the -cc1 argument, since nightly test uses
     // it and developers have been trained to spell it with -mllvm. Both
     // spellings are now deprecated and should be removed.
     if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") {

llvm/include/llvm/IR/DebugInfo.h

private:
   SmallVector<DICompileUnit *, 8> CUs;
   SmallVector<DISubprogram *, 8> SPs;
   SmallVector<DIGlobalVariableExpression *, 8> GVs;
   SmallVector<DIType *, 8> TYs;
   SmallVector<DIScope *, 8> Scopes;
   SmallPtrSet<const MDNode *, 32> NodesSeen;
 };
 
+/// Return true if assignment tracking is enabled.
+bool getEnableAssignmentTracking();
 } // end namespace llvm
 
 #endif // LLVM_IR_DEBUGINFO_H

llvm/lib/IR/DebugInfo.cpp

 #include "llvm/Support/Casting.h"
 #include <algorithm>
 #include <cassert>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::dwarf;
 
+static cl::opt<bool>
+    ExperimentalAssignmentTracking("experimental-assignment-tracking",
+                                   cl::init(false));
+bool llvm::getEnableAssignmentTracking() {
+  return ExperimentalAssignmentTracking;
+}
+
 /// Finds all intrinsics declaring local variables as living in the memory that
 /// 'V' points to. This may include a mix of dbg.declare and
 /// dbg.addr intrinsics.
 TinyPtrVector<DbgVariableIntrinsic *> llvm::FindDbgAddrUses(Value *V) {
   // This function is hot. Check whether the value has any metadata to avoid a
   // DenseMap lookup.
   if (!V->isUsedByMetadata())
     return {};