[lldb] Add setting to override PE/COFF ABI by module name

[alvinhochun]

Summary

The setting plugin.object-file.pe-coff.module-abi is a string-to-enum
map that allows specifying an ABI to a module name. For example:

ucrtbase.dll=msvc
libstdc++-6.dll=gnu

This allows for debugging a process which mixes both modules built using
the MSVC ABI and modules built using the MinGW ABI.

Depends on D127048

[mstorsjo]

(I guess this one might need some updates after D127048 is finalized?)

Edit: Doesn't seem so, there hadn't been any further updates to the preceding patch - sorry for the noise.

[alvinhochun]

Rebased patch

[alvinhochun]

Rebased

[DavidSpickett]

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFFProperties.td

13

What are the values accepted for this?

lldb/test/Shell/ObjectFile/PECOFF/settings-abi.yaml

37

You should test that UPPER_CASE and UPPER_CASE.debug still find the module abi.

I think you could test the priority order too.

Start with 1 setting foo=msvc, check it gets msvc.
Add the next highest priority Foo=gnu, check it gets gnu.
Remove foo=msvc, add the next highest priority as foo.debug=msvc, check it gets msvc.
Remove Foo=gnu and add Foo.debug=gnu, check it gets gnu.

At each stage you're proving that it'll choose one of a pair, put that all together you've proved the order overall.

[alvinhochun]

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFFProperties.td

13

It's the same enum as the setting plugin.object-file.pe-coff.abi added in D127048 - default, msvc and gnu.

[DavidSpickett]

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFFProperties.td

13

Which makes sense but the user isn't always going to see both descriptions so I'd repeat that information here.

[alvinhochun]

Added test and improved setting description as suggested.

[DavidSpickett]

LGTM

lldb/include/lldb/Interpreter/OptionValueDictionary.h

 //===-- OptionValueDictionary.h ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_INTERPRETER_OPTIONVALUEDICTIONARY_H
 #define LLDB_INTERPRETER_OPTIONVALUEDICTIONARY_H
 
 #include <map>
 
 #include "lldb/Interpreter/OptionValue.h"
+#include "lldb/lldb-private-types.h"
 
 namespace lldb_private {
 
 class OptionValueDictionary
     : public Cloneable<OptionValueDictionary, OptionValue> {
 public:
   OptionValueDictionary(uint32_t type_mask = UINT32_MAX,
+                        OptionEnumValues enum_values = OptionEnumValues(),
                         bool raw_value_dump = true)
-      : m_type_mask(type_mask), m_raw_value_dump(raw_value_dump) {}
+      : m_type_mask(type_mask), m_enum_values(enum_values),
+        m_raw_value_dump(raw_value_dump) {}
 
   ~OptionValueDictionary() override = default;
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeDictionary; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
public:
 
   size_t GetArgs(Args &args) const;
 
   Status SetArgs(const Args &args, VarSetOperationType op);
 
 protected:
   typedef std::map<ConstString, lldb::OptionValueSP> collection;
   uint32_t m_type_mask;
+  OptionEnumValues m_enum_values;
   collection m_values;
   bool m_raw_value_dump;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONVALUEDICTIONARY_H

lldb/source/Interpreter/OptionValueDictionary.cpp

 //===-- OptionValueDictionary.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueDictionary.h"
 
-#include "llvm/ADT/StringRef.h"
 #include "lldb/DataFormatters/FormatManager.h"
+#include "lldb/Interpreter/OptionValueEnumeration.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/State.h"
+#include "llvm/ADT/StringRef.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueDictionary::DumpValue(const ExecutionContext *exe_ctx,
                                       Stream &strm, uint32_t dump_mask) {
   const Type dict_type = ConvertTypeMaskToType(m_type_mask);
   if (dump_mask & eDumpOptionType) {
for (const auto &entry : args) {
         error.SetErrorStringWithFormat(
             "invalid key \"%s\", the key must be a bare string or "
             "surrounded by brackets with optional quotes: [<key>] or "
             "['<key>'] or [\"<key>\"]",
             key.str().c_str());
         return error;
       }
 
+      if (m_type_mask == 1u << eTypeEnum) {
+        auto enum_value =
+            std::make_shared<OptionValueEnumeration>(m_enum_values, 0);
+        error = enum_value->SetValueFromString(value);
+        if (error.Fail())
+          return error;
+        m_value_was_set = true;
+        SetValueForKey(ConstString(key), enum_value, true);
+      } else {
         lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask(
             value.str().c_str(), m_type_mask, error));
         if (value_sp) {
           if (error.Fail())
             return error;
           m_value_was_set = true;
           SetValueForKey(ConstString(key), value_sp, true);
         } else {
           error.SetErrorString("dictionaries that can contain multiple types "
                                "must subclass OptionValueArray");
         }
       }
+    }
     break;
 
   case eVarSetOperationRemove:
     if (argc > 0) {
       for (size_t i = 0; i < argc; ++i) {
         ConstString key(args.GetArgumentAtIndex(i));
         if (!DeleteValueForKey(key)) {
           error.SetErrorStringWithFormat(

lldb/source/Interpreter/Property.cpp

Property::Property(const PropertyDefinition &definition)
   case OptionValue::eTypeChar: {
     llvm::StringRef s(definition.default_cstr_value ? definition.default_cstr_value : "");
     m_value_sp = std::make_shared<OptionValueChar>(
         OptionArgParser::ToChar(s, '\0', nullptr));
     break;
   }
   case OptionValue::eTypeDictionary:
     // "definition.default_uint_value" is always a OptionValue::Type
-    m_value_sp =
-        std::make_shared<OptionValueDictionary>(OptionValue::ConvertTypeToMask(
-            (OptionValue::Type)definition.default_uint_value));
+    m_value_sp = std::make_shared<OptionValueDictionary>(
+        OptionValue::ConvertTypeToMask(
+            (OptionValue::Type)definition.default_uint_value),
+        definition.enum_values);
     break;
 
   case OptionValue::eTypeEnum:
     // "definition.default_uint_value" is the default enumeration value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default value.
     {

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

 #include "WindowsMiniDump.h"
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Interpreter/OptionValueDictionary.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/FileSpec.h"
PluginProperties() {
     m_collection_sp->Initialize(g_objectfilepecoff_properties);
   }
 
   llvm::Triple::EnvironmentType ABI() const {
     return (llvm::Triple::EnvironmentType)
         m_collection_sp->GetPropertyAtIndexAsEnumeration(
             nullptr, ePropertyABI, llvm::Triple::UnknownEnvironment);
   }
+
+  OptionValueDictionary *ModuleABIMap() const {
+    return m_collection_sp->GetPropertyAtIndexAsOptionValueDictionary(
+        nullptr, ePropertyModuleABIMap);
+  }
 };
 
 static PluginProperties &GetGlobalPluginProperties() {
   static PluginProperties g_settings;
   return g_settings;
 }
 
 } // namespace
static llvm::Triple::EnvironmentType default_env = [] {
     auto def_target = llvm::Triple(
         llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()));
     if (def_target.getOS() == llvm::Triple::Win32 &&
         def_target.getEnvironment() != llvm::Triple::UnknownEnvironment)
       return def_target.getEnvironment();
     return llvm::Triple::MSVC;
   }();
 
-  llvm::Triple::EnvironmentType env = GetGlobalPluginProperties().ABI();
+  // Check for a module-specific override.
+  OptionValueSP module_env_option;
+  const auto *map = GetGlobalPluginProperties().ModuleABIMap();
+  if (map->GetNumValues() > 0) {
+    // Step 1: Try with the exact file name.
+    auto name = file.GetLastPathComponent();
+    module_env_option = map->GetValueForKey(name);
+    if (!module_env_option) {
+      // Step 2: Try with the file name in lowercase.
+      auto name_lower = name.GetStringRef().lower();
+      module_env_option =
+          map->GetValueForKey(ConstString(llvm::StringRef(name_lower)));
+    }
+    if (!module_env_option) {
+      // Step 3: Try with the file name with ".debug" suffix stripped.
+      auto name_stripped = name.GetStringRef();
+      if (name_stripped.consume_back_insensitive(".debug")) {
+        module_env_option = map->GetValueForKey(ConstString(name_stripped));
+        if (!module_env_option) {
+          // Step 4: Try with the file name in lowercase with ".debug" suffix
+          // stripped.
+          auto name_lower = name_stripped.lower();
+          module_env_option =
+              map->GetValueForKey(ConstString(llvm::StringRef(name_lower)));
+        }
+      }
+    }
+  }
+  llvm::Triple::EnvironmentType env;
+  if (module_env_option)
+    env =
+        (llvm::Triple::EnvironmentType)module_env_option->GetEnumerationValue();
+  else
+    env = GetGlobalPluginProperties().ABI();
+
   if (env == llvm::Triple::UnknownEnvironment)
     env = default_env;
 
   switch (COFFObj->getMachine()) {
   case MachineAmd64:
     spec.SetTriple("x86_64-pc-windows");
     spec.GetTriple().setEnvironment(env);
     specs.Append(module_spec);

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFFProperties.td

 include "../../../../include/lldb/Core/PropertiesBase.td"
 
 let Definition = "objectfilepecoff" in {
   def ABI: Property<"abi", "Enum">,
     Global,
     DefaultEnumValue<"llvm::Triple::UnknownEnvironment">,
     EnumValues<"OptionEnumValues(g_abi_enums)">,
     Desc<"ABI to use when loading a PE/COFF module. This configures the C++ ABI used, which affects things like the handling of class layout. Accepted values are: `msvc` for the MSVC ABI, `gnu` for the MinGW / Itanium ABI, and `default` to follow the default target if it is a Windows triple or use the MSVC ABI by default.">;
+  def ModuleABIMap: Property<"module-abi", "Dictionary">,
+    Global,
+    ElementType<"Enum">,
+    EnumValues<"OptionEnumValues(g_abi_enums)">,
+    Desc<"A mapping of ABI override to use for specific modules. The module name is matched by its file name with extension. These versions are checked in sequence: exact, lowercase, exact with '.debug' suffix stripped, lowercase with '.debug' suffix stripped.">;
 }

lldb/test/Shell/ObjectFile/PECOFF/settings-abi.yaml

 # RUN: yaml2obj %s -o %t
+# RUN: yaml2obj %s -o %t.debug
 
 ## Default ABI is msvc:
 # RUN: %lldb -O "settings set plugin.object-file.pe-coff.abi msvc" \
 # RUN:   -f %t -o "image list --triple --basename" -o exit | \
 # RUN:   FileCheck -DABI=msvc -DFILENAME=%basename_t.tmp %s
 
 ## Default ABI is gnu:
 # RUN: %lldb -O "settings set plugin.object-file.pe-coff.abi gnu" \
 # RUN:   -f %t -o "image list --triple --basename" -o exit | \
 # RUN:   FileCheck -DABI=gnu -DFILENAME=%basename_t.tmp %s
 
+## Default ABI is msvc, module override is gnu:
+# RUN: %lldb -O "settings set plugin.object-file.pe-coff.abi msvc" \
+# RUN:   -O "settings append plugin.object-file.pe-coff.module-abi %basename_t.tmp=gnu" \
+# RUN:   -f %t -o "image list --triple --basename" -o exit | \
+# RUN:   FileCheck -DABI=gnu -DFILENAME=%basename_t.tmp %s
+
+## Default ABI is gnu, module override is msvc:
+# RUN: %lldb -O "settings set plugin.object-file.pe-coff.abi gnu" \
+# RUN:   -O "settings append plugin.object-file.pe-coff.module-abi %basename_t.tmp=msvc" \
+# RUN:   -f %t -o "image list --triple --basename" -o exit | \
+# RUN:   FileCheck -DABI=msvc -DFILENAME=%basename_t.tmp %s
+
+## Default ABI is msvc, module override is gnu (with .debug suffix):
+# RUN: %lldb -O "settings set plugin.object-file.pe-coff.abi msvc" \
+# RUN:   -O "settings append plugin.object-file.pe-coff.module-abi %basename_t.tmp=gnu" \
+# RUN:   -f %t.debug -o "image list --triple --basename" -o exit | \
+# RUN:   FileCheck -DABI=gnu -DFILENAME=%basename_t.tmp.debug %s
+
+## Default ABI is gnu, module override is msvc (with .debug suffix):
+# RUN: %lldb -O "settings set plugin.object-file.pe-coff.abi gnu" \
+# RUN:   -O "settings append plugin.object-file.pe-coff.module-abi %basename_t.tmp=msvc" \
+# RUN:   -f %t.debug -o "image list --triple --basename" -o exit | \
+# RUN:   FileCheck -DABI=msvc -DFILENAME=%basename_t.tmp.debug %s
+
 # CHECK-LABEL: image list --triple --basename
 # CHECK-NEXT: x86_64-pc-windows-[[ABI]] [[FILENAME]]
 
 --- !COFF
 OptionalHeader:
   AddressOfEntryPoint: 5152
   ImageBase:       5368709120
   SectionAlignment: 4096