Initial import of code to amd-debug (llvm#1432)

Author: slinder1

clang/include/clang/Basic/CodeGenOptions.h

@@ -164,6 +164,14 @@ class CodeGenOptions : public CodeGenOptionsBase {
     Never,    // No loop is assumed to be finite.
   };
 
+  enum class HeterogeneousDwarfOpts {
+    Disabled,     //< Do not emit any heterogeneous dwarf metadata.
+    DIExpression, //< Enable DIExpression-based metadata.
+  };
+  bool isHeterogeneousDwarfEnabled() const {
+    return getHeterogeneousDwarfMode() != HeterogeneousDwarfOpts::Disabled;
+  }
+
   enum AssignmentTrackingOpts {
     Disabled,
     Enabled,

clang/include/clang/Basic/DebugOptions.def

@@ -71,6 +71,10 @@ DEBUGOPT(DebugStrictDwarf, 1, 1) ///< Whether or not to use strict DWARF info.
 DEBUGOPT(DebugOmitUnreferencedMethods, 1, 0) ///< Omit unreferenced member
 					     ///< functions in type debug info.
 
+/// Control DWARF extensions for heterogeneous debugging enablement and approach.
+BENIGN_ENUM_DEBUGOPT(HeterogeneousDwarfMode, HeterogeneousDwarfOpts, 2,
+                     HeterogeneousDwarfOpts::Disabled)
+
 /// Control the Assignment Tracking debug info feature.
 BENIGN_ENUM_DEBUGOPT(AssignmentTrackingMode, AssignmentTrackingOpts, 2,
                      AssignmentTrackingOpts::Disabled)

clang/include/clang/Driver/Options.td

@@ -4494,6 +4494,23 @@ def gdwarf32 : Flag<["-"], "gdwarf32">, Group<g_Group>,
   Visibility<[ClangOption, CC1Option, CC1AsOption]>,
   HelpText<"Enables DWARF32 format for ELF binaries, if debug information emission is enabled.">;
 
+def gheterogeneous_dwarf_EQ : Joined<["-"], "gheterogeneous-dwarf=">,
+  Group<g_Group>, Visibility<[ClangOption, CC1Option]>,
+  HelpText<"Control DWARF extensions for heterogeneous debugging">,
+  Values<"disabled,diexpression">,
+  NormalizedValuesScope<"CodeGenOptions::HeterogeneousDwarfOpts">,
+  NormalizedValues<["Disabled","DIExpression"]>,
+  MarshallingInfoEnum<CodeGenOpts<"HeterogeneousDwarfMode">, "Disabled">;
+def gheterogeneous_dwarf : Flag<["-"], "gheterogeneous-dwarf">, Group<g_Group>,
+  Visibility<[ClangOption, CC1Option]>,
+  HelpText<"Enable DIExpression-based DWARF extensions for heterogeneous debugging">,
+  Alias<gheterogeneous_dwarf_EQ>, AliasArgs<["diexpression"]>;
+def gno_heterogeneous_dwarf : Flag<["-"], "gno-heterogeneous-dwarf">,
+  Visibility<[ClangOption, CC1Option]>,
+  Group<g_Group>,
+  HelpText<"Disable DWARF extensions for heterogeneous debugging">,
+  Alias<gheterogeneous_dwarf_EQ>, AliasArgs<["disabled"]>;
+
 def gcodeview : Flag<["-"], "gcodeview">,
   HelpText<"Generate CodeView debug information">,
   Visibility<[ClangOption, CC1Option, CC1AsOption, CLOption, DXCOption]>,

clang/lib/CodeGen/CGDebugInfo.cpp

@@ -539,9 +539,17 @@ class CGDebugInfo {
   /// Emit information about a global variable.
   void EmitGlobalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl);
 
+  /// Emit information about a global variable (-gheterogeneous-dwarf).
+  void EmitGlobalVariableForHeterogeneousDwarf(llvm::GlobalVariable *GV,
+                                               const VarDecl *Decl);
+
   /// Emit a constant global variable's debug info.
   void EmitGlobalVariable(const ValueDecl *VD, const APValue &Init);
 
+  /// Emit a constant global variable's debug info (-gheterogeneous-dwarf).
+  void EmitGlobalVariableForHeterogeneousDwarf(const ValueDecl *VD,
+                                               const APValue &Init);
+
   /// Emit information about an external variable.
   void EmitExternalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl);
 
@@ -645,6 +653,20 @@ class CGDebugInfo {
                                      CGBuilderTy &Builder,
                                      const bool UsePointerValue = false);
 
+  /// Emit call to llvm.dbg.declare for a variable definition.
+  /// Returns a pointer to the DILocalVariable associated with the
+  /// llvm.dbg.def, or nullptr otherwise.
+  llvm::DILocalVariable *EmitDeclareForHeterogeneousDwarf(
+      const VarDecl *decl, llvm::Value *AI, std::optional<unsigned> ArgNo,
+      CGBuilderTy &Builder, const bool UsePointerValue = false);
+
+  /// Emit call to llvm.dbg.declare for a structured binding definition.
+  /// Returns a pointer to the DILocalVariable associated with the
+  /// llvm.dbg.def, or nullptr otherwise.
+  llvm::DILocalVariable *EmitDeclareForHeterogeneousDwarf(
+      const BindingDecl *decl, llvm::Value *AI, std::optional<unsigned> ArgNo,
+      CGBuilderTy &Builder, const bool UsePointerValue = false);
+
   /// Emit call to llvm.dbg.declare for a binding declaration.
   /// Returns a pointer to the DILocalVariable associated with the
   /// llvm.dbg.declare, or nullptr otherwise.
@@ -653,6 +675,8 @@ class CGDebugInfo {
                                      CGBuilderTy &Builder,
                                      const bool UsePointerValue = false);
 
+  // FIXME: EmitDef(const BindingDecl *...
+
   struct BlockByRefType {
     /// The wrapper struct used inside the __block_literal struct.
     llvm::DIType *BlockByRefWrapper;
@@ -776,8 +800,20 @@ class CGDebugInfo {
   llvm::DIGlobalVariableExpression *
   CollectAnonRecordDecls(const RecordDecl *RD, llvm::DIFile *Unit,
                          unsigned LineNo, StringRef LinkageName,
-                         llvm::GlobalVariable *Var, llvm::DIScope *DContext);
+                         llvm::dwarf::MemorySpace MS, llvm::GlobalVariable *Var,
+                         llvm::DIScope *DContext);
 
+  /// Return a global variable that represents one of the collection of global
+  /// variables created for an anonmyous union (-gheterogeneous-dwarf).
+  ///
+  /// Recursively collect all of the member fields of a global
+  /// anonymous decl and create static variables for them. The first
+  /// time this is called it needs to be on a union and then from
+  /// there we can have additional unnamed fields.
+  llvm::DIGlobalVariableExpression *CollectAnonRecordDeclsForHeterogeneousDwarf(
+      const RecordDecl *RD, llvm::DIFile *Unit, unsigned LineNo,
+      StringRef LinkageName, llvm::dwarf::MemorySpace MS,
+      llvm::GlobalVariable *Var, llvm::DIScope *DContext);
 
   /// Return flags which enable debug info emission for call sites, provided
   /// that it is supported and enabled.

clang/lib/CodeGen/CGDebugInfo.h

@@ -4920,6 +4920,35 @@ renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
   renderDwarfFormat(D, T, Args, CmdArgs, EffectiveDWARFVersion);
   RenderDebugInfoCompressionArgs(Args, CmdArgs, D, TC);
 
+  bool EmitDwarfForAMDGCN = EmitDwarf && T.isAMDGCN();
+  if (EmitDwarfForAMDGCN)
+    CmdArgs.append({"-mllvm", "-amdgpu-spill-cfi-saved-regs"});
+  if (Arg *A = Args.getLastArg(options::OPT_gheterogeneous_dwarf_EQ)) {
+    A->render(Args, CmdArgs);
+  } else if (EmitDwarfForAMDGCN) {
+#ifndef NDEBUG
+    // There doesn't seem to be a straightforward way to "render" an option
+    // acquired from the OptTable into a string we can append to CmdArgs.
+    // All of the logic is buried in "accept" which works directly in terms
+    // of an ArgList.
+    //
+    // Instead, assert that the static string we are adding to CmdArgs has
+    // the same shape as what a bare -gheterogeneous-dwarf would alias to
+    // if the user has provided it in ArgList.
+    const Option GHeterogeneousDwarf =
+        getDriverOptTable().getOption(options::OPT_gheterogeneous_dwarf);
+    const Option Aliased = GHeterogeneousDwarf.getAlias();
+    assert(Aliased.isValid() && "gheterogeneous-dwarf must be an alias");
+    assert(Aliased.getName() == "gheterogeneous-dwarf=" &&
+           "gheterogeneous-dwarf must alias gheterogeneous-dwarf=");
+    assert(StringRef(GHeterogeneousDwarf.getAliasArgs()) == "diexpression" &&
+           GHeterogeneousDwarf.getAliasArgs()[strlen("diexpression") + 1] ==
+               '\0' &&
+           "gheterogeneous-dwarf must alias gheterogeneous-dwarf=diexpression");
+#endif
+    CmdArgs.push_back("-gheterogeneous-dwarf=diexpression");
+  }
+
   // This controls whether or not we perform JustMyCode instrumentation.
   if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false)) {
     if (TC.getTriple().isOSBinFormatELF() ||