[lldb] Make short options mandatory for all options

[teemperor]

Summary

LLDB identifies all command options via their short option character (e.g. 'c' for the '-c' option).
We have 3 options that apparently don't have a short option and only a long option, so for
those we are using 4 chars that we store in an int and identify the option based on that.
This also the reason why we store the short option character as an int in most of the code
as we might also have one of those 4-character strings packed inside an integer.

It doesn't seem that really works as we apparently not all code is aware that the character is
sometimes also a 4-byte string, so that's why we have these random short options sometimes:

(lldb) target var -
Available completions:
	-e -- A basename or fullpath to a file that contains global variables. This option can be specified multiple times.
	-b -- A basename or fullpath to a shared library to use in the search for global variables. This option can be specified multiple times.

The e and b are actually just the truncated last part of this 4-byte strings file and shlb that were used for these options.
These two short options also appear to be not usable:

(lldb) target variable -e asdf
error: invalid option with value '101'

We could fix this, but this patch is instead just giving the three options a short character and removes the whole
'4-byte strings in an int' from the code base. We anyway have a few places where people accidentially used 'char'
to store the value, and that silently transforms these options into the short option of the last character ('file' -> '-e').

The added short options are:
target variable --file -> -l (F and f were already occupied).
target variable --shlib -> -S (s was already occupied)
Some commands such as memory read have a --append-outfile option, which is now aliased to -a.

[teemperor]

You can Ctrl+F for SHORT_OPTION_ to see the changes to the changed short options (beside all the int -> char replacement).

[teemperor]

Actually the char changes related to val aren't in scope for this patch, I should remove those.

[labath]

Well... I'd say this is a step in the wrong direction. :(

Some of our commands are very baroque, and finding a meaningful short letter for their options can be really hard. target variable --file is actually a very good example for that, but there are more (e.g. the minidump dumping options).

I think we should just accept the fact that some options are just not important enough to deserve a short form -- all they would do is prevent that letter to be taken by some other, perhaps more useful, option. And it's easier to add a short option (if the option turns out to be useful) than it is to remove/change it. Also, tab completion makes it less important to have a very short way to spell something.

I'd much rather move in the other direction, actually. :) I.e., try to incentivise people to *not* add short form for every new option they come up with. Currently, the way to avoid a short option is really unobvious and most people are unaware of it. The fact that we use short letters to identify options is to blame. This is a consequence of us using getopt, but it's not even an inherent getopt thing -- it supports other ways to signal that a long option was parsed besides returning a character (int). It's just that we chose not to use that. In any case, the fact that we have a getopt wrapper means that we can hide all of this stuff, and present any interface we want...

For now though, I'd just settle for fixing the short option bug at hand. I am not particularly troubled by the fact that some code holds these options as chars. The generic code needs to be aware of the ints, of course, but this can be ensured by proper tests. And for the option-specific code, they only need to care about this if they actually make use of the functionality....

lldb/include/lldb/Interpreter/OptionGroupFile.h

 
 namespace lldb_private {
 
 // OptionGroupFile
 
 class OptionGroupFile : public OptionGroup {
 public:
   OptionGroupFile(uint32_t usage_mask, bool required, const char *long_option,
-                  int short_option, uint32_t completion_type,
+                  char short_option, uint32_t completion_type,
                   lldb::CommandArgumentType argument_type,
                   const char *usage_text);
 
   ~OptionGroupFile() override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }

lldb/include/lldb/Utility/OptionDefinition.h

 struct OptionDefinition {
   /// Used to mark options that can be used together.  If
   /// `(1 << n & usage_mask) != 0` then this option belongs to option set n.
   uint32_t usage_mask;
   /// This option is required (in the current usage level).
   bool required;
   /// Full name for this option.
   const char *long_option;
-  /// Single character for this option. If the option doesn't use a short
-  /// option character, this has to be a integer value that is not a printable
-  /// ASCII code point and also unique in the used set of options.
-  /// @see OptionDefinition::HasShortOption
-  int short_option;
+  /// Single character for this option.
+  char short_option;
   /// no_argument, required_argument or optional_argument
   int option_has_arg;
   /// If non-NULL, option is valid iff |validator->IsValid()|, otherwise
   /// always valid.
   OptionValidator *validator;
   /// If not empty, an array of enum values.
   OptionEnumValues enum_values;
   /// The kind of completion for this option.
   /// Contains values of the CommandCompletions::CommonCompletionTypes enum.
   uint32_t completion_type;
   /// Type of argument this option takes.
   lldb::CommandArgumentType argument_type;
   /// Full text explaining what this options does and what (if any) argument to
   /// pass it.
   const char *usage_text;
-
-  /// Whether this has a short option character.
-  bool HasShortOption() const {
-    // See the short_option documentation for more.
-    return llvm::isPrint(short_option);
-  }
 };
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_OPTIONDEFINITION_H

lldb/source/Commands/CommandObjectBreakpoint.cpp

public:
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_breakpoint_modify_options);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                         ExecutionContext *execution_context) override {
     Status error;
-    const int short_option =
+    const char short_option =
         g_breakpoint_modify_options[option_idx].short_option;
 
     switch (short_option) {
     case 'c':
       // Normally an empty breakpoint condition marks is as unset. But we need
       // to say it was passed in.
       m_bp_opts.SetCondition(option_arg.str().c_str());
       m_bp_opts.m_set_flags.Set(BreakpointOptions::eCondition);
public:
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_breakpoint_dummy_options);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                         ExecutionContext *execution_context) override {
     Status error;
-    const int short_option =
+    const char short_option =
         g_breakpoint_dummy_options[option_idx].short_option;
 
     switch (short_option) {
     case 'D':
       m_use_dummy = true;
       break;
     default:
       llvm_unreachable("Unimplemented option");
CommandOptions()
           m_skip_prologue(eLazyBoolCalculate), m_all_files(false),
           m_move_to_nearest_code(eLazyBoolCalculate) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option =
+      const char short_option =
           g_breakpoint_set_options[option_idx].short_option;
 
       switch (short_option) {
       case 'a': {
         m_load_addr = OptionArgParser::ToAddress(execution_context, option_arg,
                                                  LLDB_INVALID_ADDRESS, &error);
       } break;
 
CommandOptions()
         : Options(), m_level(lldb::eDescriptionLevelBrief), m_use_dummy(false) {
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'b':
         m_level = lldb::eDescriptionLevelBrief;
         break;
       case 'D':
         m_use_dummy = true;
         break;
public:
   public:
     CommandOptions() : Options(), m_filename(), m_line_num(0) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_filename.assign(std::string(option_arg));
         break;
 
       case 'l':
         option_arg.getAsInteger(0, m_line_num);
public:
     CommandOptions() : Options(), m_use_dummy(false), m_force(false),
       m_delete_disabled(false) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_force = true;
         break;
 
       case 'D':
         m_use_dummy = true;
public:
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_breakpoint_name_options);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                         ExecutionContext *execution_context) override {
     Status error;
-    const int short_option = g_breakpoint_name_options[option_idx].short_option;
+    const char short_option = g_breakpoint_name_options[option_idx].short_option;
 
     switch (short_option) {
     case 'N':
       if (BreakpointID::StringIsBreakpointName(option_arg, error) &&
           error.Success())
         m_name.SetValueFromString(option_arg);
       break;
     case 'B':
public:
   ~BreakpointAccessOptionGroup() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_breakpoint_access_options);
   }
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                         ExecutionContext *execution_context) override {
     Status error;
-    const int short_option =
+    const char short_option =
         g_breakpoint_access_options[option_idx].short_option;
 
     switch (short_option) {
     case 'L': {
       bool value, success;
       value = OptionArgParser::ToBoolean(option_arg, false, &success);
       if (success) {
         m_permissions.SetAllowList(value);
public:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_filename.assign(std::string(option_arg));
         break;
       case 'N': {
         Status name_error;
         if (!BreakpointID::StringIsBreakpointName(llvm::StringRef(option_arg),
public:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_filename.assign(std::string(option_arg));
         break;
       case 'a':
         m_append = true;
         break;

lldb/source/Commands/CommandObjectBreakpointCommand.cpp

CommandOptions()
           m_script_language(eScriptLanguageNone), m_use_one_liner(false),
           m_one_liner() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option =
+      const char short_option =
           g_breakpoint_command_add_options[option_idx].short_option;
 
       switch (short_option) {
       case 'o':
         m_use_one_liner = true;
         m_one_liner = std::string(option_arg);
         break;
 
public:
   public:
     CommandOptions() : Options(), m_use_dummy(false) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'D':
         m_use_dummy = true;
         break;
 
       default:
         llvm_unreachable("Unimplemented option");

lldb/source/Commands/CommandObjectCommands.cpp

CommandOptions()
         : Options(), m_stop_on_error(true), m_silent_run(false),
           m_stop_on_continue(true) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'e':
         error = m_stop_on_error.SetValueFromString(option_arg);
         break;
 
       case 'c':
         error = m_stop_on_continue.SetValueFromString(option_arg);
public:
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_alias_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                           ExecutionContext *execution_context) override {
       Status error;
 
-      const int short_option = GetDefinitions()[option_idx].short_option;
+      const char short_option = GetDefinitions()[option_idx].short_option;
       std::string option_str(option_value);
 
       switch (short_option) {
       case 'h':
         m_help.SetCurrentValue(option_str);
         m_help.SetOptionWasSet();
         break;
 
private:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'h':
         m_help.assign(std::string(option_arg));
         break;
       case 's':
         m_syntax.assign(std::string(option_arg));
         break;
protected:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'r':
         // NO-OP
         break;
       case 'c':
         relative_to_command_file = true;
         break;
CommandOptions()
         : Options(), m_class_name(), m_funct_name(), m_short_help(),
           m_synchronicity(eScriptedCommandSynchronicitySynchronous) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         if (!option_arg.empty())
           m_funct_name = std::string(option_arg);
         break;
       case 'c':
         if (!option_arg.empty())

lldb/source/Commands/CommandObjectDisassemble.cpp

 
 CommandObjectDisassemble::CommandOptions::~CommandOptions() = default;
 
 Status CommandObjectDisassemble::CommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
 
-  const int short_option = m_getopt_table[option_idx].val;
+  const char short_option = m_getopt_table[option_idx].val;
 
   switch (short_option) {
   case 'm':
     show_mixed = true;
     break;
 
   case 'C':
     if (option_arg.getAsInteger(0, num_lines_context))

lldb/source/Commands/CommandObjectExpression.cpp

 #define LLDB_OPTIONS_expression
 #include "CommandOptions.inc"
 
 Status CommandObjectExpression::CommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
 
-  const int short_option = GetDefinitions()[option_idx].short_option;
+  const char short_option = GetDefinitions()[option_idx].short_option;
 
   switch (short_option) {
   case 'l':
     language = Language::GetLanguageTypeFromString(option_arg);
     if (language == eLanguageTypeUnknown)
       error.SetErrorStringWithFormat(
           "unknown language type: '%s' for expression",
           option_arg.str().c_str());

lldb/source/Commands/CommandObjectFrame.cpp

public:
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       switch (short_option) {
       case 'r':
         reg = ConstString(option_arg);
         break;
 
       case 'a': {
         address.emplace();
         if (option_arg.getAsInteger(0, *address)) {
public:
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       switch (short_option) {
       case 'r': {
         int32_t offset = 0;
         if (option_arg.getAsInteger(0, offset) || offset == INT32_MIN) {
           error.SetErrorStringWithFormat("invalid frame offset argument '%s'",
                                          option_arg.str().c_str());
         } else
           relative_frame_offset = offset;
private:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'l':
         m_class_name = std::string(option_arg);
         break;
       case 's':
         m_module = std::string(option_arg);
         break;

lldb/source/Commands/CommandObjectHelp.h

public:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override {}
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'a':
         m_show_aliases = false;
         break;
       case 'u':
         m_show_user_defined = false;
         break;

lldb/source/Commands/CommandObjectLog.cpp

public:
   public:
     CommandOptions() : Options(), log_file(), log_options(0) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         log_file.SetFile(option_arg, FileSpec::Style::native);
         FileSystem::Instance().Resolve(log_file);
         break;
       case 't':
         log_options |= LLDB_LOG_OPTION_THREADSAFE;

lldb/source/Commands/CommandObjectMemory.cpp

public:
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_memory_read_options);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                         ExecutionContext *execution_context) override {
     Status error;
-    const int short_option = g_memory_read_options[option_idx].short_option;
+    const char short_option = g_memory_read_options[option_idx].short_option;
 
     switch (short_option) {
     case 'l':
       error = m_num_per_line.SetValueFromString(option_value);
       if (m_num_per_line.GetCurrentValue() == 0)
         error.SetErrorStringWithFormat(
             "invalid value for --num-per-line option '%s'",
             option_value.str().c_str());
public:
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_memory_find_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = g_memory_find_options[option_idx].short_option;
+      const char short_option = g_memory_find_options[option_idx].short_option;
 
       switch (short_option) {
       case 'e':
         m_expr.SetValueFromString(option_value);
         break;
 
       case 's':
         m_string.SetValueFromString(option_value);
public:
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_memory_write_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = g_memory_write_options[option_idx].short_option;
+      const char short_option = g_memory_write_options[option_idx].short_option;
 
       switch (short_option) {
       case 'i':
         m_infile.SetFile(option_value, FileSpec::Style::native);
         FileSystem::Instance().Resolve(m_infile);
         if (!FileSystem::Instance().Exists(m_infile)) {
           m_infile.Clear();
           error.SetErrorStringWithFormat("input file does not exist: '%s'",

lldb/source/Commands/CommandObjectPlatform.cpp

public:
   OptionPermissions() {}
 
   ~OptionPermissions() override = default;
 
   lldb_private::Status
   SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                  ExecutionContext *execution_context) override {
     Status error;
-    char short_option = (char)GetDefinitions()[option_idx].short_option;
+    char short_option = GetDefinitions()[option_idx].short_option;
     switch (short_option) {
     case 'v': {
       if (option_arg.getAsInteger(8, m_permissions)) {
         m_permissions = 0777;
         error.SetErrorStringWithFormat("invalid value for permissions: %s",
                                        option_arg.str().c_str());
       }
 
public:
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_platform_shell_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
 
-      const char short_option = (char)GetDefinitions()[option_idx].short_option;
+      const char short_option = GetDefinitions()[option_idx].short_option;
 
       switch (short_option) {
       case 'h':
         m_use_host_platform = true;
         break;
       case 't':
         uint32_t timeout_sec;
         if (option_arg.getAsInteger(10, timeout_sec))

lldb/source/Commands/CommandObjectProcess.cpp

CommandOptions() : Options() {
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       switch (short_option) {
       case 'c':
         attach_info.SetContinueOnceAttached(true);
         break;
 
       case 'p': {
         lldb::pid_t pid;
         if (option_arg.getAsInteger(0, pid)) {
CommandOptions() : Options() {
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       switch (short_option) {
       case 'i':
         if (option_arg.getAsInteger(0, m_ignore))
           error.SetErrorStringWithFormat(
               "invalid value for ignore option: \"%s\", should be a number.",
               option_arg.str().c_str());
         break;
 
public:
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 's':
         bool tmp_result;
         bool success;
         tmp_result = OptionArgParser::ToBoolean(option_arg, false, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid boolean option: \"%s\"",
CommandOptions() : Options() {
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'p':
         plugin_name.assign(std::string(option_arg));
         break;
 
       default:
         llvm_unreachable("Unimplemented option");
CommandOptions() : Options() {
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       switch (short_option) {
       case 'i':
         do_install = true;
         if (!option_arg.empty())
           install_path.SetFile(option_arg, FileSpec::Style::native);
         break;
       default:
         llvm_unreachable("Unimplemented option");
public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options(), m_verbose(false) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'v':
         m_verbose = true;
         break;
       default:
         llvm_unreachable("Unimplemented option");
       }
public:
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 's':
         stop = std::string(option_arg);
         break;
       case 'n':
         notify = std::string(option_arg);
         break;

lldb/source/Commands/CommandObjectRegister.cpp

void OptionParsingStarting(ExecutionContext *execution_context) override {
       set_indexes.Clear();
       dump_all_sets.Clear();
       alternate_name.Clear();
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = GetDefinitions()[option_idx].short_option;
+      const char short_option = GetDefinitions()[option_idx].short_option;
       switch (short_option) {
       case 's': {
         OptionValueSP value_sp(OptionValueUInt64::Create(option_value, error));
         if (value_sp)
           set_indexes.AppendValue(value_sp);
       } break;
 
       case 'a':

lldb/source/Commands/CommandObjectReproducer.cpp

public:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 's':
         signal = (ReproducerCrashSignal)OptionArgParser::ToOptionEnum(
             option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
         if (!error.Success())
           error.SetErrorStringWithFormat("unrecognized value for signal '%s'",
                                          option_arg.str().c_str());
public:
   public:
     CommandOptions() : Options(), file() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         file.SetFile(option_arg, FileSpec::Style::native);
         FileSystem::Instance().Resolve(file);
         break;
       case 'p':
         provider = (ReproducerProvider)OptionArgParser::ToOptionEnum(
public:
   public:
     CommandOptions() : Options(), file() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         file.SetFile(option_arg, FileSpec::Style::native);
         FileSystem::Instance().Resolve(file);
         break;
       default:
         llvm_unreachable("Unimplemented option");

lldb/source/Commands/CommandObjectScript.cpp

 
 #define LLDB_OPTIONS_script
 #include "CommandOptions.inc"
 
 Status CommandObjectScript::CommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
-  const int short_option = m_getopt_table[option_idx].val;
+  const char short_option = m_getopt_table[option_idx].val;
 
   switch (short_option) {
   case 'l':
     language = (lldb::ScriptLanguage)OptionArgParser::ToOptionEnum(
         option_arg, GetDefinitions()[option_idx].enum_values,
         eScriptLanguageNone, error);
     if (!error.Success())
       error.SetErrorStringWithFormat("unrecognized value for language '%s'",

lldb/source/Commands/CommandObjectSession.cpp

CommandOptions()
         : Options(), m_start_idx(0), m_stop_idx(0), m_count(0), m_clear(false) {
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'c':
         error = m_count.SetValueFromString(option_arg, eVarSetOperationAssign);
         break;
       case 's':
         if (option_arg == "end") {
           m_start_idx.SetCurrentValue(UINT64_MAX);

lldb/source/Commands/CommandObjectSettings.cpp

insert-before or insert-after.");
   public:
     CommandOptions() : Options(), m_global(false) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_force = true;
         break;
       case 'g':
         m_global = true;
         break;
public:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_filename.assign(std::string(option_arg));
         break;
       case 'a':
         m_append = true;
         break;
public:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_filename.assign(std::string(option_arg));
         break;
       default:
         llvm_unreachable("Unimplemented option");
       }
public:
   class CommandOptions : public Options {
   public:
     CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       switch (short_option) {
       case 'a':
         m_clear_all = true;
         break;
       default:
         llvm_unreachable("Unimplemented option");
       }
       return Status();

lldb/source/Commands/CommandObjectSource.cpp

class CommandObjectSourceInfo : public CommandObjectParsed {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = GetDefinitions()[option_idx].short_option;
+      const char short_option = GetDefinitions()[option_idx].short_option;
       switch (short_option) {
       case 'l':
         if (option_arg.getAsInteger(0, start_line))
           error.SetErrorStringWithFormat("invalid line number: '%s'",
                                          option_arg.str().c_str());
         break;
 
       case 'e':
class CommandObjectSourceList : public CommandObjectParsed {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = GetDefinitions()[option_idx].short_option;
+      const char short_option = GetDefinitions()[option_idx].short_option;
       switch (short_option) {
       case 'l':
         if (option_arg.getAsInteger(0, start_line))
           error.SetErrorStringWithFormat("invalid line number: '%s'",
                                          option_arg.str().c_str());
         break;
 
       case 'c':

lldb/source/Commands/CommandObjectTarget.cpp

bool DoExecute(Args &args, CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectTargetVariable
 
 class CommandObjectTargetVariable : public CommandObjectParsed {
-  static const uint32_t SHORT_OPTION_FILE = 0x66696c65; // 'file'
-  static const uint32_t SHORT_OPTION_SHLB = 0x73686c62; // 'shlb'
-
 public:
   CommandObjectTargetVariable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target variable",
                             "Read global variables for the current target, "
                             "before or while running a process.",
                             nullptr, eCommandRequiresTarget),
         m_option_group(),
         m_option_variable(false), // Don't include frame options
         m_option_format(eFormatDefault),
-        m_option_compile_units(LLDB_OPT_SET_1, false, "file", SHORT_OPTION_FILE,
+        m_option_compile_units(LLDB_OPT_SET_1, false, "file", 'l',
                                0, eArgTypeFilename,
                                "A basename or fullpath to a file that contains "
                                "global variables. This option can be "
                                "specified multiple times."),
         m_option_shared_libraries(
-            LLDB_OPT_SET_1, false, "shlib", SHORT_OPTION_SHLB, 0,
+            LLDB_OPT_SET_1, false, "shlib", 'S', 0,
             eArgTypeFilename,
             "A basename or fullpath to a shared library to use in the search "
             "for global "
             "variables. This option can be specified multiple times."),
         m_varobj_options() {
     CommandArgumentEntry arg;
     CommandArgumentData var_name_arg;
 
public:
   public:
     CommandOptions() : Options(), m_sort_order(eSortOrderNone) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'm':
         m_prefer_mangled.SetCurrentValue(true);
         m_prefer_mangled.SetOptionWasSet();
         break;
 
       case 's':
CommandOptions()
           m_module_addr(LLDB_INVALID_ADDRESS) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
 
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       if (short_option == 'g') {
         m_use_global_module_list = true;
       } else if (short_option == 'a') {
         m_module_addr = OptionArgParser::ToAddress(
             execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
       } else {
         unsigned long width = 0;
         option_arg.getAsInteger(0, width);
CommandOptions()
           m_addr(LLDB_INVALID_ADDRESS) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
 
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'a': {
         m_str = std::string(option_arg);
         m_type = eLookupTypeAddress;
         m_addr = OptionArgParser::ToAddress(execution_context, option_arg,
                                             LLDB_INVALID_ADDRESS, &error);
         if (m_addr == LLDB_INVALID_ADDRESS)
public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
 
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'a': {
         m_type = eLookupTypeAddress;
         m_addr = OptionArgParser::ToAddress(execution_context, option_arg,
                                             LLDB_INVALID_ADDRESS, &error);
       } break;
 
public:
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_target_stop_hook_add_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option =
+      const char short_option =
           g_target_stop_hook_add_options[option_idx].short_option;
 
       switch (short_option) {
       case 'c':
         m_class_name = std::string(option_arg);
         m_sym_ctx_specified = true;
         break;
 

lldb/source/Commands/CommandObjectThread.cpp

CommandOptions() : Options() {
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'c': {
         int32_t input_count = 0;
         if (option_arg.getAsInteger(0, m_count)) {
           m_count = UINT32_MAX;
           error.SetErrorStringWithFormat(
               "invalid integer value for option '%c'", short_option);
public:
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_thread_step_scope_options);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                         ExecutionContext *execution_context) override {
     Status error;
-    const int short_option =
+    const char short_option =
         g_thread_step_scope_options[option_idx].short_option;
 
     switch (short_option) {
     case 'a': {
       bool success;
       bool avoid_no_debug =
           OptionArgParser::ToBoolean(option_arg, true, &success);
       if (!success)
CommandOptions()
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'a': {
         lldb::addr_t tmp_addr = OptionArgParser::ToAddress(
             execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
         if (error.Success())
           m_until_addrs.push_back(tmp_addr);
       } break;
public:
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_json_thread = false;
       m_json_stopinfo = false;
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       Status error;
 
       switch (short_option) {
       case 'j':
         m_json_thread = true;
         break;
 
       case 's':
CommandOptions() : Options(), m_from_expression(false) {
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'x': {
         bool success;
         bool tmp_value =
             OptionArgParser::ToBoolean(option_arg, false, &success);
         if (success)
           m_from_expression = tmp_value;
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_line_num = 0;
       m_line_offset = 0;
       m_load_addr = LLDB_INVALID_ADDRESS;
       m_force = false;
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       Status error;
 
       switch (short_option) {
       case 'f':
         m_filenames.AppendIfUnique(FileSpec(option_arg));
         if (m_filenames.GetSize() > 1)
           return Status("only one source file expected.");
         break;
CommandOptions() : Options() {
       // ()
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'i':
         m_internal = true;
         break;
       case 't':
         lldb::tid_t tid;
         if (option_arg.getAsInteger(0, tid))
public:
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'c': {
         int32_t count;
         if (option_arg.empty() || option_arg.getAsInteger(0, count) ||
             count < 0)
           error.SetErrorStringWithFormat(
               "invalid integer value for option '%s'",

lldb/source/Commands/CommandObjectTrace.cpp

public:
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'v': {
         m_verbose = true;
         break;
       }
       default:
         llvm_unreachable("Unimplemented option");
public:
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'v': {
         m_verbose = true;
         break;
       }
       default:
         llvm_unreachable("Unimplemented option");
public:
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'v': {
         m_verbose = true;
         break;
       }
       default:
         llvm_unreachable("Unimplemented option");

lldb/source/Commands/CommandObjectType.cpp

private:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       bool success;
 
       switch (short_option) {
       case 'C':
         m_cascade = OptionArgParser::ToBoolean(option_arg, true, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                          option_arg.str().c_str());
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_regex = false;
       m_category.assign("default");
       m_custom_type_name.clear();
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option =
+      const char short_option =
           g_type_format_add_options[option_idx].short_option;
       bool success;
 
       switch (short_option) {
       case 'C':
         m_cascade = OptionArgParser::ToBoolean(option_value, true, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid value for cascade: %s",
protected:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'a':
         m_delete_all = true;
         break;
       case 'w':
         m_category = std::string(option_arg);
         break;
private:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'a':
         m_delete_all = true;
         break;
       default:
         llvm_unreachable("Unimplemented option");
       }
CommandOptions()
           m_category_language(lldb::eLanguageTypeUnknown,
                               lldb::eLanguageTypeUnknown) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       switch (short_option) {
       case 'w':
         m_category_regex.SetCurrentValue(option_arg);
         m_category_regex.SetOptionWasSet();
         break;
       case 'l':
         error = m_category_language.SetValueFromString(option_arg);
         if (error.Success())
CommandObjectTypeFormatList(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterList(interpreter, "type format list",
                                        "Show a list of current formats.") {}
 };
 
 Status CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
-  const int short_option = m_getopt_table[option_idx].val;
+  const char short_option = m_getopt_table[option_idx].val;
   bool success;
 
   switch (short_option) {
   case 'C':
     m_flags.SetCascades(OptionArgParser::ToBoolean(option_arg, true, &success));
     if (!success)
       error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                      option_arg.str().c_str());
CommandOptions()
         : Options(), m_define_enabled(false, false),
           m_cate_language(eLanguageTypeUnknown, eLanguageTypeUnknown) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'e':
         m_define_enabled.SetValueFromString(llvm::StringRef("true"));
         break;
       case 'l':
         error = m_cate_language.SetValueFromString(option_arg);
         break;
class CommandObjectTypeCategoryEnable : public CommandObjectParsed {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'l':
         if (!option_arg.empty()) {
           m_language = Language::GetLanguageTypeFromString(option_arg);
           if (m_language == lldb::eLanguageTypeUnknown)
             error.SetErrorStringWithFormat("unrecognized language '%s'",
                                            option_arg.str().c_str());
class CommandObjectTypeCategoryDisable : public CommandObjectParsed {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'l':
         if (!option_arg.empty()) {
           m_language = Language::GetLanguageTypeFromString(option_arg);
           if (m_language == lldb::eLanguageTypeUnknown)
             error.SetErrorStringWithFormat("unrecognized language '%s'",
                                            option_arg.str().c_str());
private:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       bool success;
 
       switch (short_option) {
       case 'C':
         m_cascade = OptionArgParser::ToBoolean(option_arg, true, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                          option_arg.str().c_str());
public:
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_type_lookup_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                           ExecutionContext *execution_context) override {
       Status error;
 
-      const int short_option = g_type_lookup_options[option_idx].short_option;
+      const char short_option = g_type_lookup_options[option_idx].short_option;
 
       switch (short_option) {
       case 'h':
         m_show_help = true;
         break;
 
       case 'l':
         m_language = Language::GetLanguageTypeFromString(option_value);

lldb/source/Commands/CommandObjectWatchpoint.cpp

CommandOptions()
                                                 // brief descriptions
     {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'b':
         m_level = lldb::eDescriptionLevelBrief;
         break;
       case 'f':
         m_level = lldb::eDescriptionLevelFull;
         break;
public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options(), m_force(false) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_force = true;
         break;
       default:
         llvm_unreachable("Unimplemented option");
       }
public:
   public:
     CommandOptions() : Options(), m_ignore_count(0) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'i':
         if (option_arg.getAsInteger(0, m_ignore_count))
           error.SetErrorStringWithFormat("invalid ignore count '%s'",
                                          option_arg.str().c_str());
         break;
       default:
public:
   public:
     CommandOptions() : Options(), m_condition(), m_condition_passed(false) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'c':
         m_condition = std::string(option_arg);
         m_condition_passed = true;
         break;
       default:
         llvm_unreachable("Unimplemented option");

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

CommandOptions()
           m_script_language(eScriptLanguageNone), m_use_one_liner(false),
           m_one_liner(), m_function_name() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'o':
         m_use_one_liner = true;
         m_one_liner = std::string(option_arg);
         break;
 
       case 's':

lldb/source/Interpreter/OptionGroupArchitecture.cpp

bool OptionGroupArchitecture::GetArchitecture(Platform *platform,
   return arch.IsValid();
 }
 
 Status
 OptionGroupArchitecture::SetOptionValue(uint32_t option_idx,
                                         llvm::StringRef option_arg,
                                         ExecutionContext *execution_context) {
   Status error;
-  const int short_option = g_option_table[option_idx].short_option;
+  const char short_option = g_option_table[option_idx].short_option;
 
   switch (short_option) {
   case 'a':
     m_arch_str.assign(std::string(option_arg));
     break;
 
   default:
     llvm_unreachable("Unimplemented option");

lldb/source/Interpreter/OptionGroupFile.cpp

 //===-- OptionGroupFile.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionGroupFile.h"
 
 #include "lldb/Host/OptionParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 OptionGroupFile::OptionGroupFile(uint32_t usage_mask, bool required,
-                                 const char *long_option, int short_option,
+                                 const char *long_option, char short_option,
                                  uint32_t completion_type,
                                  lldb::CommandArgumentType argument_type,
                                  const char *usage_text)
     : m_file() {
   m_option_definition.usage_mask = usage_mask;
   m_option_definition.required = required;
   m_option_definition.long_option = long_option;
   m_option_definition.short_option = short_option;

lldb/source/Interpreter/OptionGroupFormat.cpp

llvm::ArrayRef<OptionDefinition> OptionGroupFormat::GetDefinitions() {
   }
   return result.take_front(2);
 }
 
 Status OptionGroupFormat::SetOptionValue(uint32_t option_idx,
                                          llvm::StringRef option_arg,
                                          ExecutionContext *execution_context) {
   Status error;
-  const int short_option = g_option_table[option_idx].short_option;
+  const char short_option = g_option_table[option_idx].short_option;
 
   switch (short_option) {
   case 'f':
     error = m_format.SetValueFromString(option_arg);
     break;
 
   case 'c':
     if (m_count.GetDefaultValue() == 0) {

lldb/source/Interpreter/OptionGroupOutputFile.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 OptionGroupOutputFile::OptionGroupOutputFile()
     : m_file(), m_append(false, false) {}
 
 OptionGroupOutputFile::~OptionGroupOutputFile() {}
 
-static const uint32_t SHORT_OPTION_APND = 0x61706e64; // 'apnd'
-
 static constexpr OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_1, false, "outfile", 'o', OptionParser::eRequiredArgument,
      nullptr, {}, 0, eArgTypeFilename,
      "Specify a path for capturing command output."},
-    {LLDB_OPT_SET_1, false, "append-outfile", SHORT_OPTION_APND,
+    {LLDB_OPT_SET_1, false, "append-outfile", 'a',
      OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone,
      "Append to the file specified with '--outfile <path>'."},
 };
 
 llvm::ArrayRef<OptionDefinition> OptionGroupOutputFile::GetDefinitions() {
   return llvm::makeArrayRef(g_option_table);
 }
 
 Status
 OptionGroupOutputFile::SetOptionValue(uint32_t option_idx,
                                       llvm::StringRef option_arg,
                                       ExecutionContext *execution_context) {
   Status error;
-  const int short_option = g_option_table[option_idx].short_option;
+  const char short_option = g_option_table[option_idx].short_option;
 
   switch (short_option) {
   case 'o':
     error = m_file.SetValueFromString(option_arg);
     break;
 
-  case SHORT_OPTION_APND:
+  case 'a':
     m_append.SetCurrentValue(true);
     break;
 
   default:
     llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void OptionGroupOutputFile::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_file.Clear();
   m_append.Clear();
 }

lldb/source/Interpreter/OptionGroupPlatform.cpp

 Status
 OptionGroupPlatform::SetOptionValue(uint32_t option_idx,
                                     llvm::StringRef option_arg,
                                     ExecutionContext *execution_context) {
   Status error;
   if (!m_include_platform_option)
     ++option_idx;
 
-  const int short_option = g_option_table[option_idx].short_option;
+  const char short_option = g_option_table[option_idx].short_option;
 
   switch (short_option) {
   case 'p':
     m_platform_name.assign(std::string(option_arg));
     break;
 
   case 'v':
     if (m_os_version.tryParse(option_arg))

lldb/source/Interpreter/OptionGroupUUID.cpp

 llvm::ArrayRef<OptionDefinition> OptionGroupUUID::GetDefinitions() {
   return llvm::makeArrayRef(g_option_table);
 }
 
 Status OptionGroupUUID::SetOptionValue(uint32_t option_idx,
                                        llvm::StringRef option_arg,
                                        ExecutionContext *execution_context) {
   Status error;
-  const int short_option = g_option_table[option_idx].short_option;
+  const char short_option = g_option_table[option_idx].short_option;
 
   switch (short_option) {
   case 'u':
     error = m_uuid.SetValueFromString(option_arg);
     if (error.Success())
       m_uuid.SetOptionWasSet();
     break;
 

lldb/source/Interpreter/OptionGroupValueObjectDisplay.cpp

 OptionGroupValueObjectDisplay::GetDefinitions() {
   return llvm::makeArrayRef(g_option_table);
 }
 
 Status OptionGroupValueObjectDisplay::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
-  const int short_option = g_option_table[option_idx].short_option;
+  const char short_option = g_option_table[option_idx].short_option;
   bool success = false;
 
   switch (short_option) {
   case 'd': {
     int32_t result;
     result = OptionArgParser::ToOptionEnum(option_arg, GetDynamicValueTypes(),
                                            2, error);
     if (error.Success())

lldb/source/Interpreter/OptionGroupVariable.cpp

 
 Status
 OptionGroupVariable::SetOptionValue(uint32_t option_idx,
                                     llvm::StringRef option_arg,
                                     ExecutionContext *execution_context) {
   Status error;
   if (!include_frame_options)
     option_idx += 3;
-  const int short_option = g_variable_options[option_idx].short_option;
+  const char short_option = g_variable_options[option_idx].short_option;
   switch (short_option) {
   case 'r':
     use_regex = true;
     break;
   case 'a':
     show_args = false;
     break;
   case 'l':

lldb/source/Interpreter/OptionGroupWatchpoint.cpp

 
 OptionGroupWatchpoint::~OptionGroupWatchpoint() {}
 
 Status
 OptionGroupWatchpoint::SetOptionValue(uint32_t option_idx,
                                       llvm::StringRef option_arg,
                                       ExecutionContext *execution_context) {
   Status error;
-  const int short_option = g_option_table[option_idx].short_option;
+  const char short_option = g_option_table[option_idx].short_option;
   switch (short_option) {
   case 'w': {
     WatchType tmp_watch_type;
     tmp_watch_type = (WatchType)OptionArgParser::ToOptionEnum(
         option_arg, g_option_table[option_idx].enum_values, 0, error);
     if (error.Success()) {
       watch_type = tmp_watch_type;
       watch_type_specified = true;

lldb/source/Interpreter/Options.cpp

if (m_getopt_table.empty()) {
     auto defs = GetDefinitions();
     if (defs.empty())
       return nullptr;
 
     std::map<int, uint32_t> option_seen;
 
     m_getopt_table.resize(defs.size() + 1);
     for (size_t i = 0; i < defs.size(); ++i) {
-      const int short_opt = defs[i].short_option;
+      const char short_opt = defs[i].short_option;
 
       m_getopt_table[i].definition = &defs[i];
       m_getopt_table[i].flag = nullptr;
       m_getopt_table[i].val = short_opt;
 
       if (option_seen.find(short_opt) == option_seen.end()) {
         option_seen[short_opt] = i;
       } else if (short_opt) {
         m_getopt_table[i].val = 0;
         std::map<int, uint32_t>::const_iterator pos =
             option_seen.find(short_opt);
         StreamString strm;
-        if (defs[i].HasShortOption())
-          Host::SystemLog(Host::eSystemLogError,
-                          "option[%u] --%s has a short option -%c that "
-                          "conflicts with option[%u] --%s, short option won't "
-                          "be used for --%s\n",
-                          (int)i, defs[i].long_option, short_opt, pos->second,
-                          m_getopt_table[pos->second].definition->long_option,
-                          defs[i].long_option);
-        else
-          Host::SystemLog(Host::eSystemLogError,
-                          "option[%u] --%s has a short option 0x%x that "
-                          "conflicts with option[%u] --%s, short option won't "
-                          "be used for --%s\n",
-                          (int)i, defs[i].long_option, short_opt, pos->second,
-                          m_getopt_table[pos->second].definition->long_option,
-                          defs[i].long_option);
       }
     }
 
     // getopt_long_only requires a NULL final entry in the table:
 
     m_getopt_table.back().definition = nullptr;
     m_getopt_table.back().flag = nullptr;
     m_getopt_table.back().val = 0;
enum OptionDisplayType {
   eDisplayBestOption,
   eDisplayShortOption,
   eDisplayLongOption
 };
 
 static bool PrintOption(const OptionDefinition &opt_def,
                         OptionDisplayType display_type, const char *header,
                         const char *footer, bool show_optional, Stream &strm) {
-  if (display_type == eDisplayShortOption && !opt_def.HasShortOption())
-    return false;
-
   if (header && header[0])
     strm.PutCString(header);
 
   if (show_optional && !opt_def.required)
     strm.PutChar('[');
-  const bool show_short_option =
-      opt_def.HasShortOption() && display_type != eDisplayLongOption;
+  const bool show_short_option = display_type != eDisplayLongOption;
   if (show_short_option)
     strm.Printf("-%c", opt_def.short_option);
   else
     strm.Printf("--%s", opt_def.long_option);
   switch (opt_def.option_has_arg) {
   case OptionParser::eNoArgument:
     break;
   case OptionParser::eRequiredArgument:
for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) {
 
       // First go through and print all options that take no arguments as a
       // single string. If a command has "-a" "-b" and "-c", this will show up
       // as [-abc]
 
       std::set<int> options;
       std::set<int>::const_iterator options_pos, options_end;
       for (auto &def : opt_defs) {
-        if (def.usage_mask & opt_set_mask && def.HasShortOption()) {
+        if (def.usage_mask & opt_set_mask) {
           // Add current option to the end of out_stream.
 
           if (def.required && def.option_has_arg == OptionParser::eNoArgument) {
             options.insert(def.short_option);
           }
         }
       }
 
       if (!options.empty()) {
         // We have some required options with no arguments
         strm.PutCString(" -");
         for (i = 0; i < 2; ++i)
           for (options_pos = options.begin(), options_end = options.end();
                options_pos != options_end; ++options_pos) {
             if (i == 0 && ::islower(*options_pos))
               continue;
             if (i == 1 && ::isupper(*options_pos))
               continue;
             strm << (char)*options_pos;
           }
       }
 
       options.clear();
       for (auto &def : opt_defs) {
-        if (def.usage_mask & opt_set_mask && def.HasShortOption()) {
+        if (def.usage_mask & opt_set_mask) {
           // Add current option to the end of out_stream.
 
           if (!def.required &&
               def.option_has_arg == OptionParser::eNoArgument) {
             options.insert(def.short_option);
           }
         }
       }
for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) {
             strm << (char)*options_pos;
           }
         strm.PutChar(']');
       }
 
       // First go through and print the required options (list them up front).
 
       for (auto &def : opt_defs) {
-        if (def.usage_mask & opt_set_mask && def.HasShortOption()) {
+        if (def.usage_mask & opt_set_mask) {
           if (def.required && def.option_has_arg != OptionParser::eNoArgument)
             PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
         }
       }
 
       // Now go through again, and this time only print the optional options.
 
       for (auto &def : opt_defs) {
for (auto pos : options_seen) {
         first_option_printed = true;
 
       CommandArgumentType arg_type = opt_defs[i].argument_type;
 
       StreamString arg_name_str;
       arg_name_str.Printf("<%s>", CommandObject::GetArgumentName(arg_type));
 
       strm.Indent();
-      if (opt_defs[i].short_option && opt_defs[i].HasShortOption()) {
+      if (opt_defs[i].short_option) {
         PrintOption(opt_defs[i], eDisplayShortOption, nullptr, nullptr, false,
                     strm);
         PrintOption(opt_defs[i], eDisplayLongOption, " ( ", " )", false, strm);
-      } else {
-        // Short option is not printable, just print long option
-        PrintOption(opt_defs[i], eDisplayLongOption, nullptr, nullptr, false,
-                    strm);
       }
       strm.EOL();
 
       strm.IndentMore(5);
 
       if (opt_defs[i].usage_text)
         OutputFormattedUsageText(strm, opt_defs[i], screen_width);
       if (!opt_defs[i].enum_values.empty()) {

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

public:
   public:
     CommandOptions() : Options(), m_verbose(false, false) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       switch (short_option) {
       case 'v':
         m_verbose.SetCurrentValue(true);
         m_verbose.SetOptionWasSet();
         break;
 
       default:
         error.SetErrorStringWithFormat("unrecognized short option '%c'",

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

CommandOptions()
           m_kernel_types(RSReduceBreakpointResolver::eKernelTypeAll) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *exe_ctx) override {
       Status err;
       StreamString err_str;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
       switch (short_option) {
       case 't':
         if (!ParseReductionTypes(option_arg, err_str))
           err.SetErrorStringWithFormat(
               "Unable to deduce reduction types for %s: %s",
               option_arg.str().c_str(), err_str.GetData());
         break;
       case 'c': {
public:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *exe_ctx) override {
       Status err;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'c': {
         auto coord = RSCoordinate{};
         if (!ParseCoordinate(option_arg, coord))
           err.SetErrorStringWithFormat(
               "Couldn't parse coordinate '%s', should be in format 'x,y,z'.",
               option_arg.str().c_str());
public:
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *exe_ctx) override {
       Status err;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_outfile.SetFile(option_arg, FileSpec::Style::native);
         FileSystem::Instance().Resolve(m_outfile);
         if (FileSystem::Instance().Exists(m_outfile)) {
           m_outfile.Clear();
           err.SetErrorStringWithFormat("file already exists: '%s'",
public:
   public:
     CommandOptions() : Options(), m_id(0) {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *exe_ctx) override {
       Status err;
-      const int short_option = m_getopt_table[option_idx].val;
+      const char short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'i':
         if (option_arg.getAsInteger(0, m_id))
           err.SetErrorStringWithFormat("invalid integer value for option '%c'",
                                        short_option);
         break;
       default:

lldb/source/Target/Platform.cpp

void OptionGroupPlatformRSync::OptionParsingStarting(
   m_ignores_remote_hostname = false;
 }
 
 lldb_private::Status
 OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
                                          llvm::StringRef option_arg,
                                          ExecutionContext *execution_context) {
   Status error;
-  char short_option = (char)GetDefinitions()[option_idx].short_option;
+  char short_option = GetDefinitions()[option_idx].short_option;
   switch (short_option) {
   case 'r':
     m_rsync = true;
     break;
 
   case 'R':
     m_rsync_opts.assign(std::string(option_arg));
     break;
void OptionGroupPlatformSSH::OptionParsingStarting(
   m_ssh_opts.clear();
 }
 
 lldb_private::Status
 OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
                                        llvm::StringRef option_arg,
                                        ExecutionContext *execution_context) {
   Status error;
-  char short_option = (char)GetDefinitions()[option_idx].short_option;
+  char short_option = GetDefinitions()[option_idx].short_option;
   switch (short_option) {
   case 's':
     m_ssh = true;
     break;
 
   case 'S':
     m_ssh_opts.assign(std::string(option_arg));
     break;
void OptionGroupPlatformCaching::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_cache_dir.clear();
 }
 
 lldb_private::Status OptionGroupPlatformCaching::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
-  char short_option = (char)GetDefinitions()[option_idx].short_option;
+  char short_option = GetDefinitions()[option_idx].short_option;
   switch (short_option) {
   case 'c':
     m_cache_dir.assign(std::string(option_arg));
     break;
 
   default:
     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
     break;

lldb/source/Target/Process.cpp

if (exp_values)
     exp_values->SetPropertyAtIndexAsBoolean(
         nullptr, ePropertyOSPluginReportsAllThreads, does_report);
 }
 
 Status ProcessLaunchCommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
-  const int short_option = m_getopt_table[option_idx].val;
+  const char short_option = m_getopt_table[option_idx].val;
 
   switch (short_option) {
   case 's': // Stop at program entry point
     launch_info.GetFlags().Set(eLaunchFlagStopAtEntry);
     break;
 
   case 'i': // STDIN for read only
   {