[lldb] Implement SymbolFile::GetCompileOptions

[augusto2112]

Summary

Implement SymbolFile::GetCompileOptions, which returns a map from
compilation units to compilation arguments associated with that unit.

[JDevlieghere]

At a higher level I wonder if this is really the best interface. If you ever need all the compile options, you probably want something like Args SymbolFile::GetCompileOptions(). Wouldn't that be a more generic way to do the same thing here? Or do we expect that for DW_AT_APPLE_flags the only possible use case is to check whether a particular flag is set?

lldb/include/lldb/Symbol/SymbolFile.h

441

Please use StringRefs instead of raw char pointers.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

4271

It's not obvious from the function name what GetArgumentArrayRef is going to return. Looking at the header, it's apparently a llvm::ArrayRef<const char *>, so auto& is a reference to a pointer?

4282–4285

[JDevlieghere]

(adding myself as a reviewer so this shows up in my review queue)

[augusto2112]

In D147748#4251543, @JDevlieghere wrote:

At a higher level I wonder if this is really the best interface. If you ever need all the compile options, you probably want something like Args SymbolFile::GetCompileOptions(). Wouldn't that be a more generic way to do the same thing here? Or do we expect that for DW_AT_APPLE_flags the only possible use case is to check whether a particular flag is set?

I agree. I implemented it in such a a way to mirror the GetCompileOption function (which apparently doesn't exist upstream anymore). I'll update it to return the Args instead.

[augusto2112]

Changed implementation to GetCompileOptions

[JDevlieghere]

LGTM with or without the DenseMap, whichever makes the most sense.

lldb/include/lldb/Symbol/SymbolFile.h

441

Any reason you picked unordered_map? Not that I expected this code to be particularly hot, but I would've gone for an llvm::DenseMap which should offer much better performance characteristics.

[augusto2112]

lldb/include/lldb/Symbol/SymbolFile.h

441

Mainly because there's no implementation of shared pointer as keys for dense maps (DenseMapInfo<T> where the T is a shared_ptr) at the moment, and I don't expect this to be super hot.

lldb/include/lldb/Symbol/SymbolFile.h

 #include "lldb/Utility/XcodeSDK.h"
 #include "lldb/lldb-private.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/Errc.h"
 
 #include <mutex>
 #include <optional>
+#include <unordered_map>
 
 #if defined(LLDB_CONFIGURATION_DEBUG)
 #define ASSERT_MODULE_LOCK(expr) (expr->AssertModuleLock())
 #else
 #define ASSERT_MODULE_LOCK(expr) ((void)0)
 #endif
 
 namespace lldb_private {
MakeType(lldb::user_id_t uid, ConstString name,
            lldb::user_id_t encoding_uid,
            Type::EncodingDataType encoding_uid_type, const Declaration &decl,
            const CompilerType &compiler_qual_type,
            Type::ResolveState compiler_type_resolve_state,
            uint32_t opaque_payload = 0) = 0;
 
   virtual lldb::TypeSP CopyType(const lldb::TypeSP &other_type) = 0;
 
+  /// Returns a map of compilation unit to the compile option arguments
+  /// associated with that compilation unit.
+  std::unordered_map<lldb::CompUnitSP, Args> GetCompileOptions() {
+    std::unordered_map<lldb::CompUnitSP, Args> args;
+    GetCompileOptions(args);
+    return args;
+  }
+
 protected:
   void AssertModuleLock();
 
+  virtual void GetCompileOptions(
+      std::unordered_map<lldb::CompUnitSP, lldb_private::Args> &args) {}
+
 private:
   SymbolFile(const SymbolFile &) = delete;
   const SymbolFile &operator=(const SymbolFile &) = delete;
 };
 
 /// Containing protected virtual methods for child classes to override.
 /// Most actual SymbolFile implementations should inherit from this class.
 class SymbolFileCommon : public SymbolFile {

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

protected:
 
   const lldb_private::FileSpecList &GetTypeUnitSupportFiles(DWARFTypeUnit &tu);
 
   void InitializeFirstCodeAddressRecursive(
       const lldb_private::SectionList &section_list);
 
   void InitializeFirstCodeAddress();
 
+  void GetCompileOptions(
+      std::unordered_map<lldb::CompUnitSP, lldb_private::Args> &args) override;
+
   lldb::ModuleWP m_debug_map_module_wp;
   SymbolFileDWARFDebugMap *m_debug_map_symfile;
 
   llvm::once_flag m_dwp_symfile_once_flag;
   std::shared_ptr<SymbolFileDWARFDwo> m_dwp_symfile;
 
   lldb_private::DWARFContext m_context;
 

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Status SymbolFileDWARF::CalculateFrameVariableError(StackFrame &frame) {
   // Check if this compile unit has any variable DIEs. If it doesn't then there
   // is not variable information for the entire compile unit.
   if (dwarf_cu->HasAny({DW_TAG_variable, DW_TAG_formal_parameter}))
     return Status();
 
   return Status("no variable information is available in debug info for this "
                 "compile unit");
 }
+
+void SymbolFileDWARF::GetCompileOptions(
+    std::unordered_map<lldb::CompUnitSP, lldb_private::Args> &args) {
+
+  const uint32_t num_compile_units = GetNumCompileUnits();
+
+  for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
+    lldb::CompUnitSP comp_unit = GetCompileUnitAtIndex(cu_idx);
+    if (!comp_unit)
+      continue;
+
+    DWARFUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit.get());
+    if (!dwarf_cu)
+      continue;
+
+    const DWARFBaseDIE die = dwarf_cu->GetUnitDIEOnly();
+    if (!die)
+      continue;
+
+    const char *flags = die.GetAttributeValueAsString(DW_AT_APPLE_flags, NULL);
+
+    if (!flags)
+      continue;
+    args.insert({comp_unit, Args(flags)});
+  }
+}
+

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
   void DumpClangAST(lldb_private::Stream &s) override;
 
   // PluginInterface protocol
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
   // Statistics overrides.
   lldb_private::ModuleList GetDebugInfoModules() override;
 
+  void GetCompileOptions(
+      std::unordered_map<lldb::CompUnitSP, lldb_private::Args> &args) override;
+
 protected:
   enum { kHaveInitializedOSOs = (1 << 0), kNumFlags };
 
   friend class DebugMapModule;
   friend class DWARFASTParserClang;
   friend class DWARFCompileUnit;
   friend class SymbolFileDWARF;
   struct OSOInfo {

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (symtab) {
                             comp_unit_info->oso_path.GetCString());
           }
         }
       }
     }
   }
   return Status();
 }
+
+void SymbolFileDWARFDebugMap::GetCompileOptions(
+    std::unordered_map<lldb::CompUnitSP, lldb_private::Args> &args) {
+
+  ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
+    oso_dwarf->GetCompileOptions(args);
+    return false;
+  });
+}