Replace pointer to C-array of PropertyDefinition with llvm::ArrayRef

[tatyana-krasnukha]

Summary

As a follow-up to D49017.

[clayborg]

Good stuff!

[zturner]

It would be nice if You could replace the logic that iterates these arrays.
We no longer need to terminate on a sentinel nullptr entry and can now use
range based for loop

[tatyana-krasnukha]

Hmm... There is no such logic left, isn't it?
If you mean iterating OptionValueProperties::m_properties vector, I can replace cycles with range based for loop, but this doesn't seem to be related to these changes.

[zturner]

You might be right, I’m on mobile so hard for me to review. I saw a bunch
of nullptr so assumed it was still using sentinel values for iterating. If
not, ignore my suggestion

[tatyana-krasnukha]

It seems you are speaking about OptionDefinition, not PropertyDefinition. I was going to create a separate revision for it. Should I add OptionDefinition-related changes here?

[zturner]

No, separate revision is fine. Thanks!

include/lldb/Interpreter/OptionValueProperties.h

virtual Status DumpPropertyValue(const ExecutionContext *exe_ctx,
                                    uint32_t dump_mask);
 
   virtual void DumpAllDescriptions(CommandInterpreter &interpreter,
                                    Stream &strm) const;
 
   void Apropos(llvm::StringRef keyword,
                std::vector<const Property *> &matching_properties) const;
 
-  void Initialize(const PropertyDefinition *setting_definitions);
+  void Initialize(const PropertyDefinitions &setting_definitions);
 
   //    bool
   //    GetQualifiedName (Stream &strm);
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 

include/lldb/Interpreter/Property.h

struct PropertyDefinition {
   OptionValue::Type type;
   bool global; // false == this setting is a global setting by default
   uintptr_t default_uint_value;
   const char *default_cstr_value;
   OptionEnumValues enum_values;
   const char *description;
 };
 
+using PropertyDefinitions = llvm::ArrayRef<PropertyDefinition>;
+
 class Property {
 public:
   Property(const PropertyDefinition &definition);
 
   Property(const ConstString &name, const ConstString &desc, bool is_global,
            const lldb::OptionValueSP &value_sp);
 
   llvm::StringRef GetName() const { return m_name.GetStringRef(); }

source/Core/Debugger.cpp

static constexpr PropertyDefinition g_properties[] = {
      "(default: 4)."},
     {"escape-non-printables", OptionValue::eTypeBoolean, true, true, nullptr,
      {},
      "If true, LLDB will automatically escape non-printable and "
      "escape characters when formatting strings."},
     {"frame-format-unique", OptionValue::eTypeFormatEntity, true, 0,
      DEFAULT_FRAME_FORMAT_NO_ARGS, {},
      "The default frame format string to use when displaying stack frame"
-     "information for threads from thread backtrace unique."},
-    {nullptr, OptionValue::eTypeInvalid, true, 0, nullptr, {}, nullptr}};
+     "information for threads from thread backtrace unique."}};
 
 enum {
   ePropertyAutoConfirm = 0,
   ePropertyDisassemblyFormat,
   ePropertyFrameFormat,
   ePropertyNotiftVoid,
   ePropertyPrompt,
   ePropertyScriptLanguage,

source/Core/ModuleList.cpp

 static constexpr PropertyDefinition g_properties[] = {
     {"enable-external-lookup", OptionValue::eTypeBoolean, true, true, nullptr,
      {},
      "Control the use of external tools or libraries to locate symbol files. "
      "On macOS, Spotlight is used to locate a matching .dSYM bundle based on "
      "the UUID of the executable."},
     {"clang-modules-cache-path", OptionValue::eTypeFileSpec, true, 0, nullptr,
      {},
-     "The path to the clang modules cache directory (-fmodules-cache-path)."},
-    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, {}, nullptr}};
+     "The path to the clang modules cache directory (-fmodules-cache-path)."}};
 
 enum { ePropertyEnableExternalLookup, ePropertyClangModulesCachePath };
 
 } // namespace
 
 ModuleListProperties::ModuleListProperties() {
   m_collection_sp.reset(new OptionValueProperties(ConstString("symbols")));
   m_collection_sp->Initialize(g_properties);

source/Interpreter/CommandInterpreter.cpp

static constexpr PropertyDefinition g_properties[] = {
     {"prompt-on-quit", OptionValue::eTypeBoolean, true, true, nullptr, {},
      "If true, LLDB will prompt you before quitting if there are any live "
      "processes being debugged. If false, LLDB will quit without asking in any "
      "case."},
     {"stop-command-source-on-error", OptionValue::eTypeBoolean, true, true,
      nullptr, {}, "If true, LLDB will stop running a 'command source' "
                   "script upon encountering an error."},
     {"space-repl-prompts", OptionValue::eTypeBoolean, true, false, nullptr, {},
-     "If true, blank lines will be printed between between REPL submissions."},
-    {nullptr, OptionValue::eTypeInvalid, true, 0, nullptr, {}, nullptr}};
+     "If true, blank lines will be printed between between REPL submissions."}};
 
 enum {
   ePropertyExpandRegexAliases = 0,
   ePropertyPromptOnQuit = 1,
   ePropertyStopCmdSourceOnError = 2,
   eSpaceReplPrompts = 3
 };
 

source/Interpreter/OptionValueProperties.cpp

for (size_t i = 0; i < num_properties; ++i) {
     }
   }
 }
 
 size_t OptionValueProperties::GetNumProperties() const {
   return m_properties.size();
 }
 
-void OptionValueProperties::Initialize(const PropertyDefinition *defs) {
-  for (size_t i = 0; defs[i].name; ++i) {
-    Property property(defs[i]);
+void OptionValueProperties::Initialize(const PropertyDefinitions &defs) {
+  for (const auto &definition : defs) {
+    Property property(definition);
     assert(property.IsValid());
     m_name_to_index.Append(ConstString(property.GetName()), m_properties.size());
     property.GetValue()->SetParent(shared_from_this());
     m_properties.push_back(property);
   }
   m_name_to_index.Sort();
 }
 

source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

static constexpr OptionEnumValueElement g_kaslr_kernel_scan_enum_values[] = {
      "on 32-bit targets)."}};
 
 static constexpr PropertyDefinition g_properties[] = {
     {"load-kexts", OptionValue::eTypeBoolean, true, true, NULL, {},
      "Automatically loads kext images when attaching to a kernel."},
     {"scan-type", OptionValue::eTypeEnum, true, eKASLRScanNearPC, NULL,
      OptionEnumValues(g_kaslr_kernel_scan_enum_values),
      "Control how many reads lldb will make while searching for a Darwin "
-     "kernel on attach."},
-    {NULL, OptionValue::eTypeInvalid, false, 0, NULL, {}, NULL} };
+     "kernel on attach."}};
 
 enum { ePropertyLoadKexts, ePropertyScanType };
 
 class DynamicLoaderDarwinKernelProperties : public Properties {
 public:
   static ConstString &GetSettingName() {
     static ConstString g_setting_name("darwin-kernel");
     return g_setting_name;

source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

template <typename ptr_t> struct jit_descriptor {
   ptr_t relevant_entry; // pointer
   ptr_t first_entry;    // pointer
 };
 
 namespace {
 
 static constexpr PropertyDefinition g_properties[] = {
     {"enable-jit-breakpoint", OptionValue::eTypeBoolean, true, true, nullptr,
-     {}, "Enable breakpoint on __jit_debug_register_code."},
-    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, {}, nullptr}};
+     {}, "Enable breakpoint on __jit_debug_register_code."}};
 
 enum { ePropertyEnableJITBreakpoint };
 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return JITLoaderGDB::GetPluginNameStatic();
   }

source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 
 static constexpr PropertyDefinition g_properties[] = {
     {"enable", OptionValue::eTypeBoolean, true, true, nullptr, {},
-     "Specify whether goroutines should be treated as threads."},
-    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, {}, nullptr}};
+     "Specify whether goroutines should be treated as threads."}};
 
 enum {
   ePropertyEnableGoroutines,
 };
 
 class PluginProperties : public Properties {
 public:
   PluginProperties() : Properties() {

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

 const char *PlatformDarwinKernel::GetDescriptionStatic() {
   return "Darwin Kernel platform plug-in.";
 }
 
 //------------------------------------------------------------------
 /// Code to handle the PlatformDarwinKernel settings
 //------------------------------------------------------------------
 
-static PropertyDefinition g_properties[] = {
+static constexpr PropertyDefinition g_properties[] = {
     {"search-locally-for-kexts", OptionValue::eTypeBoolean, true, true, NULL,
      {}, "Automatically search for kexts on the local system when doing "
            "kernel debugging."},
     {"kext-directories", OptionValue::eTypeFileSpecList, false, 0, NULL, {},
      "Directories/KDKs to search for kexts in when starting a kernel debug "
-     "session."},
-    {NULL, OptionValue::eTypeInvalid, false, 0, NULL, {}, NULL}};
+     "session."}};
 
 enum { ePropertySearchForKexts = 0, ePropertyKextDirectories };
 
 class PlatformDarwinKernelProperties : public Properties {
 public:
   static ConstString &GetSettingName() {
     static ConstString g_setting_name("darwin-kernel");
     return g_setting_name;

source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 #include "ProcessKDPLog.h"
 #include "ThreadKDP.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 
-static PropertyDefinition g_properties[] = {
+static constexpr PropertyDefinition g_properties[] = {
     {"packet-timeout", OptionValue::eTypeUInt64, true, 5, NULL, {},
-     "Specify the default packet timeout in seconds."},
-    {NULL, OptionValue::eTypeInvalid, false, 0, NULL, {}, NULL}};
+     "Specify the default packet timeout in seconds."}};
 
 enum { ePropertyPacketTimeout };
 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return ProcessKDP::GetPluginNameStatic();
   }

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 }
 
 namespace {
 
 static constexpr PropertyDefinition g_properties[] = {
     {"packet-timeout", OptionValue::eTypeUInt64, true, 1, NULL, {},
      "Specify the default packet timeout in seconds."},
     {"target-definition-file", OptionValue::eTypeFileSpec, true, 0, NULL, {},
-     "The file that provides the description for remote target registers."},
-    {NULL, OptionValue::eTypeInvalid, false, 0, NULL, {}, NULL}};
+     "The file that provides the description for remote target registers."}};
 
 enum { ePropertyPacketTimeout, ePropertyTargetDefinitionFile };
 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return ProcessGDBRemote::GetPluginNameStatic();
   }

source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

static constexpr PropertyDefinition g_properties[] = {
         OptionValue::eTypeString, // type
         true,                     // global
         0,                        // default uint value
         "",                       // default cstring value
         {},                       // enum values
         "Specify the options to 'plugin structured-data darwin-log enable' "
         "that should be applied when automatically enabling logging on "
         "startup/attach." // description
-    },
-    // Last entry sentinel.
-    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, {}, nullptr}};
+    }};
 
 enum { ePropertyEnableOnStartup = 0, ePropertyAutoEnableOptions = 1 };
 
 class StructuredDataDarwinLogProperties : public Properties {
 public:
   static ConstString &GetSettingName() {
     static ConstString g_setting_name("darwin-log");
     return g_setting_name;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 
 static constexpr PropertyDefinition g_properties[] = {
     {"comp-dir-symlink-paths", OptionValue::eTypeFileSpecList, true, 0, nullptr,
      {},
      "If the DW_AT_comp_dir matches any of these paths the symbolic "
      "links will be resolved at DWARF parse time."},
     {"ignore-file-indexes", OptionValue::eTypeBoolean, true, 0, nullptr, {},
      "Ignore indexes present in the object files and always index DWARF "
-     "manually."},
-    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, {}, nullptr},
-};
+     "manually."}};
 
 enum {
   ePropertySymLinkPaths,
   ePropertyIgnoreIndexes,
 };
 
 class PluginProperties : public Properties {
 public:

source/Target/Platform.cpp

 const char *Platform::GetHostPlatformName() { return "host"; }
 
 namespace {
 
 static constexpr PropertyDefinition g_properties[] = {
     {"use-module-cache", OptionValue::eTypeBoolean, true, true, nullptr,
      {}, "Use module cache."},
     {"module-cache-directory", OptionValue::eTypeFileSpec, true, 0, nullptr,
-     {}, "Root directory for cached modules."},
-    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, {}, nullptr}};
+     {}, "Root directory for cached modules."}};
 
 enum { ePropertyUseModuleCache, ePropertyModuleCacheDirectory };
 
 } // namespace
 
 ConstString PlatformProperties::GetSettingName() {
   static ConstString g_setting_name("platform");
   return g_setting_name;

source/Target/Process.cpp

static constexpr PropertyDefinition g_properties[] = {
      {}, "If true, detach will attempt to keep the process stopped."},
     {"memory-cache-line-size", OptionValue::eTypeUInt64, false, 512, nullptr,
      {}, "The memory cache line size"},
     {"optimization-warnings", OptionValue::eTypeBoolean, false, true, nullptr,
      {}, "If true, warn when stopped in code that is optimized where "
          "stepping and variable availability may not behave as expected."},
     {"stop-on-exec", OptionValue::eTypeBoolean, true, true,
      nullptr, {},
-     "If true, stop when a shared library is loaded or unloaded."},
-    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, {}, nullptr}};
+     "If true, stop when a shared library is loaded or unloaded."}};
 
 enum {
   ePropertyDisableMemCache,
   ePropertyExtraStartCommand,
   ePropertyIgnoreBreakpointsInExpressions,
   ePropertyUnwindOnErrorInExpressions,
   ePropertyPythonOSPluginPath,
   ePropertyStopOnSharedLibraryEvents,

source/Target/Target.cpp

static constexpr PropertyDefinition g_properties[] = {
     {"trap-handler-names", OptionValue::eTypeArray, true,
      OptionValue::eTypeString, nullptr, {},
      "A list of trap handler function names, e.g. a common Unix user process "
      "one is _sigtramp."},
     {"display-runtime-support-values", OptionValue::eTypeBoolean, false, false,
      nullptr, {}, "If true, LLDB will show variables that are meant to "
                   "support the operation of a language's runtime support."},
     {"non-stop-mode", OptionValue::eTypeBoolean, false, 0, nullptr, {},
-     "Disable lock-step debugging, instead control threads independently."},
-    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, {}, nullptr}};
+     "Disable lock-step debugging, instead control threads independently."}};
 
 enum {
   ePropertyDefaultArch,
   ePropertyMoveToNearestCode,
   ePropertyLanguage,
   ePropertyExprPrefix,
   ePropertyPreferDynamic,
   ePropertyEnableSynthetic,

 static constexpr PropertyDefinition g_experimental_properties[]{
     {"inject-local-vars", OptionValue::eTypeBoolean, true, true, nullptr,
      {},
      "If true, inject local variables explicitly into the expression text.  "
      "This will fix symbol resolution when there are name collisions between "
      "ivars and local variables.  "
      "But it can make expressions run much more slowly."},
     {"use-modern-type-lookup", OptionValue::eTypeBoolean, true, false, nullptr,
-     {}, "If true, use Clang's modern type lookup infrastructure."},
-    {nullptr, OptionValue::eTypeInvalid, true, 0, nullptr, {}, nullptr}};
+     {}, "If true, use Clang's modern type lookup infrastructure."}};
 
 enum { ePropertyInjectLocalVars = 0, ePropertyUseModernTypeLookup };
 
 class TargetExperimentalOptionValueProperties : public OptionValueProperties {
 public:
   TargetExperimentalOptionValueProperties()
       : OptionValueProperties(
             ConstString(Properties::GetExperimentalSettingsName())) {}

source/Target/Thread.cpp

"If true, step-in will not stop in functions with no debug information."},
          "override this option."},
     {"step-avoid-regexp", OptionValue::eTypeRegex, true, 0, "^std::", {},
      "A regular expression defining functions step-in won't stop in."},
     {"step-avoid-libraries", OptionValue::eTypeFileSpecList, true, 0, nullptr,
      {}, "A list of libraries that source stepping won't stop in."},
     {"trace-thread", OptionValue::eTypeBoolean, false, false, nullptr, {},
      "If true, this thread will single-step and log execution."},
     {"max-backtrace-depth", OptionValue::eTypeUInt64, false, 300000, nullptr,
-     {}, "Maximum number of frames to backtrace."},
-    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, {}, nullptr}};
+     {}, "Maximum number of frames to backtrace."}};
 
 enum {
   ePropertyStepInAvoidsNoDebug,
   ePropertyStepOutAvoidsNoDebug,
   ePropertyStepAvoidRegex,
   ePropertyStepAvoidLibraries,
   ePropertyEnableThreadTrace,
   ePropertyMaxBacktraceDepth