Qualify includes of Properties[Enum].inc files. NFC

[sammccall]

Summary

This is a bit more explicit, and makes it possible to build LLDB without
varying the -I lines per-directory.
(The latter is useful because many build systems only allow this to be
configured per-library, and LLDB is insufficiently layered to be split into
multiple libraries on stricter build systems).

(My comment on D65185 has some more context)

[labath]

I am not sure about the consistency argument (on the other CL), as it seems to me that most/all llvm .inc files *which are produced by tblgen" are included by via just their bare names. However, these files generally have unique names, which is usually achieved by just embedding (a derivative of) the folder name into the .inc file name (e.g. AArch64GenAsmWriter.inc, AMDGPUGenAsmWriter.inc, ...). So, I think the most consistent approach here would be to rename lldb files into something like TargetProperties.inc, CoreProperties.inc etc.

Consistency considerations aside, I do think that having a bunch of files called Properties.inc is a bit confusing, and it would be good to disambiguate between them. I'm fairly ambivalent about whether that is achieved by prefixing the include directives with the folder name, or by renaming the files so that they have unique names.

[sammccall]

Give the files distinct names instead.

[sammccall]

Fix one straggler

[sammccall]

In D65397#1604416, @labath wrote:

I am not sure about the consistency argument (on the other CL), as it seems to me that most/all llvm .inc files *which are produced by tblgen" are included by via just their bare names. However, these files generally have unique names, which is usually achieved by just embedding (a derivative of) the folder name into the .inc file name (e.g. AArch64GenAsmWriter.inc, AMDGPUGenAsmWriter.inc, ...). So, I think the most consistent approach here would be to rename lldb files into something like TargetProperties.inc, CoreProperties.inc etc.

Consistency considerations aside, I do think that having a bunch of files called Properties.inc is a bit confusing, and it would be good to disambiguate between them. I'm fairly ambivalent about whether that is achieved by prefixing the include directives with the folder name, or by renaming the files so that they have unique names.

Fair enough, I've given them names that match the main file in that directory (thanks for pointing out this convention!).

[labath]

Thanks. This looks fine to me, and I think that the new file names fit pretty organically into the existing lldb conventions (as well as being mostly consistent with how llvm handles tablegened files).

[rupprecht]

Committed this for you as r367241, including a rebase past r367238 (which I really hope I didn't mess up -- ninja check-lldb passed, at least).

[sammccall]

Thanks @rupprecht!

[JDevlieghere]

Thanks!

lldb/trunk/source/Core/CMakeLists.txt

-lldb_tablegen(Properties.inc -gen-lldb-property-defs
-  SOURCE Properties.td
+lldb_tablegen(CoreProperties.inc -gen-lldb-property-defs
+  SOURCE CoreProperties.td
   TARGET LLDBCorePropertiesGen)
 
-lldb_tablegen(PropertiesEnum.inc -gen-lldb-property-enum-defs
-  SOURCE Properties.td
+lldb_tablegen(CorePropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE CoreProperties.td
   TARGET LLDBCorePropertiesEnumGen)
 
 set(LLDB_CURSES_LIBS)
 set(LLDB_LIBEDIT_LIBS)
 
 if (NOT LLDB_DISABLE_CURSES)
   list(APPEND LLDB_CURSES_LIBS ${CURSES_LIBRARIES})
   if(LLVM_ENABLE_TERMINFO AND HAVE_TERMINFO)

lldb/trunk/source/Core/CoreProperties.td

+include "../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "modulelist" in {
+  def EnableExternalLookup: Property<"enable-external-lookup", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"Control the use of external tools and repositories to locate symbol files. Directories listed in target.debug-file-search-paths and directory of the executable are always checked first for separate debug info files. Then depending on this setting: On macOS, Spotlight would be also used to locate a matching .dSYM bundle based on the UUID of the executable. On NetBSD, directory /usr/libdata/debug would be also searched. On platforms other than NetBSD directory /usr/lib/debug would be also searched.">;
+  def ClangModulesCachePath: Property<"clang-modules-cache-path", "FileSpec">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"The path to the clang modules cache directory (-fmodules-cache-path).">;
+}
+
+let Definition = "debugger" in {
+  def AutoConfirm: Property<"auto-confirm", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"If true all confirmation prompts will receive their default reply.">;
+  def DisassemblyFormat: Property<"disassembly-format", "FormatEntity">,
+    Global,
+    DefaultStringValue<"{${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}{ <${function.concrete-only-addr-offset-no-padding}>}: ">,
+    Desc<"The default disassembly format string to use when disassembling instruction sequences.">;
+  def FrameFormat: Property<"frame-format", "FormatEntity">,
+    Global,
+    DefaultStringValue<"frame #${frame.index}: ${ansi.fg.yellow}${frame.pc}${ansi.normal}{ ${module.file.basename}{`${function.name-with-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{${function.is-optimized} [opt]}{${frame.is-artificial} [artificial]}\\\\n">,
+    Desc<"The default frame format string to use when displaying stack frame information for threads.">;
+  def NotiftVoid: Property<"notify-void", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"Notify the user explicitly if an expression returns void (default: false).">;
+  def Prompt: Property<"prompt", "String">,
+    Global,
+    DefaultEnumValue<"OptionValueString::eOptionEncodeCharacterEscapeSequences">,
+    DefaultStringValue<"(lldb) ">,
+    Desc<"The debugger command line prompt displayed for the user.">;
+  def ScriptLanguage: Property<"script-lang", "Enum">,
+    Global,
+    DefaultEnumValue<"eScriptLanguagePython">,
+    EnumValues<"OptionEnumValues(g_language_enumerators)">,
+    Desc<"The script language to be used for evaluating user-written scripts.">;
+  def StopDisassemblyCount: Property<"stop-disassembly-count", "SInt64">,
+    Global,
+    DefaultUnsignedValue<4>,
+    Desc<"The number of disassembly lines to show when displaying a stopped context.">;
+  def StopDisassemblyDisplay: Property<"stop-disassembly-display", "Enum">,
+    Global,
+    DefaultEnumValue<"Debugger::eStopDisassemblyTypeNoDebugInfo">,
+    EnumValues<"OptionEnumValues(g_show_disassembly_enum_values)">,
+    Desc<"Control when to display disassembly when displaying a stopped context.">;
+  def StopLineCountAfter: Property<"stop-line-count-after", "SInt64">,
+    Global,
+    DefaultUnsignedValue<3>,
+    Desc<"The number of sources lines to display that come after the current source line when displaying a stopped context.">;
+  def StopLineCountBefore: Property<"stop-line-count-before", "SInt64">,
+    Global,
+    DefaultUnsignedValue<3>,
+    Desc<"The number of sources lines to display that come before the current source line when displaying a stopped context.">;
+  def HighlightSource: Property<"highlight-source", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, LLDB will highlight the displayed source code.">;
+  def StopShowColumn: Property<"stop-show-column", "Enum">,
+    DefaultEnumValue<"eStopShowColumnAnsiOrCaret">,
+    EnumValues<"OptionEnumValues(s_stop_show_column_values)">,
+    Desc<"If true, LLDB will use the column information from the debug info to mark the current position when displaying a stopped context.">;
+  def StopShowColumnAnsiPrefix: Property<"stop-show-column-ansi-prefix", "String">,
+    Global,
+    DefaultStringValue<"${ansi.underline}">,
+    Desc<"When displaying the column marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format at the immediately before the column to be marked.">;
+  def StopShowColumnAnsiSuffix: Property<"stop-show-column-ansi-suffix", "String">,
+    Global,
+    DefaultStringValue<"${ansi.normal}">,
+    Desc<"When displaying the column marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format immediately after the column to be marked.">;
+  def TerminalWidth: Property<"term-width", "SInt64">,
+    Global,
+    DefaultUnsignedValue<80>,
+    Desc<"The maximum number of columns to use for displaying text.">;
+  def ThreadFormat: Property<"thread-format", "FormatEntity">,
+    Global,
+    DefaultStringValue<"thread #${thread.index}: tid = ${thread.id%tid}{, ${frame.pc}}{ ${module.file.basename}{`${function.name-with-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{, name = ${ansi.fg.green}'${thread.name}'${ansi.normal}}{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}{, activity = ${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}{, ${thread.info.trace_messages} messages}{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}{\\\\nReturn value: ${thread.return-value}}{\\\\nCompleted expression: ${thread.completed-expression}}\\\\n">,
+    Desc<"The default thread format string to use when displaying thread information.">;
+  def ThreadStopFormat: Property<"thread-stop-format", "FormatEntity">,
+    Global,
+    DefaultStringValue<"thread #${thread.index}{, name = '${thread.name}'}{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}{, activity = ${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}{, ${thread.info.trace_messages} messages}{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}{\\\\nReturn value: ${thread.return-value}}{\\\\nCompleted expression: ${thread.completed-expression}}\\\\n">,
+    Desc<"The default thread format  string to use when displaying thread information as part of the stop display.">;
+  def UseExternalEditor: Property<"use-external-editor", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"Whether to use an external editor or not.">;
+  def UseColor: Property<"use-color", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"Whether to use Ansi color codes or not.">;
+  def AutoOneLineSummaries: Property<"auto-one-line-summaries", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, LLDB will automatically display small structs in one-liner format (default: true).">;
+  def AutoIndent: Property<"auto-indent", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, LLDB will auto indent/outdent code. Currently only supported in the REPL (default: true).">;
+  def PrintDecls: Property<"print-decls", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, LLDB will print the values of variables declared in an expression. Currently only supported in the REPL (default: true).">;
+  def TabSize: Property<"tab-size", "UInt64">,
+    Global,
+    DefaultUnsignedValue<4>,
+    Desc<"The tab size to use when indenting code in multi-line input mode (default: 4).">;
+  def EscapeNonPrintables: Property<"escape-non-printables", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, LLDB will automatically escape non-printable and escape characters when formatting strings.">;
+  def FrameFormatUnique: Property<"frame-format-unique", "FormatEntity">,
+    Global,
+    DefaultStringValue<"frame #${frame.index}: ${ansi.fg.yellow}${frame.pc}${ansi.normal}{ ${module.file.basename}{`${function.name-without-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{${function.is-optimized} [opt]}{${frame.is-artificial} [artificial]}\\\\n">,
+    Desc<"The default frame format string to use when displaying stack frameinformation for threads from thread backtrace unique.">;
+}

lldb/trunk/source/Core/Debugger.cpp

"\"caret-only\" mode was selected."},
                                   "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."}};
 
 #define LLDB_PROPERTIES_debugger
-#include "Properties.inc"
+#include "CoreProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_debugger
-#include "PropertiesEnum.inc"
+#include "CorePropertiesEnum.inc"
 };
 
 LoadPluginCallbackType Debugger::g_load_plugin_callback = nullptr;
 
 Status Debugger::SetPropertyValue(const ExecutionContext *exe_ctx,
                                   VarSetOperationType op,
                                   llvm::StringRef property_path,
                                   llvm::StringRef value) {

lldb/trunk/source/Core/ModuleList.cpp

 }
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 
 #define LLDB_PROPERTIES_modulelist
-#include "Properties.inc"
+#include "CoreProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_modulelist
-#include "PropertiesEnum.inc"
+#include "CorePropertiesEnum.inc"
 };
 
 } // namespace
 
 ModuleListProperties::ModuleListProperties() {
   m_collection_sp =
       std::make_shared<OptionValueProperties>(ConstString("symbols"));
   m_collection_sp->Initialize(g_modulelist_properties);

lldb/trunk/source/Core/Properties.td

-include "../../include/lldb/Core/PropertiesBase.td"
-
-let Definition = "modulelist" in {
-  def EnableExternalLookup: Property<"enable-external-lookup", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"Control the use of external tools and repositories to locate symbol files. Directories listed in target.debug-file-search-paths and directory of the executable are always checked first for separate debug info files. Then depending on this setting: On macOS, Spotlight would be also used to locate a matching .dSYM bundle based on the UUID of the executable. On NetBSD, directory /usr/libdata/debug would be also searched. On platforms other than NetBSD directory /usr/lib/debug would be also searched.">;
-  def ClangModulesCachePath: Property<"clang-modules-cache-path", "FileSpec">,
-    Global,
-    DefaultStringValue<"">,
-    Desc<"The path to the clang modules cache directory (-fmodules-cache-path).">;
-}
-
-let Definition = "debugger" in {
-  def AutoConfirm: Property<"auto-confirm", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"If true all confirmation prompts will receive their default reply.">;
-  def DisassemblyFormat: Property<"disassembly-format", "FormatEntity">,
-    Global,
-    DefaultStringValue<"{${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}{ <${function.concrete-only-addr-offset-no-padding}>}: ">,
-    Desc<"The default disassembly format string to use when disassembling instruction sequences.">;
-  def FrameFormat: Property<"frame-format", "FormatEntity">,
-    Global,
-    DefaultStringValue<"frame #${frame.index}: ${ansi.fg.yellow}${frame.pc}${ansi.normal}{ ${module.file.basename}{`${function.name-with-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{${function.is-optimized} [opt]}{${frame.is-artificial} [artificial]}\\\\n">,
-    Desc<"The default frame format string to use when displaying stack frame information for threads.">;
-  def NotiftVoid: Property<"notify-void", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"Notify the user explicitly if an expression returns void (default: false).">;
-  def Prompt: Property<"prompt", "String">,
-    Global,
-    DefaultEnumValue<"OptionValueString::eOptionEncodeCharacterEscapeSequences">,
-    DefaultStringValue<"(lldb) ">,
-    Desc<"The debugger command line prompt displayed for the user.">;
-  def ScriptLanguage: Property<"script-lang", "Enum">,
-    Global,
-    DefaultEnumValue<"eScriptLanguagePython">,
-    EnumValues<"OptionEnumValues(g_language_enumerators)">,
-    Desc<"The script language to be used for evaluating user-written scripts.">;
-  def StopDisassemblyCount: Property<"stop-disassembly-count", "SInt64">,
-    Global,
-    DefaultUnsignedValue<4>,
-    Desc<"The number of disassembly lines to show when displaying a stopped context.">;
-  def StopDisassemblyDisplay: Property<"stop-disassembly-display", "Enum">,
-    Global,
-    DefaultEnumValue<"Debugger::eStopDisassemblyTypeNoDebugInfo">,
-    EnumValues<"OptionEnumValues(g_show_disassembly_enum_values)">,
-    Desc<"Control when to display disassembly when displaying a stopped context.">;
-  def StopLineCountAfter: Property<"stop-line-count-after", "SInt64">,
-    Global,
-    DefaultUnsignedValue<3>,
-    Desc<"The number of sources lines to display that come after the current source line when displaying a stopped context.">;
-  def StopLineCountBefore: Property<"stop-line-count-before", "SInt64">,
-    Global,
-    DefaultUnsignedValue<3>,
-    Desc<"The number of sources lines to display that come before the current source line when displaying a stopped context.">;
-  def HighlightSource: Property<"highlight-source", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, LLDB will highlight the displayed source code.">;
-  def StopShowColumn: Property<"stop-show-column", "Enum">,
-    DefaultEnumValue<"eStopShowColumnAnsiOrCaret">,
-    EnumValues<"OptionEnumValues(s_stop_show_column_values)">,
-    Desc<"If true, LLDB will use the column information from the debug info to mark the current position when displaying a stopped context.">;
-  def StopShowColumnAnsiPrefix: Property<"stop-show-column-ansi-prefix", "String">,
-    Global,
-    DefaultStringValue<"${ansi.underline}">,
-    Desc<"When displaying the column marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format at the immediately before the column to be marked.">;
-  def StopShowColumnAnsiSuffix: Property<"stop-show-column-ansi-suffix", "String">,
-    Global,
-    DefaultStringValue<"${ansi.normal}">,
-    Desc<"When displaying the column marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format immediately after the column to be marked.">;
-  def TerminalWidth: Property<"term-width", "SInt64">,
-    Global,
-    DefaultUnsignedValue<80>,
-    Desc<"The maximum number of columns to use for displaying text.">;
-  def ThreadFormat: Property<"thread-format", "FormatEntity">,
-    Global,
-    DefaultStringValue<"thread #${thread.index}: tid = ${thread.id%tid}{, ${frame.pc}}{ ${module.file.basename}{`${function.name-with-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{, name = ${ansi.fg.green}'${thread.name}'${ansi.normal}}{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}{, activity = ${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}{, ${thread.info.trace_messages} messages}{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}{\\\\nReturn value: ${thread.return-value}}{\\\\nCompleted expression: ${thread.completed-expression}}\\\\n">,
-    Desc<"The default thread format string to use when displaying thread information.">;
-  def ThreadStopFormat: Property<"thread-stop-format", "FormatEntity">,
-    Global,
-    DefaultStringValue<"thread #${thread.index}{, name = '${thread.name}'}{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}{, activity = ${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}{, ${thread.info.trace_messages} messages}{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}{\\\\nReturn value: ${thread.return-value}}{\\\\nCompleted expression: ${thread.completed-expression}}\\\\n">,
-    Desc<"The default thread format  string to use when displaying thread information as part of the stop display.">;
-  def UseExternalEditor: Property<"use-external-editor", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"Whether to use an external editor or not.">;
-  def UseColor: Property<"use-color", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"Whether to use Ansi color codes or not.">;
-  def AutoOneLineSummaries: Property<"auto-one-line-summaries", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, LLDB will automatically display small structs in one-liner format (default: true).">;
-  def AutoIndent: Property<"auto-indent", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, LLDB will auto indent/outdent code. Currently only supported in the REPL (default: true).">;
-  def PrintDecls: Property<"print-decls", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, LLDB will print the values of variables declared in an expression. Currently only supported in the REPL (default: true).">;
-  def TabSize: Property<"tab-size", "UInt64">,
-    Global,
-    DefaultUnsignedValue<4>,
-    Desc<"The tab size to use when indenting code in multi-line input mode (default: 4).">;
-  def EscapeNonPrintables: Property<"escape-non-printables", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, LLDB will automatically escape non-printable and escape characters when formatting strings.">;
-  def FrameFormatUnique: Property<"frame-format-unique", "FormatEntity">,
-    Global,
-    DefaultStringValue<"frame #${frame.index}: ${ansi.fg.yellow}${frame.pc}${ansi.normal}{ ${module.file.basename}{`${function.name-without-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{${function.is-optimized} [opt]}{${frame.is-artificial} [artificial]}\\\\n">,
-    Desc<"The default frame format string to use when displaying stack frameinformation for threads from thread backtrace unique.">;
-}

lldb/trunk/source/Interpreter/CMakeLists.txt

-lldb_tablegen(Properties.inc -gen-lldb-property-defs
-  SOURCE Properties.td
+lldb_tablegen(InterpreterProperties.inc -gen-lldb-property-defs
+  SOURCE InterpreterProperties.td
   TARGET LLDBInterpreterPropertiesGen)
 
-lldb_tablegen(PropertiesEnum.inc -gen-lldb-property-enum-defs
-  SOURCE Properties.td
+lldb_tablegen(InterpreterPropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE InterpreterProperties.td
   TARGET LLDBInterpreterPropertiesEnumGen)
 
 add_lldb_library(lldbInterpreter
   CommandAlias.cpp
   CommandHistory.cpp
   CommandInterpreter.cpp
   CommandObject.cpp
   CommandObjectRegexCommand.cpp
add_lldb_library(lldbInterpreter
   )
 
 add_dependencies(lldbInterpreter
   LLDBInterpreterPropertiesGen
   LLDBInterpreterPropertiesEnumGen)
 
 if (NOT LLDB_DISABLE_LIBEDIT)
   target_include_directories(lldbInterpreter PRIVATE ${libedit_INCLUDE_DIRS})
-endif()
+endif()
 

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

static constexpr const char *InitFileWarning =
     "    settings set target.load-cwd-lldbinit false\n"
     "To allow lldb to source .lldbinit files in the current working "
     "directory,\n"
     "set the value of this variable to true.  Only do so if you understand "
     "and\n"
     "accept the security risk.";
 
 #define LLDB_PROPERTIES_interpreter
-#include "Properties.inc"
+#include "InterpreterProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_interpreter
-#include "PropertiesEnum.inc"
+#include "InterpreterPropertiesEnum.inc"
 };
 
 ConstString &CommandInterpreter::GetStaticBroadcasterClass() {
   static ConstString class_name("lldb.commandInterpreter");
   return class_name;
 }
 
 CommandInterpreter::CommandInterpreter(Debugger &debugger,

lldb/trunk/source/Interpreter/InterpreterProperties.td

+include "../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "interpreter" in {
+  def ExpandRegexAliases: Property<"expand-regex-aliases", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"If true, regular expression alias commands will show the expanded command that will be executed. This can be used to debug new regular expression alias commands.">;
+  def PromptOnQuit: Property<"prompt-on-quit", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"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.">;
+  def StopCmdSourceOnError: Property<"stop-command-source-on-error", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, LLDB will stop running a 'command source' script upon encountering an error.">;
+  def SpaceReplPrompts: Property<"space-repl-prompts", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"If true, blank lines will be printed between between REPL submissions.">;
+  def EchoCommands: Property<"echo-commands", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, commands will be echoed before they are evaluated.">;
+  def EchoCommentCommands: Property<"echo-comment-commands", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, commands will be echoed even if they are pure comment lines.">;
+}

lldb/trunk/source/Interpreter/Properties.td

-include "../../include/lldb/Core/PropertiesBase.td"
-
-let Definition = "interpreter" in {
-  def ExpandRegexAliases: Property<"expand-regex-aliases", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"If true, regular expression alias commands will show the expanded command that will be executed. This can be used to debug new regular expression alias commands.">;
-  def PromptOnQuit: Property<"prompt-on-quit", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"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.">;
-  def StopCmdSourceOnError: Property<"stop-command-source-on-error", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, LLDB will stop running a 'command source' script upon encountering an error.">;
-  def SpaceReplPrompts: Property<"space-repl-prompts", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"If true, blank lines will be printed between between REPL submissions.">;
-  def EchoCommands: Property<"echo-commands", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, commands will be echoed before they are evaluated.">;
-  def EchoCommentCommands: Property<"echo-comment-commands", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, commands will be echoed even if they are pure comment lines.">;
-}

lldb/trunk/source/Plugins/DynamicLoader/Darwin-Kernel/CMakeLists.txt

-lldb_tablegen(Properties.inc -gen-lldb-property-defs
-  SOURCE Properties.td
+lldb_tablegen(DynamicLoaderDarwinKernelProperties.inc -gen-lldb-property-defs
+  SOURCE DynamicLoaderDarwinKernelProperties.td
   TARGET LLDBPluginDynamicLoaderDarwinKernelPropertiesGen)
 
-lldb_tablegen(PropertiesEnum.inc -gen-lldb-property-enum-defs
-  SOURCE Properties.td
+lldb_tablegen(DynamicLoaderDarwinKernelPropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE DynamicLoaderDarwinKernelProperties.td
   TARGET LLDBPluginDynamicLoaderDarwinKernelPropertiesEnumGen)
 
 add_lldb_library(lldbPluginDynamicLoaderDarwinKernel PLUGIN
   DynamicLoaderDarwinKernel.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore

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

"Do not read memory looking for a Darwin kernel when attaching."},
                                          "(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)."}};
 
 #define LLDB_PROPERTIES_dynamicloaderdarwinkernel
-#include "Properties.inc"
+#include "DynamicLoaderDarwinKernelProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_dynamicloaderdarwinkernel
-#include "PropertiesEnum.inc"
+#include "DynamicLoaderDarwinKernelPropertiesEnum.inc"
 };
 
 class DynamicLoaderDarwinKernelProperties : public Properties {
 public:
   static ConstString &GetSettingName() {
     static ConstString g_setting_name("darwin-kernel");
     return g_setting_name;
   }

lldb/trunk/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernelProperties.td

+include "../../../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "dynamicloaderdarwinkernel" in {
+  def LoadKexts: Property<"load-kexts", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"Automatically loads kext images when attaching to a kernel.">;
+  def ScanType: Property<"scan-type", "Enum">,
+    Global,
+    DefaultEnumValue<"eKASLRScanNearPC">,
+    EnumValues<"OptionEnumValues(g_kaslr_kernel_scan_enum_values)">,
+    Desc<"Control how many reads lldb will make while searching for a Darwin kernel on attach.">;
+}

lldb/trunk/source/Plugins/DynamicLoader/Darwin-Kernel/Properties.td

-include "../../../../include/lldb/Core/PropertiesBase.td"
-
-let Definition = "dynamicloaderdarwinkernel" in {
-  def LoadKexts: Property<"load-kexts", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"Automatically loads kext images when attaching to a kernel.">;
-  def ScanType: Property<"scan-type", "Enum">,
-    Global,
-    DefaultEnumValue<"eKASLRScanNearPC">,
-    EnumValues<"OptionEnumValues(g_kaslr_kernel_scan_enum_values)">,
-    Desc<"Control how many reads lldb will make while searching for a Darwin kernel on attach.">;
-}

lldb/trunk/source/Plugins/JITLoader/GDB/CMakeLists.txt

-lldb_tablegen(Properties.inc -gen-lldb-property-defs
-  SOURCE Properties.td
+lldb_tablegen(JITLoaderGDBProperties.inc -gen-lldb-property-defs
+  SOURCE JITLoaderGDBProperties.td
   TARGET LLDBPluginJITLoaderGDBPropertiesGen)
 
-lldb_tablegen(PropertiesEnum.inc -gen-lldb-property-enum-defs
-  SOURCE Properties.td
+lldb_tablegen(JITLoaderGDBPropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE JITLoaderGDBProperties.td
   TARGET LLDBPluginJITLoaderGDBPropertiesEnumGen)
 
 add_lldb_library(lldbPluginJITLoaderGDB PLUGIN
   JITLoaderGDB.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore

lldb/trunk/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

 static constexpr OptionEnumValueElement g_enable_jit_loader_gdb_enumerators[] = {
     {eEnableJITLoaderGDBDefault, "default", "Enable JIT compilation interface "
      "for all platforms except macOS"},
     {eEnableJITLoaderGDBOn, "on", "Enable JIT compilation interface"},
     {eEnableJITLoaderGDBOff, "off", "Disable JIT compilation interface"}
  };
 
 #define LLDB_PROPERTIES_jitloadergdb
-#include "Properties.inc"
+#include "JITLoaderGDBProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_jitloadergdb
-#include "PropertiesEnum.inc"
+#include "JITLoaderGDBPropertiesEnum.inc"
   ePropertyEnableJITBreakpoint
 };
 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return JITLoaderGDB::GetPluginNameStatic();
   }

lldb/trunk/source/Plugins/JITLoader/GDB/JITLoaderGDBProperties.td

+include "../../../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "jitloadergdb" in {
+  def Enable: Property<"enable", "Enum">,
+    Global,
+    DefaultEnumValue<"eEnableJITLoaderGDBDefault">,
+    EnumValues<"OptionEnumValues(g_enable_jit_loader_gdb_enumerators)">,
+    Desc<"Enable GDB's JIT compilation interface (default: enabled on all platforms except macOS)">;
+}

lldb/trunk/source/Plugins/JITLoader/GDB/Properties.td

-include "../../../../include/lldb/Core/PropertiesBase.td"
-
-let Definition = "jitloadergdb" in {
-  def Enable: Property<"enable", "Enum">,
-    Global,
-    DefaultEnumValue<"eEnableJITLoaderGDBDefault">,
-    EnumValues<"OptionEnumValues(g_enable_jit_loader_gdb_enumerators)">,
-    Desc<"Enable GDB's JIT compilation interface (default: enabled on all platforms except macOS)">;
-}

lldb/trunk/source/Plugins/Platform/MacOSX/CMakeLists.txt

-lldb_tablegen(Properties.inc -gen-lldb-property-defs
-  SOURCE Properties.td
+lldb_tablegen(PlatformMacOSXProperties.inc -gen-lldb-property-defs
+  SOURCE PlatformMacOSXProperties.td
   TARGET LLDBPluginPlatformMacOSXPropertiesGen)
 
-lldb_tablegen(PropertiesEnum.inc -gen-lldb-property-enum-defs
-  SOURCE Properties.td
+lldb_tablegen(PlatformMacOSXPropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE PlatformMacOSXProperties.td
   TARGET LLDBPluginPlatformMacOSXPropertiesEnumGen)
 
 list(APPEND PLUGIN_PLATFORM_MACOSX_SOURCES
   PlatformDarwin.cpp
   PlatformDarwinKernel.cpp
   PlatformMacOSX.cpp
   PlatformRemoteiOS.cpp
   PlatformRemoteAppleTV.cpp

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

 
 const char *PlatformDarwinKernel::GetDescriptionStatic() {
   return "Darwin Kernel platform plug-in.";
 }
 
 /// Code to handle the PlatformDarwinKernel settings
 
 #define LLDB_PROPERTIES_platformdarwinkernel
-#include "Properties.inc"
+#include "PlatformMacOSXProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_platformdarwinkernel
-#include "PropertiesEnum.inc"
+#include "PlatformMacOSXPropertiesEnum.inc"
 };
 
 class PlatformDarwinKernelProperties : public Properties {
 public:
   static ConstString &GetSettingName() {
     static ConstString g_setting_name("darwin-kernel");
     return g_setting_name;
   }

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformMacOSXProperties.td

+include "../../../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "platformdarwinkernel" in {
+  def SearchForKexts: Property<"search-locally-for-kexts", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"Automatically search for kexts on the local system when doing kernel debugging.">;
+  def KextDirectories: Property<"kext-directories", "FileSpecList">,
+    DefaultStringValue<"">,
+    Desc<"Directories/KDKs to search for kexts in when starting a kernel debug session.">;
+}

lldb/trunk/source/Plugins/Platform/MacOSX/Properties.td

-include "../../../../include/lldb/Core/PropertiesBase.td"
-
-let Definition = "platformdarwinkernel" in {
-  def SearchForKexts: Property<"search-locally-for-kexts", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"Automatically search for kexts on the local system when doing kernel debugging.">;
-  def KextDirectories: Property<"kext-directories", "FileSpecList">,
-    DefaultStringValue<"">,
-    Desc<"Directories/KDKs to search for kexts in when starting a kernel debug session.">;
-}

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CMakeLists.txt

-lldb_tablegen(Properties.inc -gen-lldb-property-defs
-  SOURCE Properties.td
+lldb_tablegen(ProcessKDPProperties.inc -gen-lldb-property-defs
+  SOURCE ProcessKDPProperties.td
   TARGET LLDBPluginProcessMacOSXKernelPropertiesGen)
 
-lldb_tablegen(PropertiesEnum.inc -gen-lldb-property-enum-defs
-  SOURCE Properties.td
+lldb_tablegen(ProcessKDPPropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE ProcessKDPProperties.td
   TARGET LLDBPluginProcessMacOSXKernelPropertiesEnumGen)
 
 add_lldb_library(lldbPluginProcessMacOSXKernel PLUGIN
   CommunicationKDP.cpp
   ProcessKDP.cpp
   ProcessKDPLog.cpp
   RegisterContextKDP_arm.cpp
   RegisterContextKDP_arm64.cpp

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

 #include "ThreadKDP.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 
 #define LLDB_PROPERTIES_processkdp
-#include "Properties.inc"
+#include "ProcessKDPProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_processkdp
-#include "PropertiesEnum.inc"
+#include "ProcessKDPPropertiesEnum.inc"
 };
 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return ProcessKDP::GetPluginNameStatic();
   }
 

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDPProperties.td

+include "../../../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "processkdp" in {
+  def KDPPacketTimeout: Property<"packet-timeout", "UInt64">,
+    Global,
+    DefaultUnsignedValue<5>,
+    Desc<"Specify the default packet timeout in seconds.">;
+}

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/Properties.td

-include "../../../../include/lldb/Core/PropertiesBase.td"
-
-let Definition = "processkdp" in {
-  def KDPPacketTimeout: Property<"packet-timeout", "UInt64">,
-    Global,
-    DefaultUnsignedValue<5>,
-    Desc<"Specify the default packet timeout in seconds.">;
-}

lldb/trunk/source/Plugins/Process/gdb-remote/CMakeLists.txt

-lldb_tablegen(Properties.inc -gen-lldb-property-defs
-  SOURCE Properties.td
+lldb_tablegen(ProcessGDBRemoteProperties.inc -gen-lldb-property-defs
+  SOURCE ProcessGDBRemoteProperties.td
   TARGET LLDBPluginProcessGDBRemotePropertiesGen)
 
-lldb_tablegen(PropertiesEnum.inc -gen-lldb-property-enum-defs
-  SOURCE Properties.td
+lldb_tablegen(ProcessGDBRemotePropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE ProcessGDBRemoteProperties.td
   TARGET LLDBPluginProcessGDBRemotePropertiesEnumGen)
 
 if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   include_directories(${LIBXML2_INCLUDE_DIR})
 endif()
 
 set(LLDB_PLUGINS
   lldbPluginProcessUtility

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

void DumpProcessGDBRemotePacketHistory(void *p, const char *path) {
   if (error.Success())
     ((ProcessGDBRemote *)p)->GetGDBRemote().DumpHistory(strm);
 }
 } // namespace lldb
 
 namespace {
 
 #define LLDB_PROPERTIES_processgdbremote
-#include "Properties.inc"
+#include "ProcessGDBRemoteProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_processgdbremote
-#include "PropertiesEnum.inc"
+#include "ProcessGDBRemotePropertiesEnum.inc"
 };
 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return ProcessGDBRemote::GetPluginNameStatic();
   }
 

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemoteProperties.td

+include "../../../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "processgdbremote" in {
+  def PacketTimeout: Property<"packet-timeout", "UInt64">,
+    Global,
+    DefaultUnsignedValue<5>,
+    Desc<"Specify the default packet timeout in seconds.">;
+  def TargetDefinitionFile: Property<"target-definition-file", "FileSpec">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"The file that provides the description for remote target registers.">;
+  def UseSVR4: Property<"use-libraries-svr4", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"If true, the libraries-svr4 feature will be used to get a hold of the process's loaded modules.">;
+}

lldb/trunk/source/Plugins/Process/gdb-remote/Properties.td

-include "../../../../include/lldb/Core/PropertiesBase.td"
-
-let Definition = "processgdbremote" in {
-  def PacketTimeout: Property<"packet-timeout", "UInt64">,
-    Global,
-    DefaultUnsignedValue<5>,
-    Desc<"Specify the default packet timeout in seconds.">;
-  def TargetDefinitionFile: Property<"target-definition-file", "FileSpec">,
-    Global,
-    DefaultStringValue<"">,
-    Desc<"The file that provides the description for remote target registers.">;
-  def UseSVR4: Property<"use-libraries-svr4", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"If true, the libraries-svr4 feature will be used to get a hold of the process's loaded modules.">;
-}

lldb/trunk/source/Plugins/StructuredData/DarwinLog/CMakeLists.txt

-lldb_tablegen(Properties.inc -gen-lldb-property-defs
-  SOURCE Properties.td
+lldb_tablegen(StructuredDataDarwinLogProperties.inc -gen-lldb-property-defs
+  SOURCE StructuredDataDarwinLogProperties.td
   TARGET LLDBPluginStructuredDataDarwinLogPropertiesGen)
 
-lldb_tablegen(PropertiesEnum.inc -gen-lldb-property-enum-defs
-  SOURCE Properties.td
+lldb_tablegen(StructuredDataDarwinLogPropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE StructuredDataDarwinLogProperties.td
   TARGET LLDBPluginStructuredDataDarwinLogPropertiesEnumGen)
 
 add_lldb_library(lldbPluginStructuredDataDarwinLog PLUGIN
   StructuredDataDarwinLog.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbHost
     lldbInterpreter
     lldbTarget
   )
 
 add_dependencies(lldbPluginStructuredDataDarwinLog
   LLDBPluginStructuredDataDarwinLogPropertiesGen
   LLDBPluginStructuredDataDarwinLogPropertiesEnumGen)

lldb/trunk/source/Plugins/StructuredData/DarwinLog/Properties.td

-include "../../../../include/lldb/Core/PropertiesBase.td"
-
-let Definition = "darwinlog" in {
-  def EnableOnStartup: Property<"enable-on-startup", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"Enable Darwin os_log collection when debugged process is launched or attached.">;
-  def AutoEnableOptions: Property<"auto-enable-options", "String">,
-    Global,
-    DefaultStringValue<"">,
-    Desc<"Specify the options to 'plugin structured-data darwin-log enable' that should be applied when automatically enabling logging on startup/attach.">;
-}

lldb/trunk/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

 }
 
 #pragma mark -
 #pragma mark Settings Handling
 
 /// Code to handle the StructuredDataDarwinLog settings
 
 #define LLDB_PROPERTIES_darwinlog
-#include "Properties.inc"
+#include "StructuredDataDarwinLogProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_darwinlog
-#include "PropertiesEnum.inc"
+#include "StructuredDataDarwinLogPropertiesEnum.inc"
 };
 
 class StructuredDataDarwinLogProperties : public Properties {
 public:
   static ConstString &GetSettingName() {
     static ConstString g_setting_name("darwin-log");
     return g_setting_name;
   }

lldb/trunk/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLogProperties.td

+include "../../../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "darwinlog" in {
+  def EnableOnStartup: Property<"enable-on-startup", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"Enable Darwin os_log collection when debugged process is launched or attached.">;
+  def AutoEnableOptions: Property<"auto-enable-options", "String">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"Specify the options to 'plugin structured-data darwin-log enable' that should be applied when automatically enabling logging on startup/attach.">;
+}

lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt

-lldb_tablegen(Properties.inc -gen-lldb-property-defs
-  SOURCE Properties.td
+lldb_tablegen(SymbolFileDWARFProperties.inc -gen-lldb-property-defs
+  SOURCE SymbolFileDWARFProperties.td
   TARGET LLDBPluginSymbolFileDWARFPropertiesGen)
 
-lldb_tablegen(PropertiesEnum.inc -gen-lldb-property-enum-defs
-  SOURCE Properties.td
+lldb_tablegen(SymbolFileDWARFPropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE SymbolFileDWARFProperties.td
   TARGET LLDBPluginSymbolFileDWARFPropertiesEnumGen)
 
 add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
   AppleDWARFIndex.cpp
   DebugNamesDWARFIndex.cpp
   DIERef.cpp
   DWARFAbbreviationDeclaration.cpp
   DWARFASTParserClang.cpp

lldb/trunk/source/Plugins/SymbolFile/DWARF/Properties.td

-include "../../../../include/lldb/Core/PropertiesBase.td"
-
-let Definition = "symbolfiledwarf" in {
-  def SymLinkPaths: Property<"comp-dir-symlink-paths", "FileSpecList">,
-    Global,
-    DefaultStringValue<"">,
-    Desc<"If the DW_AT_comp_dir matches any of these paths the symbolic links will be resolved at DWARF parse time.">;
-  def IgnoreIndexes: Property<"ignore-file-indexes", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"Ignore indexes present in the object files and always index DWARF manually.">;
-}

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

 //    }
 //    return false;
 //}
 //
 
 namespace {
 
 #define LLDB_PROPERTIES_symbolfiledwarf
-#include "Properties.inc"
+#include "SymbolFileDWARFProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_symbolfiledwarf
-#include "PropertiesEnum.inc"
+#include "SymbolFileDWARFPropertiesEnum.inc"
 };
 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return SymbolFileDWARF::GetPluginNameStatic();
   }
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFProperties.td

+include "../../../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "symbolfiledwarf" in {
+  def SymLinkPaths: Property<"comp-dir-symlink-paths", "FileSpecList">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"If the DW_AT_comp_dir matches any of these paths the symbolic links will be resolved at DWARF parse time.">;
+  def IgnoreIndexes: Property<"ignore-file-indexes", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"Ignore indexes present in the object files and always index DWARF manually.">;
+}

lldb/trunk/source/Target/CMakeLists.txt

-lldb_tablegen(Properties.inc -gen-lldb-property-defs
-  SOURCE Properties.td
+lldb_tablegen(TargetProperties.inc -gen-lldb-property-defs
+  SOURCE TargetProperties.td
   TARGET LLDBTargetPropertiesGen)
 
-lldb_tablegen(PropertiesEnum.inc -gen-lldb-property-enum-defs
-  SOURCE Properties.td
+lldb_tablegen(TargetPropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE TargetProperties.td
   TARGET LLDBTargetPropertiesEnumGen)
 
 add_lldb_library(lldbTarget
   ABI.cpp
   ExecutionContext.cpp
   JITLoader.cpp
   JITLoaderList.cpp
   InstrumentationRuntime.cpp

lldb/trunk/source/Target/Platform.cpp

static PlatformSP &GetHostPlatformSP() {
   return g_platform_sp;
 }
 
 const char *Platform::GetHostPlatformName() { return "host"; }
 
 namespace {
 
 #define LLDB_PROPERTIES_platform
-#include "Properties.inc"
+#include "TargetProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_platform
-#include "PropertiesEnum.inc"
+#include "TargetPropertiesEnum.inc"
 };
 
 } // namespace
 
 ConstString PlatformProperties::GetSettingName() {
   static ConstString g_setting_name("platform");
   return g_setting_name;
 }

lldb/trunk/source/Target/Process.cpp

if (exe_ctx) {
           return instance_properties->ProtectedGetPropertyAtIndex(idx);
       }
     }
     return ProtectedGetPropertyAtIndex(idx);
   }
 };
 
 #define LLDB_PROPERTIES_process
-#include "Properties.inc"
+#include "TargetProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_process
-#include "PropertiesEnum.inc"
+#include "TargetPropertiesEnum.inc"
 };
 
 ProcessProperties::ProcessProperties(lldb_private::Process *process)
     : Properties(),
       m_process(process) // Can be nullptr for global ProcessProperties
 {
   if (process == nullptr) {
     // Global process properties, set them up one time

lldb/trunk/source/Target/Properties.td

-include "../../include/lldb/Core/PropertiesBase.td"
-
-let Definition = "experimental" in {
-  def InjectLocalVars : Property<"inject-local-vars", "Boolean">,
-    Global, DefaultTrue,
-    Desc<"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.">;
-  def UseModernTypeLookup : Property<"use-modern-type-lookup", "Boolean">,
-    Global, DefaultFalse,
-    Desc<"If true, use Clang's modern type lookup infrastructure.">;
-}
-
-let Definition = "target" in {
-  def DefaultArch: Property<"default-arch", "Arch">,
-    Global,
-    DefaultStringValue<"">,
-    Desc<"Default architecture to choose, when there's a choice.">;
-  def MoveToNearestCode: Property<"move-to-nearest-code", "Boolean">,
-    DefaultTrue,
-    Desc<"Move breakpoints to nearest code.">;
-  def Language: Property<"language", "Language">,
-    DefaultEnumValue<"eLanguageTypeUnknown">,
-    Desc<"The language to use when interpreting expressions entered in commands.">;
-  def ExprPrefix: Property<"expr-prefix", "FileSpec">,
-    DefaultStringValue<"">,
-    Desc<"Path to a file containing expressions to be prepended to all expressions.">;
-  def PreferDynamic: Property<"prefer-dynamic-value", "Enum">,
-    DefaultEnumValue<"eDynamicDontRunTarget">,
-    EnumValues<"OptionEnumValues(g_dynamic_value_types)">,
-    Desc<"Should printed values be shown as their dynamic value.">;
-  def EnableSynthetic: Property<"enable-synthetic-value", "Boolean">,
-    DefaultTrue,
-    Desc<"Should synthetic values be used by default whenever available.">;
-  def SkipPrologue: Property<"skip-prologue", "Boolean">,
-    DefaultTrue,
-    Desc<"Skip function prologues when setting breakpoints by name.">;
-  def SourceMap: Property<"source-map", "PathMap">,
-    DefaultStringValue<"">,
-    Desc<"Source path remappings are used to track the change of location between a source file when built, and where it exists on the current system.  It consists of an array of duples, the first element of each duple is some part (starting at the root) of the path to the file when it was built, and the second is where the remainder of the original build hierarchy is rooted on the local system.  Each element of the array is checked in order and the first one that results in a match wins.">;
-  def ExecutableSearchPaths: Property<"exec-search-paths", "FileSpecList">,
-    DefaultStringValue<"">,
-    Desc<"Executable search paths to use when locating executable files whose paths don't match the local file system.">;
-  def DebugFileSearchPaths: Property<"debug-file-search-paths", "FileSpecList">,
-    DefaultStringValue<"">,
-    Desc<"List of directories to be searched when locating debug symbol files. See also symbols.enable-external-lookup.">;
-  def ClangModuleSearchPaths: Property<"clang-module-search-paths", "FileSpecList">,
-    DefaultStringValue<"">,
-    Desc<"List of directories to be searched when locating modules for Clang.">;
-  def AutoImportClangModules: Property<"auto-import-clang-modules", "Boolean">,
-    DefaultTrue,
-    Desc<"Automatically load Clang modules referred to by the program.">;
-  def ImportStdModule: Property<"import-std-module", "Boolean">,
-    DefaultFalse,
-    Desc<"Import the C++ std module to improve debugging STL containers.">;
-  def AutoApplyFixIts: Property<"auto-apply-fixits", "Boolean">,
-    DefaultTrue,
-    Desc<"Automatically apply fix-it hints to expressions.">;
-  def NotifyAboutFixIts: Property<"notify-about-fixits", "Boolean">,
-    DefaultTrue,
-    Desc<"Print the fixed expression text.">;
-  def SaveObjects: Property<"save-jit-objects", "Boolean">,
-    DefaultFalse,
-    Desc<"Save intermediate object files generated by the LLVM JIT">;
-  def MaxChildrenCount: Property<"max-children-count", "SInt64">,
-    DefaultUnsignedValue<256>,
-    Desc<"Maximum number of children to expand in any level of depth.">;
-  def MaxSummaryLength: Property<"max-string-summary-length", "SInt64">,
-    DefaultUnsignedValue<1024>,
-    Desc<"Maximum number of characters to show when using %s in summary strings.">;
-  def MaxMemReadSize: Property<"max-memory-read-size", "SInt64">,
-    DefaultUnsignedValue<1024>,
-    Desc<"Maximum number of bytes that 'memory read' will fetch before --force must be specified.">;
-  def BreakpointUseAvoidList: Property<"breakpoints-use-platform-avoid-list", "Boolean">,
-    DefaultTrue,
-    Desc<"Consult the platform module avoid list when setting non-module specific breakpoints.">;
-  def Arg0: Property<"arg0", "String">,
-    DefaultStringValue<"">,
-    Desc<"The first argument passed to the program in the argument array which can be different from the executable itself.">;
-  def RunArgs: Property<"run-args", "Args">,
-    DefaultStringValue<"">,
-    Desc<"A list containing all the arguments to be passed to the executable when it is run. Note that this does NOT include the argv[0] which is in target.arg0.">;
-  def EnvVars: Property<"env-vars", "Dictionary">,
-    DefaultUnsignedValue<16>,
-    Desc<"A list of all the environment variables to be passed to the executable's environment, and their values.">;
-  def InheritEnv: Property<"inherit-env", "Boolean">,
-    DefaultTrue,
-    Desc<"Inherit the environment from the process that is running LLDB.">;
-  def InputPath: Property<"input-path", "FileSpec">,
-    DefaultStringValue<"">,
-    Desc<"The file/path to be used by the executable program for reading its standard input.">;
-  def OutputPath: Property<"output-path", "FileSpec">,
-    DefaultStringValue<"">,
-    Desc<"The file/path to be used by the executable program for writing its standard output.">;
-  def ErrorPath: Property<"error-path", "FileSpec">,
-    DefaultStringValue<"">,
-    Desc<"The file/path to be used by the executable program for writing its standard error.">;
-  def DetachOnError: Property<"detach-on-error", "Boolean">,
-    DefaultTrue,
-    Desc<"debugserver will detach (rather than killing) a process if it loses connection with lldb.">;
-  def PreloadSymbols: Property<"preload-symbols", "Boolean">,
-    DefaultTrue,
-    Desc<"Enable loading of symbol tables before they are needed.">;
-  def DisableASLR: Property<"disable-aslr", "Boolean">,
-    DefaultTrue,
-    Desc<"Disable Address Space Layout Randomization (ASLR)">;
-  def DisableSTDIO: Property<"disable-stdio", "Boolean">,
-    DefaultFalse,
-    Desc<"Disable stdin/stdout for process (e.g. for a GUI application)">;
-  def InlineStrategy: Property<"inline-breakpoint-strategy", "Enum">,
-    DefaultEnumValue<"eInlineBreakpointsAlways">,
-    EnumValues<"OptionEnumValues(g_inline_breakpoint_enums)">,
-    Desc<"The strategy to use when settings breakpoints by file and line. Breakpoint locations can end up being inlined by the compiler, so that a compile unit 'a.c' might contain an inlined function from another source file. Usually this is limited to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. Always checking for inlined breakpoint locations can be expensive (memory and time), so if you have a project with many headers and find that setting breakpoints is slow, then you can change this setting to headers. This setting allows you to control exactly which strategy is used when setting file and line breakpoints.">;
-  def DisassemblyFlavor: Property<"x86-disassembly-flavor", "Enum">,
-    DefaultEnumValue<"eX86DisFlavorDefault">,
-    EnumValues<"OptionEnumValues(g_x86_dis_flavor_value_types)">,
-    Desc<"The default disassembly flavor to use for x86 or x86-64 targets.">;
-  def UseHexImmediates: Property<"use-hex-immediates", "Boolean">,
-    DefaultTrue,
-    Desc<"Show immediates in disassembly as hexadecimal.">;
-  def HexImmediateStyle: Property<"hex-immediate-style", "Enum">,
-    DefaultEnumValue<"Disassembler::eHexStyleC">,
-    EnumValues<"OptionEnumValues(g_hex_immediate_style_values)">,
-    Desc<"Which style to use for printing hexadecimal disassembly values.">;
-  def UseFastStepping: Property<"use-fast-stepping", "Boolean">,
-    DefaultTrue,
-    Desc<"Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping.">;
-  def LoadScriptFromSymbolFile: Property<"load-script-from-symbol-file", "Enum">,
-    DefaultEnumValue<"eLoadScriptFromSymFileWarn">,
-    EnumValues<"OptionEnumValues(g_load_script_from_sym_file_values)">,
-    Desc<"Allow LLDB to load scripting resources embedded in symbol files when available.">;
-  def LoadCWDlldbinitFile: Property<"load-cwd-lldbinit", "Enum">,
-    DefaultEnumValue<"eLoadCWDlldbinitWarn">,
-    EnumValues<"OptionEnumValues(g_load_current_working_dir_lldbinit_values)">,
-    Desc<"Allow LLDB to .lldbinit files from the current directory automatically.">;
-  def MemoryModuleLoadLevel: Property<"memory-module-load-level", "Enum">,
-    DefaultEnumValue<"eMemoryModuleLoadLevelComplete">,
-    EnumValues<"OptionEnumValues(g_memory_module_load_level_values)">,
-    Desc<"Loading modules from memory can be slow as reading the symbol tables and other data can take a long time depending on your connection to the debug target. This setting helps users control how much information gets loaded when loading modules from memory.'complete' is the default value for this setting which will load all sections and symbols by reading them from memory (slowest, most accurate). 'partial' will load sections and attempt to find function bounds without downloading the symbol table (faster, still accurate, missing symbol names). 'minimal' is the fastest setting and will load section data with no symbols, but should rarely be used as stack frames in these memory regions will be inaccurate and not provide any context (fastest). ">;
-  def DisplayExpressionsInCrashlogs: Property<"display-expression-in-crashlogs", "Boolean">,
-    DefaultFalse,
-    Desc<"Expressions that crash will show up in crash logs if the host system supports executable specific crash log strings and this setting is set to true.">;
-  def TrapHandlerNames: Property<"trap-handler-names", "Array">,
-    Global,
-    DefaultUnsignedValue<16>,
-    Desc<"A list of trap handler function names, e.g. a common Unix user process one is _sigtramp.">;
-  def DisplayRuntimeSupportValues: Property<"display-runtime-support-values", "Boolean">,
-    DefaultFalse,
-    Desc<"If true, LLDB will show variables that are meant to support the operation of a language's runtime support.">;
-  def DisplayRecognizedArguments: Property<"display-recognized-arguments", "Boolean">,
-    DefaultFalse,
-    Desc<"Show recognized arguments in variable listings by default.">;
-  def NonStopModeEnabled: Property<"non-stop-mode", "Boolean">,
-    DefaultFalse,
-    Desc<"Disable lock-step debugging, instead control threads independently.">;
-  def RequireHardwareBreakpoints: Property<"require-hardware-breakpoint", "Boolean">,
-    DefaultFalse,
-    Desc<"Require all breakpoints to be hardware breakpoints.">;
-}
-
-let Definition = "process" in {
-  def DisableMemCache: Property<"disable-memory-cache", "Boolean">,
-    DefaultFalse,
-    Desc<"Disable reading and caching of memory in fixed-size units.">;
-  def ExtraStartCommand: Property<"extra-startup-command", "Array">,
-    DefaultUnsignedValue<16>,
-    Desc<"A list containing extra commands understood by the particular process plugin used.  For instance, to turn on debugserver logging set this to 'QSetLogging:bitmask=LOG_DEFAULT;">;
-  def IgnoreBreakpointsInExpressions: Property<"ignore-breakpoints-in-expressions", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, breakpoints will be ignored during expression evaluation.">;
-  def UnwindOnErrorInExpressions: Property<"unwind-on-error-in-expressions", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, errors in expression evaluation will unwind the stack back to the state before the call.">;
-  def PythonOSPluginPath: Property<"python-os-plugin-path", "FileSpec">,
-    DefaultUnsignedValue<1>,
-    Desc<"A path to a python OS plug-in module file that contains a OperatingSystemPlugIn class.">;
-  def StopOnSharedLibraryEvents: Property<"stop-on-sharedlibrary-events", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"If true, stop when a shared library is loaded or unloaded.">;
-  def DetachKeepsStopped: Property<"detach-keeps-stopped", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"If true, detach will attempt to keep the process stopped.">;
-  def MemCacheLineSize: Property<"memory-cache-line-size", "UInt64">,
-    DefaultUnsignedValue<512>,
-    Desc<"The memory cache line size">;
-  def WarningOptimization: Property<"optimization-warnings", "Boolean">,
-    DefaultTrue,
-    Desc<"If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected.">;
-  def StopOnExec: Property<"stop-on-exec", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, stop when a shared library is loaded or unloaded.">;
-  def UtilityExpressionTimeout: Property<"utility-expression-timeout", "UInt64">,
-    DefaultUnsignedValue<15>,
-    Desc<"The time in seconds to wait for LLDB-internal utility expressions.">;
-}
-
-let Definition = "platform" in {
-  def UseModuleCache: Property<"use-module-cache", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"Use module cache.">;
-  def ModuleCacheDirectory: Property<"module-cache-directory", "FileSpec">,
-    Global,
-    DefaultStringValue<"">,
-    Desc<"Root directory for cached modules.">;
-}
-
-let Definition = "thread" in {
-  def StepInAvoidsNoDebug: Property<"step-in-avoid-nodebug", "Boolean">,
-    Global,
-    DefaultTrue,
-    Desc<"If true, step-in will not stop in functions with no debug information.">;
-  def StepOutAvoidsNoDebug: Property<"step-out-avoid-nodebug", "Boolean">,
-    Global,
-    DefaultFalse,
-    Desc<"If true, when step-in/step-out/step-over leave the current frame, they will continue to step out till they come to a function with debug information. Passing a frame argument to step-out will override this option.">;
-  def StepAvoidRegex: Property<"step-avoid-regexp", "Regex">,
-    Global,
-    DefaultStringValue<"^std::">,
-    Desc<"A regular expression defining functions step-in won't stop in.">;
-  def StepAvoidLibraries: Property<"step-avoid-libraries", "FileSpecList">,
-    Global,
-    DefaultStringValue<"">,
-    Desc<"A list of libraries that source stepping won't stop in.">;
-  def EnableThreadTrace: Property<"trace-thread", "Boolean">,
-    DefaultFalse,
-    Desc<"If true, this thread will single-step and log execution.">;
-  def MaxBacktraceDepth: Property<"max-backtrace-depth", "UInt64">,
-    DefaultUnsignedValue<300000>,
-    Desc<"Maximum number of frames to backtrace.">;
-}

lldb/trunk/source/Target/Target.cpp

static constexpr OptionEnumValueElement g_memory_module_load_level_values[] = {
     {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."} };
 
 #define LLDB_PROPERTIES_target
-#include "Properties.inc"
+#include "TargetProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_target
-#include "PropertiesEnum.inc"
+#include "TargetPropertiesEnum.inc"
   ePropertyExperimental,
 };
 
 class TargetOptionValueProperties : public OptionValueProperties {
 public:
   TargetOptionValueProperties(ConstString name)
       : OptionValueProperties(name), m_target(nullptr), m_got_host_env(false) {}
 
void GetHostEnvironmentIfNeeded() const {
     }
   }
   Target *m_target;
   mutable bool m_got_host_env;
 };
 
 // TargetProperties
 #define LLDB_PROPERTIES_experimental
-#include "Properties.inc"
+#include "TargetProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_experimental
-#include "PropertiesEnum.inc"
+#include "TargetPropertiesEnum.inc"
 };
 
 class TargetExperimentalOptionValueProperties : public OptionValueProperties {
 public:
   TargetExperimentalOptionValueProperties()
       : OptionValueProperties(
             ConstString(Properties::GetExperimentalSettingsName())) {}
 };

lldb/trunk/source/Target/TargetProperties.td

+include "../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "experimental" in {
+  def InjectLocalVars : Property<"inject-local-vars", "Boolean">,
+    Global, DefaultTrue,
+    Desc<"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.">;
+  def UseModernTypeLookup : Property<"use-modern-type-lookup", "Boolean">,
+    Global, DefaultFalse,
+    Desc<"If true, use Clang's modern type lookup infrastructure.">;
+}
+
+let Definition = "target" in {
+  def DefaultArch: Property<"default-arch", "Arch">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"Default architecture to choose, when there's a choice.">;
+  def MoveToNearestCode: Property<"move-to-nearest-code", "Boolean">,
+    DefaultTrue,
+    Desc<"Move breakpoints to nearest code.">;
+  def Language: Property<"language", "Language">,
+    DefaultEnumValue<"eLanguageTypeUnknown">,
+    Desc<"The language to use when interpreting expressions entered in commands.">;
+  def ExprPrefix: Property<"expr-prefix", "FileSpec">,
+    DefaultStringValue<"">,
+    Desc<"Path to a file containing expressions to be prepended to all expressions.">;
+  def PreferDynamic: Property<"prefer-dynamic-value", "Enum">,
+    DefaultEnumValue<"eDynamicDontRunTarget">,
+    EnumValues<"OptionEnumValues(g_dynamic_value_types)">,
+    Desc<"Should printed values be shown as their dynamic value.">;
+  def EnableSynthetic: Property<"enable-synthetic-value", "Boolean">,
+    DefaultTrue,
+    Desc<"Should synthetic values be used by default whenever available.">;
+  def SkipPrologue: Property<"skip-prologue", "Boolean">,
+    DefaultTrue,
+    Desc<"Skip function prologues when setting breakpoints by name.">;
+  def SourceMap: Property<"source-map", "PathMap">,
+    DefaultStringValue<"">,
+    Desc<"Source path remappings are used to track the change of location between a source file when built, and where it exists on the current system.  It consists of an array of duples, the first element of each duple is some part (starting at the root) of the path to the file when it was built, and the second is where the remainder of the original build hierarchy is rooted on the local system.  Each element of the array is checked in order and the first one that results in a match wins.">;
+  def ExecutableSearchPaths: Property<"exec-search-paths", "FileSpecList">,
+    DefaultStringValue<"">,
+    Desc<"Executable search paths to use when locating executable files whose paths don't match the local file system.">;
+  def DebugFileSearchPaths: Property<"debug-file-search-paths", "FileSpecList">,
+    DefaultStringValue<"">,
+    Desc<"List of directories to be searched when locating debug symbol files. See also symbols.enable-external-lookup.">;
+  def ClangModuleSearchPaths: Property<"clang-module-search-paths", "FileSpecList">,
+    DefaultStringValue<"">,
+    Desc<"List of directories to be searched when locating modules for Clang.">;
+  def AutoImportClangModules: Property<"auto-import-clang-modules", "Boolean">,
+    DefaultTrue,
+    Desc<"Automatically load Clang modules referred to by the program.">;
+  def ImportStdModule: Property<"import-std-module", "Boolean">,
+    DefaultFalse,
+    Desc<"Import the C++ std module to improve debugging STL containers.">;
+  def AutoApplyFixIts: Property<"auto-apply-fixits", "Boolean">,
+    DefaultTrue,
+    Desc<"Automatically apply fix-it hints to expressions.">;
+  def NotifyAboutFixIts: Property<"notify-about-fixits", "Boolean">,
+    DefaultTrue,
+    Desc<"Print the fixed expression text.">;
+  def SaveObjects: Property<"save-jit-objects", "Boolean">,
+    DefaultFalse,
+    Desc<"Save intermediate object files generated by the LLVM JIT">;
+  def MaxChildrenCount: Property<"max-children-count", "SInt64">,
+    DefaultUnsignedValue<256>,
+    Desc<"Maximum number of children to expand in any level of depth.">;
+  def MaxSummaryLength: Property<"max-string-summary-length", "SInt64">,
+    DefaultUnsignedValue<1024>,
+    Desc<"Maximum number of characters to show when using %s in summary strings.">;
+  def MaxMemReadSize: Property<"max-memory-read-size", "SInt64">,
+    DefaultUnsignedValue<1024>,
+    Desc<"Maximum number of bytes that 'memory read' will fetch before --force must be specified.">;
+  def BreakpointUseAvoidList: Property<"breakpoints-use-platform-avoid-list", "Boolean">,
+    DefaultTrue,
+    Desc<"Consult the platform module avoid list when setting non-module specific breakpoints.">;
+  def Arg0: Property<"arg0", "String">,
+    DefaultStringValue<"">,
+    Desc<"The first argument passed to the program in the argument array which can be different from the executable itself.">;
+  def RunArgs: Property<"run-args", "Args">,
+    DefaultStringValue<"">,
+    Desc<"A list containing all the arguments to be passed to the executable when it is run. Note that this does NOT include the argv[0] which is in target.arg0.">;
+  def EnvVars: Property<"env-vars", "Dictionary">,
+    DefaultUnsignedValue<16>,
+    Desc<"A list of all the environment variables to be passed to the executable's environment, and their values.">;
+  def InheritEnv: Property<"inherit-env", "Boolean">,
+    DefaultTrue,
+    Desc<"Inherit the environment from the process that is running LLDB.">;
+  def InputPath: Property<"input-path", "FileSpec">,
+    DefaultStringValue<"">,
+    Desc<"The file/path to be used by the executable program for reading its standard input.">;
+  def OutputPath: Property<"output-path", "FileSpec">,
+    DefaultStringValue<"">,
+    Desc<"The file/path to be used by the executable program for writing its standard output.">;
+  def ErrorPath: Property<"error-path", "FileSpec">,
+    DefaultStringValue<"">,
+    Desc<"The file/path to be used by the executable program for writing its standard error.">;
+  def DetachOnError: Property<"detach-on-error", "Boolean">,
+    DefaultTrue,
+    Desc<"debugserver will detach (rather than killing) a process if it loses connection with lldb.">;
+  def PreloadSymbols: Property<"preload-symbols", "Boolean">,
+    DefaultTrue,
+    Desc<"Enable loading of symbol tables before they are needed.">;
+  def DisableASLR: Property<"disable-aslr", "Boolean">,
+    DefaultTrue,
+    Desc<"Disable Address Space Layout Randomization (ASLR)">;
+  def DisableSTDIO: Property<"disable-stdio", "Boolean">,
+    DefaultFalse,
+    Desc<"Disable stdin/stdout for process (e.g. for a GUI application)">;
+  def InlineStrategy: Property<"inline-breakpoint-strategy", "Enum">,
+    DefaultEnumValue<"eInlineBreakpointsAlways">,
+    EnumValues<"OptionEnumValues(g_inline_breakpoint_enums)">,
+    Desc<"The strategy to use when settings breakpoints by file and line. Breakpoint locations can end up being inlined by the compiler, so that a compile unit 'a.c' might contain an inlined function from another source file. Usually this is limited to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. Always checking for inlined breakpoint locations can be expensive (memory and time), so if you have a project with many headers and find that setting breakpoints is slow, then you can change this setting to headers. This setting allows you to control exactly which strategy is used when setting file and line breakpoints.">;
+  def DisassemblyFlavor: Property<"x86-disassembly-flavor", "Enum">,
+    DefaultEnumValue<"eX86DisFlavorDefault">,
+    EnumValues<"OptionEnumValues(g_x86_dis_flavor_value_types)">,
+    Desc<"The default disassembly flavor to use for x86 or x86-64 targets.">;
+  def UseHexImmediates: Property<"use-hex-immediates", "Boolean">,
+    DefaultTrue,
+    Desc<"Show immediates in disassembly as hexadecimal.">;
+  def HexImmediateStyle: Property<"hex-immediate-style", "Enum">,
+    DefaultEnumValue<"Disassembler::eHexStyleC">,
+    EnumValues<"OptionEnumValues(g_hex_immediate_style_values)">,
+    Desc<"Which style to use for printing hexadecimal disassembly values.">;
+  def UseFastStepping: Property<"use-fast-stepping", "Boolean">,
+    DefaultTrue,
+    Desc<"Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping.">;
+  def LoadScriptFromSymbolFile: Property<"load-script-from-symbol-file", "Enum">,
+    DefaultEnumValue<"eLoadScriptFromSymFileWarn">,
+    EnumValues<"OptionEnumValues(g_load_script_from_sym_file_values)">,
+    Desc<"Allow LLDB to load scripting resources embedded in symbol files when available.">;
+  def LoadCWDlldbinitFile: Property<"load-cwd-lldbinit", "Enum">,
+    DefaultEnumValue<"eLoadCWDlldbinitWarn">,
+    EnumValues<"OptionEnumValues(g_load_current_working_dir_lldbinit_values)">,
+    Desc<"Allow LLDB to .lldbinit files from the current directory automatically.">;
+  def MemoryModuleLoadLevel: Property<"memory-module-load-level", "Enum">,
+    DefaultEnumValue<"eMemoryModuleLoadLevelComplete">,
+    EnumValues<"OptionEnumValues(g_memory_module_load_level_values)">,
+    Desc<"Loading modules from memory can be slow as reading the symbol tables and other data can take a long time depending on your connection to the debug target. This setting helps users control how much information gets loaded when loading modules from memory.'complete' is the default value for this setting which will load all sections and symbols by reading them from memory (slowest, most accurate). 'partial' will load sections and attempt to find function bounds without downloading the symbol table (faster, still accurate, missing symbol names). 'minimal' is the fastest setting and will load section data with no symbols, but should rarely be used as stack frames in these memory regions will be inaccurate and not provide any context (fastest). ">;
+  def DisplayExpressionsInCrashlogs: Property<"display-expression-in-crashlogs", "Boolean">,
+    DefaultFalse,
+    Desc<"Expressions that crash will show up in crash logs if the host system supports executable specific crash log strings and this setting is set to true.">;
+  def TrapHandlerNames: Property<"trap-handler-names", "Array">,
+    Global,
+    DefaultUnsignedValue<16>,
+    Desc<"A list of trap handler function names, e.g. a common Unix user process one is _sigtramp.">;
+  def DisplayRuntimeSupportValues: Property<"display-runtime-support-values", "Boolean">,
+    DefaultFalse,
+    Desc<"If true, LLDB will show variables that are meant to support the operation of a language's runtime support.">;
+  def DisplayRecognizedArguments: Property<"display-recognized-arguments", "Boolean">,
+    DefaultFalse,
+    Desc<"Show recognized arguments in variable listings by default.">;
+  def NonStopModeEnabled: Property<"non-stop-mode", "Boolean">,
+    DefaultFalse,
+    Desc<"Disable lock-step debugging, instead control threads independently.">;
+  def RequireHardwareBreakpoints: Property<"require-hardware-breakpoint", "Boolean">,
+    DefaultFalse,
+    Desc<"Require all breakpoints to be hardware breakpoints.">;
+}
+
+let Definition = "process" in {
+  def DisableMemCache: Property<"disable-memory-cache", "Boolean">,
+    DefaultFalse,
+    Desc<"Disable reading and caching of memory in fixed-size units.">;
+  def ExtraStartCommand: Property<"extra-startup-command", "Array">,
+    DefaultUnsignedValue<16>,
+    Desc<"A list containing extra commands understood by the particular process plugin used.  For instance, to turn on debugserver logging set this to 'QSetLogging:bitmask=LOG_DEFAULT;">;
+  def IgnoreBreakpointsInExpressions: Property<"ignore-breakpoints-in-expressions", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, breakpoints will be ignored during expression evaluation.">;
+  def UnwindOnErrorInExpressions: Property<"unwind-on-error-in-expressions", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, errors in expression evaluation will unwind the stack back to the state before the call.">;
+  def PythonOSPluginPath: Property<"python-os-plugin-path", "FileSpec">,
+    DefaultUnsignedValue<1>,
+    Desc<"A path to a python OS plug-in module file that contains a OperatingSystemPlugIn class.">;
+  def StopOnSharedLibraryEvents: Property<"stop-on-sharedlibrary-events", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"If true, stop when a shared library is loaded or unloaded.">;
+  def DetachKeepsStopped: Property<"detach-keeps-stopped", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"If true, detach will attempt to keep the process stopped.">;
+  def MemCacheLineSize: Property<"memory-cache-line-size", "UInt64">,
+    DefaultUnsignedValue<512>,
+    Desc<"The memory cache line size">;
+  def WarningOptimization: Property<"optimization-warnings", "Boolean">,
+    DefaultTrue,
+    Desc<"If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected.">;
+  def StopOnExec: Property<"stop-on-exec", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, stop when a shared library is loaded or unloaded.">;
+  def UtilityExpressionTimeout: Property<"utility-expression-timeout", "UInt64">,
+    DefaultUnsignedValue<15>,
+    Desc<"The time in seconds to wait for LLDB-internal utility expressions.">;
+}
+
+let Definition = "platform" in {
+  def UseModuleCache: Property<"use-module-cache", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"Use module cache.">;
+  def ModuleCacheDirectory: Property<"module-cache-directory", "FileSpec">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"Root directory for cached modules.">;
+}
+
+let Definition = "thread" in {
+  def StepInAvoidsNoDebug: Property<"step-in-avoid-nodebug", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"If true, step-in will not stop in functions with no debug information.">;
+  def StepOutAvoidsNoDebug: Property<"step-out-avoid-nodebug", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"If true, when step-in/step-out/step-over leave the current frame, they will continue to step out till they come to a function with debug information. Passing a frame argument to step-out will override this option.">;
+  def StepAvoidRegex: Property<"step-avoid-regexp", "Regex">,
+    Global,
+    DefaultStringValue<"^std::">,
+    Desc<"A regular expression defining functions step-in won't stop in.">;
+  def StepAvoidLibraries: Property<"step-avoid-libraries", "FileSpecList">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"A list of libraries that source stepping won't stop in.">;
+  def EnableThreadTrace: Property<"trace-thread", "Boolean">,
+    DefaultFalse,
+    Desc<"If true, this thread will single-step and log execution.">;
+  def MaxBacktraceDepth: Property<"max-backtrace-depth", "UInt64">,
+    DefaultUnsignedValue<300000>,
+    Desc<"Maximum number of frames to backtrace.">;
+}

lldb/trunk/source/Target/Thread.cpp

const ThreadPropertiesSP &Thread::GetGlobalProperties() {
   // NOTE: intentional leak so we don't crash if global destructor chain gets
   // called as other threads still use the result of this function
   static ThreadPropertiesSP *g_settings_sp_ptr =
       new ThreadPropertiesSP(new ThreadProperties(true));
   return *g_settings_sp_ptr;
 }
 
 #define LLDB_PROPERTIES_thread
-#include "Properties.inc"
+#include "TargetProperties.inc"
 
 enum {
 #define LLDB_PROPERTIES_thread
-#include "PropertiesEnum.inc"
+#include "TargetPropertiesEnum.inc"
 };
 
 class ThreadOptionValueProperties : public OptionValueProperties {
 public:
   ThreadOptionValueProperties(ConstString name)
       : OptionValueProperties(name) {}
 
   // This constructor is used when creating ThreadOptionValueProperties when it