[lldb] - Fix compilation with MSVS 2015 update 3

[grimar]

Summary

Currently, LLDB fails to build with the following errors when MSVS update 3 is used:

fatal error C1001: An internal error has occurred in the compiler.
(compiler file 'msc1.cpp', line 1468)
To work around this problem, try simplifying or changing the program near the locations listed above.

Seems it is relative to constexpr. This patch introduces macro CONSTEXPR that expands to const/constexpr
depending on the environment and this change allows LLDB to compile and run under windows for me.

[clayborg]

The changes from "constexpr" to "const" might introduce global constructors in the shared library which is what we were trying to avoid. The less work that the LLDB shared library does on load the better. We might need to use a macro that expands to "constexpr" for non windows and to "const" for windows in a private LLDB header (PropertyDefinition.h?)

[grimar]

In D55995#1339099, @clayborg wrote:

The changes from "constexpr" to "const" might introduce global constructors in the shared library which is what we were trying to avoid. The less work that the LLDB shared library does on load the better. We might need to use a macro that expands to "constexpr" for non windows and to "const" for windows in a private LLDB header (PropertyDefinition.h?)

Thanks for looking, Greg. Initially, I thought only MSVS 2015 is affected, but looking at the comments in the wild (https://developercommunity.visualstudio.com/content/problem/18155/msvc-2017-c-fatal-error-c1001-constexpr-initializa.html),
seems it might be an issue for MSVS 2017 too. So I am going to implement your suggestion. Seems lldb/lldb-defines.h file we already have is a good place for a new macro definition.

[grimar]

• Addressed review comment.

[grimar]

Ping.

[labath]

BTW, I've been compiling lldb with VS2017 and haven't run into this issue. Also, with the imminent release of VS2019, I expect someone will soon start a thread proposing to drop VS2015, so you might be better of switching to a newer compiler. (But I don't have a problem with checking this in while we still officially support this compiler.)

[grimar]

In D55995#1352772, @labath wrote:

BTW, I've been compiling lldb with VS2017 and haven't run into this issue. Also, with the imminent release of VS2019, I expect someone will soon start a thread proposing to drop VS2015, so you might be better of switching to a newer compiler. (But I don't have a problem with checking this in while we still officially support this compiler.)

I am OK with switching to VS2017 I think.

[grimar]

I'll try to switch to MSVS 2017 and recheck this.

[grimar]

Yep, MSVS2017 works fine here for me too. Thanks, Pavel! I am abandoning it.

include/lldb/lldb-defines.h

 #define MAX_PATH 260
 #endif
 
 // ignore GCC function attributes
 #if defined(_MSC_VER) && !defined(__clang__)
 #define __attribute__(X)
 #endif
 
+// MSVS 2015/2017 suffer from internal compiler error when dealing with a
+// `constexpr` keyword. It's a known issue, but we have to declare this macro to
+// use 'const' as a workaround for now.
+// (https://developercommunity.visualstudio.com/content/problem/18155/msvc-2017-c-fatal-error-c1001-constexpr-initializa.html)
+#if defined(_MSC_VER)
+#define CONSTEXPR const
+#else
+#define CONSTEXPR constexpr
+#endif
+
 #define UNUSED_IF_ASSERT_DISABLED(x) ((void)(x))
 
 #if defined(__cplusplus)
 
 //----------------------------------------------------------------------
 /// @def DISALLOW_COPY_AND_ASSIGN(TypeName)
 ///     Macro definition for easily disallowing copy constructor and
 ///     assignment operators in C++ classes.
 //----------------------------------------------------------------------
 #define DISALLOW_COPY_AND_ASSIGN(TypeName)                                     \
   TypeName(const TypeName &) = delete;                                         \
   const TypeName &operator=(const TypeName &) = delete
 
 #endif // #if defined(__cplusplus)
 
 #endif // LLDB_lldb_defines_h_

source/Commands/CommandObjectBreakpointCommand.cpp

 // CommandObjectBreakpointCommandAdd
 //-------------------------------------------------------------------------
 
 // FIXME: "script-type" needs to have its contents determined dynamically, so
 // somebody can add a new scripting
 // language to lldb and have it pickable here without having to change this
 // enumeration by hand and rebuild lldb proper.
 
-static constexpr OptionEnumValueElement g_script_option_enumeration[] = {
+static CONSTEXPR OptionEnumValueElement g_script_option_enumeration[] = {
     {eScriptLanguageNone, "command",
      "Commands are in the lldb command interpreter language"},
     {eScriptLanguagePython, "python", "Commands are in the Python language."},
     {eSortOrderByName, "default-script",
      "Commands are in the default scripting language."} };
 
-static constexpr OptionEnumValues ScriptOptionEnum() {
+static CONSTEXPR OptionEnumValues ScriptOptionEnum() {
   return OptionEnumValues(g_script_option_enumeration);
 }
 
-static constexpr OptionDefinition g_breakpoint_add_options[] = {
+static CONSTEXPR OptionDefinition g_breakpoint_add_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1,   false, "one-liner",         'o', OptionParser::eRequiredArgument, nullptr, {},                 0, eArgTypeOneLiner,       "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." },
   { LLDB_OPT_SET_ALL, false, "stop-on-error",     'e', OptionParser::eRequiredArgument, nullptr, {},                 0, eArgTypeBoolean,        "Specify whether breakpoint command execution should terminate on error." },
   { LLDB_OPT_SET_ALL, false, "script-type",       's', OptionParser::eRequiredArgument, nullptr, ScriptOptionEnum(), 0, eArgTypeNone,           "Specify the language for the commands - if none is specified, the lldb command interpreter will be used." },
   { LLDB_OPT_SET_2,   false, "python-function",   'F', OptionParser::eRequiredArgument, nullptr, {},                 0, eArgTypePythonFunction, "Give the name of a Python function to run as command for this breakpoint. Be sure to give a module name if appropriate." },
   { LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument,       nullptr, {},                 0, eArgTypeNone,           "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets." },
     // clang-format on
 };

source/Commands/CommandObjectCommands.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
 // CommandObjectCommandsSource
 //-------------------------------------------------------------------------
 
-static constexpr OptionDefinition g_history_options[] = {
+static CONSTEXPR OptionDefinition g_history_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1, false, "count",       'c', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeUnsignedInteger, "How many history commands to print." },
   { LLDB_OPT_SET_1, false, "start-index", 's', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeUnsignedInteger, "Index at which to start printing history commands (or end to mean tail mode)." },
   { LLDB_OPT_SET_1, false, "end-index",   'e', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeUnsignedInteger, "Index at which to stop printing history commands." },
   { LLDB_OPT_SET_2, false, "clear",       'C', OptionParser::eNoArgument,       nullptr, {}, 0, eArgTypeBoolean,         "Clears the current command history." },
     // clang-format on
 };
 
protected:
 
   CommandOptions m_options;
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectCommandsSource
 //-------------------------------------------------------------------------
 
-static constexpr OptionDefinition g_source_options[] = {
+static CONSTEXPR OptionDefinition g_source_options[] = {
     // clang-format off
   { LLDB_OPT_SET_ALL, false, "stop-on-error",    'e', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, "If true, stop executing commands on error." },
   { LLDB_OPT_SET_ALL, false, "stop-on-continue", 'c', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, "If true, stop executing commands on continue." },
   { LLDB_OPT_SET_ALL, false, "silent-run",       's', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, "If true don't echo commands while executing." },
     // clang-format on
 };
 
 class CommandObjectCommandsSource : public CommandObjectParsed {
protected:
   CommandOptions m_options;
 };
 
 #pragma mark CommandObjectCommandsAlias
 //-------------------------------------------------------------------------
 // CommandObjectCommandsAlias
 //-------------------------------------------------------------------------
 
-static constexpr OptionDefinition g_alias_options[] = {
+static CONSTEXPR OptionDefinition g_alias_options[] = {
     // clang-format off
   { LLDB_OPT_SET_ALL, false, "help",      'h', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeHelpText, "Help text for this command" },
   { LLDB_OPT_SET_ALL, false, "long-help", 'H', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeHelpText, "Long help text for this command" },
     // clang-format on
 };
 
 static const char *g_python_command_instructions =
     "Enter your Python command(s). Type 'DONE' to end.\n"
bool DoExecute(Args &args, CommandReturnObject &result) override {
     return true;
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectCommandsAddRegex
 //-------------------------------------------------------------------------
 
-static constexpr OptionDefinition g_regex_options[] = {
+static CONSTEXPR OptionDefinition g_regex_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1, false, "help"  , 'h', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeNone, "The help text to display for this command." },
   { LLDB_OPT_SET_1, false, "syntax", 's', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeNone, "A syntax string showing the typical usage syntax." },
     // clang-format on
 };
 
 #pragma mark CommandObjectCommandsAddRegex
 
private:
   bool m_fetched_help_short : 1;
   bool m_fetched_help_long : 1;
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectCommandsScriptImport
 //-------------------------------------------------------------------------
 
-static constexpr OptionDefinition g_script_import_options[] = {
+static CONSTEXPR OptionDefinition g_script_import_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1, false, "allow-reload", 'r', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Allow the script to be loaded even if it was already loaded before. This argument exists for backwards compatibility, but reloading is always allowed, whether you specify it or not." },
     // clang-format on
 };
 
 class CommandObjectCommandsScriptImport : public CommandObjectParsed {
 public:
   CommandObjectCommandsScriptImport(CommandInterpreter &interpreter)
protected:
   }
 
   CommandOptions m_options;
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectCommandsScriptAdd
 //-------------------------------------------------------------------------
-static constexpr OptionEnumValueElement g_script_synchro_type[] = {
+static CONSTEXPR OptionEnumValueElement g_script_synchro_type[] = {
   {eScriptedCommandSynchronicitySynchronous, "synchronous",
    "Run synchronous"},
   {eScriptedCommandSynchronicityAsynchronous, "asynchronous",
    "Run asynchronous"},
   {eScriptedCommandSynchronicityCurrentValue, "current",
    "Do not alter current setting"} };
 
-static constexpr OptionEnumValues ScriptSynchroType() {
+static CONSTEXPR OptionEnumValues ScriptSynchroType() {
   return OptionEnumValues(g_script_synchro_type);
 }
 
-static constexpr OptionDefinition g_script_add_options[] = {
+static CONSTEXPR OptionDefinition g_script_add_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1,   false, "function",      'f', OptionParser::eRequiredArgument, nullptr, {},                  0, eArgTypePythonFunction,               "Name of the Python function to bind to this command name." },
   { LLDB_OPT_SET_2,   false, "class",         'c', OptionParser::eRequiredArgument, nullptr, {},                  0, eArgTypePythonClass,                  "Name of the Python class to bind to this command name." },
   { LLDB_OPT_SET_1,   false, "help"  ,        'h', OptionParser::eRequiredArgument, nullptr, {},                  0, eArgTypeHelpText,                     "The help text to display for this command." },
   { LLDB_OPT_SET_ALL, false, "synchronicity", 's', OptionParser::eRequiredArgument, nullptr, ScriptSynchroType(), 0, eArgTypeScriptedCommandSynchronicity, "Set the synchronicity of this command's executions with regard to LLDB event system." },
     // clang-format on
 };
 

source/Commands/CommandObjectExpression.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 CommandObjectExpression::CommandOptions::CommandOptions() : OptionGroup() {}
 
 CommandObjectExpression::CommandOptions::~CommandOptions() = default;
 
-static constexpr OptionEnumValueElement g_description_verbosity_type[] = {
+static CONSTEXPR OptionEnumValueElement g_description_verbosity_type[] = {
     {eLanguageRuntimeDescriptionDisplayVerbosityCompact, "compact",
      "Only show the description string"},
     {eLanguageRuntimeDescriptionDisplayVerbosityFull, "full",
      "Show the full output, including persistent variable's name and type"} };
 
-static constexpr OptionEnumValues DescriptionVerbosityTypes() {
+static CONSTEXPR OptionEnumValues DescriptionVerbosityTypes() {
   return OptionEnumValues(g_description_verbosity_type);
 }
 
-static constexpr OptionDefinition g_expression_options[] = {
+static CONSTEXPR OptionDefinition g_expression_options[] = {
     // clang-format off
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "all-threads",           'a', OptionParser::eRequiredArgument, nullptr, {},                          0, eArgTypeBoolean,              "Should we run all threads if the execution doesn't complete on one thread."},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "ignore-breakpoints",    'i', OptionParser::eRequiredArgument, nullptr, {},                          0, eArgTypeBoolean,              "Ignore breakpoint hits while running expressions"},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "timeout",               't', OptionParser::eRequiredArgument, nullptr, {},                          0, eArgTypeUnsignedInteger,      "Timeout value (in microseconds) for running the expression."},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "unwind-on-error",       'u', OptionParser::eRequiredArgument, nullptr, {},                          0, eArgTypeBoolean,              "Clean up program state if the expression causes a crash, or raises a signal.  "
                                                                                                                                                                                   "Note, unlike gdb hitting a breakpoint is controlled by another option (-i)."},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "debug",                 'g', OptionParser::eNoArgument,       nullptr, {},                          0, eArgTypeNone,                 "When specified, debug the JIT code by setting a breakpoint on the first instruction "
                                                                                                                                                                                   "and forcing breakpoints to not be ignored (-i0) and no unwinding to happen on error (-u0)."},

source/Commands/CommandObjectTarget.cpp

for (uint32_t i = 0; i < num_targets; ++i) {
       }
     }
   }
   return num_targets;
 }
 
 // Note that the negation in the argument name causes a slightly confusing
 // mapping of the enum values,
-static constexpr OptionEnumValueElement g_dependents_enumaration[] = {
+static CONSTEXPR OptionEnumValueElement g_dependents_enumaration[] = {
     {eLoadDependentsDefault, "default",
      "Only load dependents when the target is an executable."},
     {eLoadDependentsNo, "true",
      "Don't load dependents, even if the target is an executable."},
     {eLoadDependentsYes, "false",
      "Load dependents, even if the target is not an executable."}};
 
-static constexpr OptionDefinition g_dependents_options[] = {
+static CONSTEXPR OptionDefinition g_dependents_options[] = {
     {LLDB_OPT_SET_1, false, "no-dependents", 'd',
      OptionParser::eOptionalArgument, nullptr,
      OptionEnumValues(g_dependents_enumaration), 0, eArgTypeValue,
      "Whether or not to load dependents when creating a target. If the option "
      "is not specified, the value is implicitly 'default'. If the option is "
      "specified but without a value, the value is implicitly 'true'."}};
 
 class OptionGroupDependents : public OptionGroup {
if (num_dumped > 0) {
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectTargetModulesDumpSymtab
 
-static constexpr OptionEnumValueElement g_sort_option_enumeration[] = {
+static CONSTEXPR OptionEnumValueElement g_sort_option_enumeration[] = {
     {eSortOrderNone, "none",
      "No sorting, use the original symbol table order."},
     {eSortOrderByAddress, "address", "Sort output by symbol address."},
     {eSortOrderByName, "name", "Sort output by symbol name."} };
 
-static constexpr OptionDefinition g_target_modules_dump_symtab_options[] = {
+static CONSTEXPR OptionDefinition g_target_modules_dump_symtab_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1, false, "sort", 's', OptionParser::eRequiredArgument, nullptr, OptionEnumValues(g_sort_option_enumeration), 0, eArgTypeSortOrder, "Supply a sort order when dumping the symbol table." }
     // clang-format on
 };
 
 class CommandObjectTargetModulesDumpSymtab
     : public CommandObjectTargetModulesModuleAutoComplete {
 public:

source/Commands/CommandObjectThread.cpp

protected:
   bool m_unique_stacks = false;
   bool m_add_return = true;
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectThreadBacktrace
 //-------------------------------------------------------------------------
 
-static constexpr OptionDefinition g_thread_backtrace_options[] = {
+static CONSTEXPR OptionDefinition g_thread_backtrace_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1, false, "count",    'c', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCount,      "How many frames to display (-1 for all)" },
   { LLDB_OPT_SET_1, false, "start",    's', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeFrameIndex, "Frame in which to start the backtrace" },
   { LLDB_OPT_SET_1, false, "extended", 'e', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean,    "Show the extended backtrace, if available" }
     // clang-format on
 };
 
 class CommandObjectThreadBacktrace : public CommandObjectIterateOverThreads {
bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
     return true;
   }
 
   CommandOptions m_options;
 };
 
 enum StepScope { eStepScopeSource, eStepScopeInstruction };
 
-static constexpr OptionEnumValueElement g_tri_running_mode[] = {
+static CONSTEXPR OptionEnumValueElement g_tri_running_mode[] = {
     {eOnlyThisThread, "this-thread", "Run only this thread"},
     {eAllThreads, "all-threads", "Run all threads"},
     {eOnlyDuringStepping, "while-stepping",
      "Run only this thread while stepping"} };
 
-static constexpr OptionEnumValues TriRunningModes() {
+static CONSTEXPR OptionEnumValues TriRunningModes() {
   return OptionEnumValues(g_tri_running_mode);
 }
 
-static constexpr OptionDefinition g_thread_step_scope_options[] = {
+static CONSTEXPR OptionDefinition g_thread_step_scope_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1, false, "step-in-avoids-no-debug",   'a', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeBoolean,           "A boolean value that sets whether stepping into functions will step over functions with no debug information." },
   { LLDB_OPT_SET_1, false, "step-out-avoids-no-debug",  'A', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeBoolean,           "A boolean value, if true stepping out of functions will continue to step out till it hits a function with debug information." },
   { LLDB_OPT_SET_1, false, "count",                     'c', OptionParser::eRequiredArgument, nullptr, {},                1, eArgTypeCount,             "How many times to perform the stepping operation - currently only supported for step-inst and next-inst." },
   { LLDB_OPT_SET_1, false, "end-linenumber",            'e', OptionParser::eRequiredArgument, nullptr, {},                1, eArgTypeLineNum,           "The line at which to stop stepping - defaults to the next line and only supported for step-in and step-over.  You can also pass the string 'block' to step to the end of the current block.  This is particularly useful in conjunction with --step-target to step through a complex calling sequence." },
   { LLDB_OPT_SET_1, false, "run-mode",                  'm', OptionParser::eRequiredArgument, nullptr, TriRunningModes(), 0, eArgTypeRunMode,           "Determine how to run other threads while stepping the current thread." },
   { LLDB_OPT_SET_1, false, "step-over-regexp",          'r', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeRegularExpression, "A regular expression that defines function names to not to stop at when stepping in." },
   { LLDB_OPT_SET_1, false, "step-in-target",            't', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeFunctionName,      "The name of the directly called function step in should stop at when stepping into." },
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectThreadUntil
 //-------------------------------------------------------------------------
 
-static constexpr OptionEnumValueElement g_duo_running_mode[] = {
+static CONSTEXPR OptionEnumValueElement g_duo_running_mode[] = {
     {eOnlyThisThread, "this-thread", "Run only this thread"},
     {eAllThreads, "all-threads", "Run all threads"} };
 
-static constexpr OptionEnumValues DuoRunningModes() {
+static CONSTEXPR OptionEnumValues DuoRunningModes() {
   return OptionEnumValues(g_duo_running_mode);
 }
 
-static constexpr OptionDefinition g_thread_until_options[] = {
+static CONSTEXPR OptionDefinition g_thread_until_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1, false, "frame",   'f', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeFrameIndex,          "Frame index for until operation - defaults to 0" },
   { LLDB_OPT_SET_1, false, "thread",  't', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeThreadIndex,         "Thread index for the thread for until operation" },
   { LLDB_OPT_SET_1, false, "run-mode",'m', OptionParser::eRequiredArgument, nullptr, DuoRunningModes(), 0, eArgTypeRunMode,             "Determine how to run other threads while stepping this one" },
   { LLDB_OPT_SET_1, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, {},                0, eArgTypeAddressOrExpression, "Run until we reach the specified address, or leave the function - can be specified multiple times." }
     // clang-format on
 };
 

source/Commands/CommandObjectWatchpointCommand.cpp

 // CommandObjectWatchpointCommandAdd
 //-------------------------------------------------------------------------
 
 // FIXME: "script-type" needs to have its contents determined dynamically, so
 // somebody can add a new scripting
 // language to lldb and have it pickable here without having to change this
 // enumeration by hand and rebuild lldb proper.
 
-static constexpr OptionEnumValueElement g_script_option_enumeration[] = {
+static CONSTEXPR OptionEnumValueElement g_script_option_enumeration[] = {
     {eScriptLanguageNone, "command",
      "Commands are in the lldb command interpreter language"},
     {eScriptLanguagePython, "python", "Commands are in the Python language."},
     {eSortOrderByName, "default-script",
      "Commands are in the default scripting language."} };
 
-static constexpr OptionEnumValues ScriptOptionEnum() {
+static CONSTEXPR OptionEnumValues ScriptOptionEnum() {
   return OptionEnumValues(g_script_option_enumeration);
 }
 
-static constexpr OptionDefinition g_watchpoint_command_add_options[] = {
+static CONSTEXPR OptionDefinition g_watchpoint_command_add_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1,   false, "one-liner",       'o', OptionParser::eRequiredArgument, nullptr, {},                 0, eArgTypeOneLiner,       "Specify a one-line watchpoint command inline. Be sure to surround it with quotes." },
   { LLDB_OPT_SET_ALL, false, "stop-on-error",   'e', OptionParser::eRequiredArgument, nullptr, {},                 0, eArgTypeBoolean,        "Specify whether watchpoint command execution should terminate on error." },
   { LLDB_OPT_SET_ALL, false, "script-type",     's', OptionParser::eRequiredArgument, nullptr, ScriptOptionEnum(), 0, eArgTypeNone,           "Specify the language for the commands - if none is specified, the lldb command interpreter will be used." },
   { LLDB_OPT_SET_2,   false, "python-function", 'F', OptionParser::eRequiredArgument, nullptr, {},                 0, eArgTypePythonFunction, "Give the name of a Python function to run as command for this watchpoint. Be sure to give a module name if appropriate." }
     // clang-format on
 };
 

source/Core/Debugger.cpp

 #pragma mark Static Functions
 
 typedef std::vector<DebuggerSP> DebuggerList;
 static std::recursive_mutex *g_debugger_list_mutex_ptr =
     nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
 static DebuggerList *g_debugger_list_ptr =
     nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
 
-static constexpr OptionEnumValueElement g_show_disassembly_enum_values[] = {
+static CONSTEXPR OptionEnumValueElement g_show_disassembly_enum_values[] = {
     {Debugger::eStopDisassemblyTypeNever, "never",
      "Never show disassembly when displaying a stop context."},
     {Debugger::eStopDisassemblyTypeNoDebugInfo, "no-debuginfo",
      "Show disassembly when there is no debug information."},
     {Debugger::eStopDisassemblyTypeNoSource, "no-source",
      "Show disassembly when there is no source information, or the source file "
      "is missing when displaying a stop context."},
     {Debugger::eStopDisassemblyTypeAlways, "always",
      "Always show disassembly when displaying a stop context."} };
 
-static constexpr OptionEnumValueElement g_language_enumerators[] = {
+static CONSTEXPR OptionEnumValueElement g_language_enumerators[] = {
     {eScriptLanguageNone, "none", "Disable scripting languages."},
     {eScriptLanguagePython, "python",
      "Select python as the default scripting language."},
     {eScriptLanguageDefault, "default",
      "Select the lldb default as the default scripting language."} };
 
 #define MODULE_WITH_FUNC                                                       \
   "{ "                                                                         \

 // offset-no-padding}>}:
 
 // lldb's original format for disassembly would look like this format string -
 // {${function.initial-function}{${module.file.basename}`}{${function.name-
 // without-
 // args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-
 // without-args}}:\n}{${current-pc-arrow} }{${addr-file-or-load}}:
 
-static constexpr OptionEnumValueElement s_stop_show_column_values[] = {
+static CONSTEXPR OptionEnumValueElement s_stop_show_column_values[] = {
     {eStopShowColumnAnsiOrCaret, "ansi-or-caret",
      "Highlight the stop column with ANSI terminal codes when color/ANSI mode "
      "is enabled; otherwise, fall back to using a text-only caret (^) as if "
      "\"caret-only\" mode was selected."},
     {eStopShowColumnAnsi, "ansi", "Highlight the stop column with ANSI "
                                   "terminal codes when running LLDB with "
                                   "color/ANSI enabled."},
     {eStopShowColumnCaret, "caret",
      "Highlight the stop column with a caret character (^) underneath the stop "
      "column. This method introduces a new line in source listings that "
      "display thread stop locations."},
     {eStopShowColumnNone, "none", "Do not highlight the stop column."}};
 
-static constexpr PropertyDefinition g_properties[] = {
+static CONSTEXPR PropertyDefinition g_properties[] = {
     {"auto-confirm", OptionValue::eTypeBoolean, true, false, nullptr, {},
      "If true all confirmation prompts will receive their default reply."},
     {"disassembly-format", OptionValue::eTypeFormatEntity, true, 0,
      DEFAULT_DISASSEMBLY_FORMAT, {},
      "The default disassembly format "
      "string to use when disassembling "
      "instruction sequences."},
     {"frame-format", OptionValue::eTypeFormatEntity, true, 0,

source/Interpreter/OptionGroupWatchpoint.cpp

 
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/lldb-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-static constexpr OptionEnumValueElement g_watch_type[] = {
+static CONSTEXPR OptionEnumValueElement g_watch_type[] = {
     {OptionGroupWatchpoint::eWatchRead, "read", "Watch for read"},
     {OptionGroupWatchpoint::eWatchWrite, "write", "Watch for write"},
     {OptionGroupWatchpoint::eWatchReadWrite, "read_write",
-     "Watch for read/write"} };
+     "Watch for read/write"}};
 
-static constexpr OptionEnumValueElement g_watch_size[] = {
+static CONSTEXPR OptionEnumValueElement g_watch_size[] = {
     {1, "1", "Watch for byte size of 1"},
     {2, "2", "Watch for byte size of 2"},
     {4, "4", "Watch for byte size of 4"},
-    {8, "8", "Watch for byte size of 8"} };
+    {8, "8", "Watch for byte size of 8"}};
 
-static constexpr OptionDefinition g_option_table[] = {
+static CONSTEXPR OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_1, false, "watch", 'w', OptionParser::eRequiredArgument,
      nullptr, OptionEnumValues(g_watch_type), 0, eArgTypeWatchType,
      "Specify the type of watching to perform."},
     {LLDB_OPT_SET_1, false, "size", 's', OptionParser::eRequiredArgument,
      nullptr, OptionEnumValues(g_watch_size), 0, eArgTypeByteSize,
      "Number of bytes to use to watch a region."}};
 
 bool OptionGroupWatchpoint::IsWatchSizeSupported(uint32_t watch_size) {

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

enum KASLRScanType {
   eKASLRScanLowgloAddresses, // Check one word of memory for a possible kernel
                              // addr, then see if a kernel is there
   eKASLRScanNearPC, // Scan backwards from the current $pc looking for kernel;
                     // checking at 96 locations total
   eKASLRScanExhaustiveScan // Scan through the entire possible kernel address
                            // range looking for a kernel
 };
 
-static constexpr OptionEnumValueElement g_kaslr_kernel_scan_enum_values[] = {
+static CONSTEXPR OptionEnumValueElement g_kaslr_kernel_scan_enum_values[] = {
     {eKASLRScanNone, "none",
      "Do not read memory looking for a Darwin kernel when attaching."},
     {eKASLRScanLowgloAddresses, "basic", "Check for the Darwin kernel's load "
                                          "addr in the lowglo page "
                                          "(boot-args=debug) only."},
     {eKASLRScanNearPC, "fast-scan", "Scan near the pc value on attach to find "
                                     "the Darwin kernel's load address."},
     {eKASLRScanExhaustiveScan, "exhaustive-scan",
      "Scan through the entire potential address range of Darwin kernel (only "
      "on 32-bit targets)."}};
 
-static constexpr PropertyDefinition g_properties[] = {
+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."}};
 
 enum { ePropertyLoadKexts, ePropertyScanType };

source/Target/Target.cpp

void Target::StopHook::GetDescription(Stream *s,
   s->SetIndentLevel(indent_level);
 }
 
 //--------------------------------------------------------------
 // class TargetProperties
 //--------------------------------------------------------------
 
 // clang-format off
-static constexpr OptionEnumValueElement g_dynamic_value_types[] = {
+static CONSTEXPR OptionEnumValueElement g_dynamic_value_types[] = {
     {eNoDynamicValues, "no-dynamic-values",
      "Don't calculate the dynamic type of values"},
     {eDynamicCanRunTarget, "run-target", "Calculate the dynamic type of values "
                                          "even if you have to run the target."},
     {eDynamicDontRunTarget, "no-run-target",
      "Calculate the dynamic type of values, but don't run the target."} };
 
 OptionEnumValues lldb_private::GetDynamicValueTypes() {
   return OptionEnumValues(g_dynamic_value_types);
 }
 
-static constexpr OptionEnumValueElement g_inline_breakpoint_enums[] = {
+static CONSTEXPR OptionEnumValueElement g_inline_breakpoint_enums[] = {
     {eInlineBreakpointsNever, "never", "Never look for inline breakpoint "
                                        "locations (fastest). This setting "
                                        "should only be used if you know that "
                                        "no inlining occurs in your programs."},
     {eInlineBreakpointsHeaders, "headers",
      "Only check for inline breakpoint locations when setting breakpoints in "
      "header files, but not when setting breakpoint in implementation source "
      "files (default)."},
     {eInlineBreakpointsAlways, "always",
      "Always look for inline breakpoint locations when setting file and line "
      "breakpoints (slower but most accurate)."} };
 
 typedef enum x86DisassemblyFlavor {
   eX86DisFlavorDefault,
   eX86DisFlavorIntel,
   eX86DisFlavorATT
 } x86DisassemblyFlavor;
 
-static constexpr OptionEnumValueElement g_x86_dis_flavor_value_types[] = {
+static CONSTEXPR OptionEnumValueElement g_x86_dis_flavor_value_types[] = {
     {eX86DisFlavorDefault, "default", "Disassembler default (currently att)."},
     {eX86DisFlavorIntel, "intel", "Intel disassembler flavor."},
     {eX86DisFlavorATT, "att", "AT&T disassembler flavor."} };
 
-static constexpr OptionEnumValueElement g_hex_immediate_style_values[] = {
+static CONSTEXPR OptionEnumValueElement g_hex_immediate_style_values[] = {
     {Disassembler::eHexStyleC, "c", "C-style (0xffff)."},
     {Disassembler::eHexStyleAsm, "asm", "Asm-style (0ffffh)."} };
 
-static constexpr OptionEnumValueElement g_load_script_from_sym_file_values[] = {
+static CONSTEXPR OptionEnumValueElement g_load_script_from_sym_file_values[] = {
     {eLoadScriptFromSymFileTrue, "true",
      "Load debug scripts inside symbol files"},
     {eLoadScriptFromSymFileFalse, "false",
      "Do not load debug scripts inside symbol files."},
     {eLoadScriptFromSymFileWarn, "warn",
      "Warn about debug scripts inside symbol files but do not load them."} };
 
-static constexpr
+static CONSTEXPR
 OptionEnumValueElement g_load_current_working_dir_lldbinit_values[] = {
     {eLoadCWDlldbinitTrue, "true",
      "Load .lldbinit files from current directory"},
     {eLoadCWDlldbinitFalse, "false",
      "Do not load .lldbinit files from current directory"},
     {eLoadCWDlldbinitWarn, "warn",
      "Warn about loading .lldbinit files from current directory"} };
 
-static constexpr OptionEnumValueElement g_memory_module_load_level_values[] = {
+static CONSTEXPR OptionEnumValueElement g_memory_module_load_level_values[] = {
     {eMemoryModuleLoadLevelMinimal, "minimal",
      "Load minimal information when loading modules from memory. Currently "
      "this setting loads sections only."},
     {eMemoryModuleLoadLevelPartial, "partial",
      "Load partial information when loading modules from memory. Currently "
      "this setting loads sections and function bounds."},
     {eMemoryModuleLoadLevelComplete, "complete",
      "Load complete information when loading modules from memory. Currently "
      "this setting loads sections and all symbols."} };
 
-static constexpr PropertyDefinition g_properties[] = {
+static CONSTEXPR PropertyDefinition g_properties[] = {
     {"default-arch", OptionValue::eTypeArch, true, 0, nullptr, {},
      "Default architecture to choose, when there's a choice."},
     {"move-to-nearest-code", OptionValue::eTypeBoolean, false, true, nullptr,
      {}, "Move breakpoints to nearest code."},
     {"language", OptionValue::eTypeLanguage, false, eLanguageTypeUnknown,
      nullptr, {},
      "The language to use when interpreting expressions entered in commands."},
     {"expr-prefix", OptionValue::eTypeFileSpec, false, 0, nullptr, {},