[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/Target/Target.h

private:
   // Member variables.
   //------------------------------------------------------------------
   ProcessLaunchInfo m_launch_info;
   std::unique_ptr<TargetExperimentalProperties> m_experimental_properties_up;
 };
 
 class EvaluateExpressionOptions {
 public:
-// MSVC has a bug here that reports C4268: 'const' static/global data
-// initialized with compiler generated default constructor fills the object
-// with zeros. Confirmed that MSVC is *not* zero-initializing, it's just a
-// bogus warning.
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4268)
-#endif
-  static constexpr std::chrono::milliseconds default_timeout{500};
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-  static constexpr ExecutionPolicy default_execution_policy =
-      eExecutionPolicyOnlyWhenNeeded;
+  static const ExecutionPolicy default_execution_policy =
 
-  EvaluateExpressionOptions() = default;
+  EvaluateExpressionOptions() : m_timeout(std::chrono::milliseconds(500)){};
 
   ExecutionPolicy GetExecutionPolicy() const { return m_execution_policy; }
 
   void SetExecutionPolicy(ExecutionPolicy policy = eExecutionPolicyAlways) {
     m_execution_policy = policy;
   }
 
   lldb::LanguageType GetLanguage() const { return m_language; }
private:
   bool m_ansi_color_errors = false;
   bool m_result_is_internal = false;
   bool m_auto_apply_fixits = true;
   /// True if the executed code should be treated as utility code that is only
   /// used by LLDB internally.
   bool m_running_utility_expression = false;
 
   lldb::DynamicValueType m_use_dynamic = lldb::eNoDynamicValues;
-  Timeout<std::micro> m_timeout = default_timeout;
+  Timeout<std::micro> m_timeout;
   Timeout<std::micro> m_one_thread_timeout = llvm::None;
   lldb::ExpressionCancelCallback m_cancel_callback = nullptr;
   void *m_cancel_callback_baton = nullptr;
   // If m_pound_line_file is not empty and m_pound_line_line is non-zero, use
   // #line %u "%s" before the expression content to remap where the source
   // originates
   mutable std::string m_pound_line_file;
   mutable uint32_t m_pound_line_line;

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 const 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 const OptionEnumValues ScriptOptionEnum() {
   return OptionEnumValues(g_script_option_enumeration);
 }
 
-static constexpr OptionDefinition g_breakpoint_add_options[] = {
+static const 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

 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 const OptionEnumValues ScriptSynchroType() {
   return OptionEnumValues(g_script_synchro_type);
 }
 
-static constexpr OptionDefinition g_script_add_options[] = {
+static const 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 const 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 const OptionEnumValues DescriptionVerbosityTypes() {
   return OptionEnumValues(g_description_verbosity_type);
 }
 
-static constexpr OptionDefinition g_expression_options[] = {
+static const 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 const 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 const 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 const 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 const 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 const 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 const 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 const OptionEnumValues TriRunningModes() {
   return OptionEnumValues(g_tri_running_mode);
 }
 
-static constexpr OptionDefinition g_thread_step_scope_options[] = {
+static const 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 const OptionEnumValueElement g_duo_running_mode[] = {
     {eOnlyThisThread, "this-thread", "Run only this thread"},
     {eAllThreads, "all-threads", "Run all threads"} };
 
-static constexpr OptionEnumValues DuoRunningModes() {
+static const OptionEnumValues DuoRunningModes() {
   return OptionEnumValues(g_duo_running_mode);
 }
 
-static constexpr OptionDefinition g_thread_until_options[] = {
+static const 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 const 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 const OptionEnumValues ScriptOptionEnum() {
   return OptionEnumValues(g_script_option_enumeration);
 }
 
-static constexpr OptionDefinition g_watchpoint_command_add_options[] = {
+static const 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

 // 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 const 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 const 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 const OptionEnumValueElement g_watch_type[] = {
     {OptionGroupWatchpoint::eWatchRead, "read", "Watch for read"},
     {OptionGroupWatchpoint::eWatchWrite, "write", "Watch for write"},
     {OptionGroupWatchpoint::eWatchReadWrite, "read_write",
      "Watch for read/write"} };
 
-static constexpr OptionEnumValueElement g_watch_size[] = {
+static const 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"} };
 
-static constexpr OptionDefinition g_option_table[] = {
+static const 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 const 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 const 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

 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include <mutex>
 
 using namespace lldb;
 using namespace lldb_private;
 
-constexpr std::chrono::milliseconds EvaluateExpressionOptions::default_timeout;
-
 Target::Arch::Arch(const ArchSpec &spec)
     : m_spec(spec),
       m_plugin_up(PluginManager::CreateArchitectureInstance(spec)) {}
 
 const Target::Arch& Target::Arch::operator=(const ArchSpec &spec) {
   m_spec = spec;
   m_plugin_up = PluginManager::CreateArchitectureInstance(spec);
   return *this;
void Target::StopHook::GetDescription(Stream *s,
   s->SetIndentLevel(indent_level);
 }
 
 //--------------------------------------------------------------
 // class TargetProperties
 //--------------------------------------------------------------
 
 // clang-format off
-static constexpr OptionEnumValueElement g_dynamic_value_types[] = {
+static const 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 const 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 const 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 const 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 const 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 const
 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 const 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 const 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, {},
protected:
   }
   Target *m_target;
   mutable bool m_got_host_env;
 };
 
 //----------------------------------------------------------------------
 // TargetProperties
 //----------------------------------------------------------------------
-static constexpr PropertyDefinition g_experimental_properties[]{
+static const 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."}};