[lldb][NFC] Remove dead code that is supposed to handle invalid command options

[teemperor]

Summary

We currently have a bunch of code that is supposed to handle invalid command options, but
all this code is unreachable because invalid options are already handled in Options::Parse.
The only way we can reach this code is when we declare but then not implement an option
(which will be made impossible with D65386, which is also when we can completely remove
the default cases).

This patch replaces all this code with llvm_unreachable to make clear this is dead code
that can't be reached.

[teemperor]

• Remove some unreachable that are not in the command/interpreter directory (as they might be used differently and could be reached).

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

case 'x':
         if (option_arg.getAsInteger(0, thread_index))
           error.SetErrorStringWithFormat("invalid thread index string '%s'",
                                          option_arg.str().c_str());
       }
       m_bp_opts.GetThreadSpec()->SetIndex(thread_index);
     }
     break;
     default:
-      error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                     short_option);
-      break;
+      llvm_unreachable("Unimplemented option");
     }
 
     return error;
   }
 
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_bp_opts.Clear();
     m_commands.clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
     Status error;
     const int short_option = g_breakpoint_modify_options[option_idx].short_option;
 
     switch (short_option) {
       case 'D':
         m_use_dummy = true;
         break;
     default:
-      error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                     short_option);
-      break;
+      llvm_unreachable("Unimplemented option");
     }
 
     return error;
   }
 
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_use_dummy = false;
   }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
               option_arg.str().c_str());
       } break;
 
       case 'X':
         m_source_regex_func_names.insert(option_arg);
         break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_filenames.Clear();
       m_line_num = 0;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
       case 'v':
         m_level = lldb::eDescriptionLevelVerbose;
         break;
       case 'i':
         m_internal = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_level = lldb::eDescriptionLevelFull;
       m_internal = false;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         m_filename.assign(option_arg);
         break;
 
       case 'l':
         option_arg.getAsInteger(0, m_line_num);
         break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_filename.clear();
       m_line_num = 0;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         m_force = true;
         break;
 
       case 'D':
         m_use_dummy = true;
         break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_dummy = false;
       m_force = false;
case 'D':
             "unrecognized value \"%s\" for use-dummy",
             option_arg.str().c_str());
       break;
     case 'H':
       m_help_string.SetValueFromString(option_arg);
       break;
 
     default:
-      error.SetErrorStringWithFormat("unrecognized short option '%c'",
-                                     short_option);
-      break;
+      llvm_unreachable("Unimplemented option");
     }
     return error;
   }
 
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_name.Clear();
     m_breakpoint.Clear();
     m_use_dummy.Clear();
switch (short_option) {
         value = OptionArgParser::ToBoolean(option_arg, false, &success);
         if (success) {
           m_permissions.SetAllowDelete(value);
         } else
           error.SetErrorStringWithFormat(
               "invalid boolean value '%s' passed for -L option",
               option_arg.str().c_str());
       } break;
-
+      default:
+        llvm_unreachable("Unimplemented option");
     }
     
     return error;
   }
   
   void OptionParsingStarting(ExecutionContext *execution_context) override {
   }
   
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                                                   name_error)) {
           error.SetErrorStringWithFormat("Invalid breakpoint name: %s",
                                          name_error.AsCString());
         }
         m_names.push_back(option_arg);
         break;
       }
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_filename.clear();
       m_names.clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       switch (short_option) {
       case 'f':
         m_filename.assign(option_arg);
         break;
       case 'a':
         m_append = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_filename.clear();
       m_append = false;

lldb/trunk/source/Commands/CommandObjectBreakpointCommand.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         m_function_name.assign(option_arg);
         break;
 
       case 'D':
         m_use_dummy = true;
         break;
 
       default:
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_commands = true;
       m_use_script_language = false;
       m_script_language = eScriptLanguageNone;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'D':
         m_use_dummy = true;
         break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_dummy = false;
     }

lldb/trunk/source/Commands/CommandObjectCommands.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         error =
             m_stop_idx.SetValueFromString(option_arg, eVarSetOperationAssign);
         break;
       case 'C':
         m_clear.SetCurrentValue(true);
         m_clear.SetOptionWasSet();
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_start_idx.Clear();
       m_stop_idx.Clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         error = m_stop_on_continue.SetValueFromString(option_arg);
         break;
 
       case 's':
         error = m_silent_run.SetValueFromString(option_arg);
         break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_stop_on_error.Clear();
       m_silent_run.Clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
         break;
 
       case 'H':
         m_long_help.SetCurrentValue(option_str);
         m_long_help.SetOptionWasSet();
         break;
 
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_help.Clear();
       m_long_help.Clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       switch (short_option) {
       case 'h':
         m_help.assign(option_arg);
         break;
       case 's':
         m_syntax.assign(option_arg);
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_help.clear();
       m_syntax.clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'r':
         m_allow_reload = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_allow_reload = true;
     }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
             (ScriptedCommandSynchronicity)OptionArgParser::ToOptionEnum(
                 option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
         if (!error.Success())
           error.SetErrorStringWithFormat(
               "unrecognized value for synchronicity '%s'",
               option_arg.str().c_str());
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_class_name.clear();
       m_funct_name.clear();

lldb/trunk/source/Commands/CommandObjectDisassemble.cpp

case 'a': {
     symbol_containing_addr = OptionArgParser::ToAddress(
         execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
     if (symbol_containing_addr != LLDB_INVALID_ADDRESS) {
       some_location_specified = true;
     }
   } break;
 
   default:
-    error.SetErrorStringWithFormat("unrecognized short option '%c'",
-                                   short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void CommandObjectDisassemble::CommandOptions::OptionParsingStarting(
     ExecutionContext *execution_context) {
   show_mixed = false;

lldb/trunk/source/Commands/CommandObjectExpression.cpp

case 'X': {
     else
       error.SetErrorStringWithFormat(
           "could not convert \"%s\" to a boolean value.",
           option_arg.str().c_str());
     break;
   }
 
   default:
-    error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                   short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void CommandObjectExpression::CommandOptions::OptionParsingStarting(
     ExecutionContext *execution_context) {
   auto process_sp =

lldb/trunk/source/Commands/CommandObjectFrame.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         if (option_arg.getAsInteger(0, *offset)) {
           offset.reset();
           error.SetErrorStringWithFormat("invalid offset argument '%s'",
                                          option_arg.str().c_str());
         }
       } break;
 
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       address.reset();
       reg.reset();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         if (option_arg.getAsInteger(0, relative_frame_offset)) {
           relative_frame_offset = INT32_MIN;
           error.SetErrorStringWithFormat("invalid frame offset argument '%s'",
                                          option_arg.str().c_str());
         }
         break;
 
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       relative_frame_offset = INT32_MIN;
     }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
       case 'n':
         m_function = std::string(option_arg);
         break;
       case 'x':
         m_regex = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_module = "";
       m_function = "";

lldb/trunk/source/Commands/CommandObjectHelp.h

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
       case 'u':
         m_show_user_defined = false;
         break;
       case 'h':
         m_show_hidden = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_show_aliases = true;
       m_show_user_defined = true;

lldb/trunk/source/Commands/CommandObjectLog.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
       case 'a':
         log_options |= LLDB_LOG_OPTION_APPEND;
         break;
       case 'F':
         log_options |= LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       log_file.Clear();
       log_options = 0;

lldb/trunk/source/Commands/CommandObjectMemory.cpp

case 'x':
       error = m_language_for_type.SetValueFromString(option_value);
       break;
 
     case 'E':
       error = m_offset.SetValueFromString(option_value);
       break;
 
     default:
-      error.SetErrorStringWithFormat("unrecognized short option '%c'",
-                                     short_option);
-      break;
+      llvm_unreachable("Unimplemented option");
     }
     return error;
   }
 
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_num_per_line.Clear();
     m_output_as_binary = false;
     m_view_as_type.Clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
         break;
 
       case 'o':
         if (m_offset.SetValueFromString(option_value).Fail())
           error.SetErrorString("unrecognized value for dump-offset");
         break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized short option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_expr.Clear();
       m_string.Clear();
       m_count.Clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
         if (option_value.getAsInteger(0, m_infile_offset)) {
           m_infile_offset = 0;
           error.SetErrorStringWithFormat("invalid offset string '%s'",
                                          option_value.str().c_str());
         }
       } break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized short option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_infile.Clear();
       m_infile_offset = 0;
     }

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

case 'd':
       break;
     case 't':
       m_permissions |= lldb::eFilePermissionsWorldWrite;
       break;
     case 'e':
       m_permissions |= lldb::eFilePermissionsWorldExecute;
       break;
     default:
-      error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-      break;
+      llvm_unreachable("Unimplemented option");
     }
 
     return error;
   }
 
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_permissions = 0;
   }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                                          option_arg.str().c_str());
         break;
       case 'c':
         if (option_arg.getAsInteger(0, m_count))
           error.SetErrorStringWithFormat("invalid offset: '%s'",
                                          option_arg.str().c_str());
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_offset = 0;
       m_count = 1;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         if (option_arg.getAsInteger(0, m_offset))
           error.SetErrorStringWithFormat("invalid offset: '%s'",
                                          option_arg.str().c_str());
         break;
       case 'd':
         m_data.assign(option_arg);
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_offset = 0;
       m_data.clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         show_args = true;
         break;
 
       case 'v':
         verbose = true;
         break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       match_info.Clear();
       show_args = false;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                                                 FileSpec::Style::native);
         break;
 
       case 'w':
         attach_info.SetWaitForLaunch(true);
         break;
 
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       attach_info.Clear();
     }
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         if (option_arg.getAsInteger(10, timeout_sec))
           error.SetErrorStringWithFormat(
               "could not convert \"%s\" to a numeric value.",
               option_arg.str().c_str());
         else
           timeout = std::chrono::seconds(timeout_sec);
         break;
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {}
 
     Timeout<std::micro> timeout = std::chrono::seconds(10);

lldb/trunk/source/Commands/CommandObjectProcess.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         attach_info.SetWaitForLaunch(true);
         break;
 
       case 'i':
         attach_info.SetIgnoreExisting(false);
         break;
 
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       attach_info.Clear();
     }
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       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;
 
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_ignore = 0;
     }
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         else {
           if (tmp_result)
             m_keep_stopped = eLazyBoolYes;
           else
             m_keep_stopped = eLazyBoolNo;
         }
         break;
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_keep_stopped = eLazyBoolCalculate;
     }
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'p':
         plugin_name.assign(option_arg);
         break;
 
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       plugin_name.clear();
     }
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       const int 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:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       do_install = false;
       install_path.Clear();
     }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
       case 'n':
         notify = option_arg;
         break;
       case 'p':
         pass = option_arg;
         break;
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       stop.clear();
       notify.clear();
       pass.clear();

lldb/trunk/source/Commands/CommandObjectRegister.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
         // When we don't use OptionValue::SetValueFromCString(const char *) to
         // set an option value, it won't be marked as being set in the options
         // so we make a call to let users know the value was set via option
         alternate_name.SetCurrentValue(true);
         dump_all_sets.SetOptionWasSet();
         break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized short option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     // Instance variables to hold the values for command options.
     OptionValueArray set_indexes;
     OptionValueBoolean dump_all_sets;
     OptionValueBoolean alternate_name;

lldb/trunk/source/Commands/CommandObjectSettings.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       switch (short_option) {
       case 'f':
         m_force = true;
         break;
       case 'g':
         m_global = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized options '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_global = false;
       m_force = false;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       switch (short_option) {
       case 'f':
         m_filename.assign(option_arg);
         break;
       case 'a':
         m_append = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_filename.clear();
       m_append = false;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'f':
         m_filename.assign(option_arg);
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_filename.clear();
     }

lldb/trunk/source/Commands/CommandObjectSource.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       case 'a': {
         address = OptionArgParser::ToAddress(execution_context, option_arg,
                                              LLDB_INVALID_ADDRESS, &error);
       } break;
       case 's':
         modules.push_back(std::string(option_arg));
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized short option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       file_spec.Clear();
       file_name.clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 
       case 'b':
         show_bp_locs = true;
         break;
       case 'r':
         reverse = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized short option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       file_spec.Clear();
       file_name.clear();

lldb/trunk/source/Commands/CommandObjectTarget.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       switch (short_option) {
       case 's':
         m_sort_order = (SortOrder)OptionArgParser::ToOptionEnum(
             option_arg, GetDefinitions()[option_idx].enum_values,
             eSortOrderNone, error);
         break;
 
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_sort_order = eSortOrderNone;
     }
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       }
 
       case 'n':
         m_str = option_arg;
         m_type = eLookupTypeFunctionOrSymbol;
         break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized option %c.", short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_type = eLookupTypeInvalid;
       m_str.clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 
       case 'A':
         m_print_all = true;
         break;
 
       case 'r':
         m_use_regex = true;
         break;
+      default:
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_type = eLookupTypeInvalid;
       m_str.clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
 
       case 'o':
         m_use_one_liner = true;
         m_one_liner.push_back(option_arg);
         break;
 
       default:
-        error.SetErrorStringWithFormat("unrecognized option %c.", short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_class_name.clear();
       m_function_name.clear();
       m_line_start = 0;

lldb/trunk/source/Commands/CommandObjectThread.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         bool success;
         m_extended_backtrace =
             OptionArgParser::ToBoolean(option_arg, false, &success);
         if (!success)
           error.SetErrorStringWithFormat(
               "invalid boolean value for option '%c'", short_option);
       } break;
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_count = UINT32_MAX;
       m_start = 0;
       m_extended_backtrace = false;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
 
       case 't':
         m_step_in_target.clear();
         m_step_in_target.assign(option_arg);
         break;
 
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_step_in_avoid_no_debug = eLazyBoolCalculate;
       m_step_out_avoid_no_debug = eLazyBoolCalculate;
       m_run_mode = eOnlyDuringStepping;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         if (error.Success()) {
           if (run_mode == eAllThreads)
             m_stop_others = false;
           else
             m_stop_others = true;
         }
       } break;
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_thread_idx = LLDB_INVALID_THREAD_ID;
       m_frame_idx = 0;
       m_stop_others = false;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         m_json_thread = true;
         break;
 
       case 's':
         m_json_stopinfo = true;
         break;
 
       default:
-        return Status("invalid short option character '%c'", short_option);
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_thread_info_options);
     }
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
           m_from_expression = tmp_value;
         else {
           error.SetErrorStringWithFormat(
               "invalid boolean value '%s' for 'x' option",
               option_arg.str().c_str());
         }
       } break;
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_from_expression = false;
     }
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       case 'a':
         m_load_addr = OptionArgParser::ToAddress(execution_context, option_arg,
                                                  LLDB_INVALID_ADDRESS, &error);
         break;
       case 'r':
         m_force = true;
         break;
       default:
-        return Status("invalid short option character '%c'", short_option);
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_thread_jump_options);
     }
 
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       switch (short_option) {
       case 'i':
         m_internal = true;
         break;
       case 'v':
         m_verbose = true;
         break;
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_verbose = false;
       m_internal = false;
     }

lldb/trunk/source/Commands/CommandObjectType.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
       case 'w':
         m_category = std::string(option_arg);
         break;
       case 'x':
         m_regex = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_cascade = true;
       m_class_name = "";
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
         break;
       case 'x':
         m_regex = true;
         break;
       case 't':
         m_custom_type_name.assign(option_value);
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     // Instance variables to hold the values for command options.
 
     bool m_cascade;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
       case 'w':
         m_category = std::string(option_arg);
         break;
       case 'l':
         m_language = Language::GetLanguageTypeFromString(option_arg);
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_delete_all = false;
       m_category = "default";
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'a':
         m_delete_all = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_delete_all = false;
     }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         m_category_regex.SetOptionWasSet();
         break;
       case 'l':
         error = m_category_language.SetValueFromString(option_arg);
         if (error.Success())
           m_category_language.SetOptionWasSet();
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_category_regex.Clear();
       m_category_language.Clear();
case 'P':
     break;
   case 'w':
     m_category = std::string(option_arg);
     break;
   case 'O':
     m_flags.SetHideItemNames(true);
     break;
   default:
-    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_flags.Clear().SetCascades().SetDontShowChildren().SetDontShowValue(false);
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       switch (short_option) {
       case 'e':
         m_define_enabled.SetValueFromString(llvm::StringRef("true"));
         break;
       case 'l':
         error = m_cate_language.SetValueFromString(option_arg);
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_define_enabled.Clear();
       m_cate_language.Clear();
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         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());
         }
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_language = lldb::eLanguageTypeUnknown;
     }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         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());
         }
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_language = lldb::eLanguageTypeUnknown;
     }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
       case 'w':
         m_category = std::string(option_arg);
         break;
       case 'x':
         m_regex = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_cascade = true;
       m_skip_pointers = false;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
         m_show_help = true;
         break;
 
       case 'l':
         m_language = Language::GetLanguageTypeFromString(option_value);
         break;
 
       default:
-        error.SetErrorStringWithFormat("invalid short option character '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_show_help = false;
       m_language = eLanguageTypeUnknown;

lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         break;
       case 'f':
         m_level = lldb::eDescriptionLevelFull;
         break;
       case 'v':
         m_level = lldb::eDescriptionLevelVerbose;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_level = lldb::eDescriptionLevelFull;
     }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 
       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:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_ignore_count = 0;
     }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'c':
         m_condition = option_arg;
         m_condition_passed = true;
         break;
       default:
-        error.SetErrorStringWithFormat("unrecognized option '%c'",
-                                       short_option);
-        break;
+        llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_condition.clear();
       m_condition_passed = false;

lldb/trunk/source/Commands/CommandObjectWatchpointCommand.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 
       case 'F':
         m_use_one_liner = false;
         m_use_script_language = true;
         m_function_name.assign(option_arg);
         break;
 
       default:
-        break;
+        llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_commands = true;
       m_use_script_language = false;
       m_script_language = eScriptLanguageNone;

lldb/trunk/source/Interpreter/OptionGroupArchitecture.cpp

OptionGroupArchitecture::SetOptionValue(uint32_t option_idx,
   const int short_option = g_option_table[option_idx].short_option;
 
   switch (short_option) {
   case 'a':
     m_arch_str.assign(option_arg);
     break;
 
   default:
-    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void OptionGroupArchitecture::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_arch_str.clear();
 }

lldb/trunk/source/Interpreter/OptionGroupFormat.cpp

case 'G': {
     }
     if (count_enabled) {
       m_count.SetCurrentValue(count);
       m_count.SetOptionWasSet();
     }
   } break;
 
   default:
-    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 bool OptionGroupFormat::ParserGDBFormatLetter(
     ExecutionContext *execution_context, char format_letter, Format &format,
     uint32_t &byte_size) {

lldb/trunk/source/Interpreter/OptionGroupOutputFile.cpp

case 'o':
     error = m_file.SetValueFromString(option_arg);
     break;
 
   case SHORT_OPTION_APND:
     m_append.SetCurrentValue(true);
     break;
 
   default:
-    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void OptionGroupOutputFile::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_file.Clear();
   m_append.Clear();
 }

lldb/trunk/source/Interpreter/OptionGroupPlatform.cpp

case 'b':
     m_sdk_build.SetString(option_arg);
     break;
 
   case 'S':
     m_sdk_sysroot.SetString(option_arg);
     break;
 
   default:
-    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
   return error;
 }
 
 bool OptionGroupPlatform::PlatformMatches(
     const lldb::PlatformSP &platform_sp) const {
   if (platform_sp) {
     if (!m_platform_name.empty()) {

lldb/trunk/source/Interpreter/OptionGroupUUID.cpp

Status OptionGroupUUID::SetOptionValue(uint32_t option_idx,
   switch (short_option) {
   case 'u':
     error = m_uuid.SetValueFromString(option_arg);
     if (error.Success())
       m_uuid.SetOptionWasSet();
     break;
 
   default:
-    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void OptionGroupUUID::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_uuid.Clear();
 }

lldb/trunk/source/Interpreter/OptionGroupValueObjectDisplay.cpp

Status OptionGroupValueObjectDisplay::SetOptionValue(
   case 'V':
     run_validator = OptionArgParser::ToBoolean(option_arg, true, &success);
     if (!success)
       error.SetErrorStringWithFormat("invalid validate '%s'",
                                      option_arg.str().c_str());
     break;
 
   default:
-    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void OptionGroupValueObjectDisplay::OptionParsingStarting(
     ExecutionContext *execution_context) {
   // If these defaults change, be sure to modify AnyOptionWasSet().

lldb/trunk/source/Interpreter/OptionGroupVariable.cpp

case 't':
     break;
   case 'y':
     error = summary.SetCurrentValue(option_arg);
     break;
   case 'z':
     error = summary_string.SetCurrentValue(option_arg);
     break;
   default:
-    error.SetErrorStringWithFormat("unrecognized short option '%c'",
-                                   short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void OptionGroupVariable::OptionParsingStarting(
     ExecutionContext *execution_context) {
   show_args = true;     // Frame option only

lldb/trunk/source/Interpreter/OptionGroupWatchpoint.cpp

case 'w': {
     break;
   }
   case 's':
     watch_size = (uint32_t)OptionArgParser::ToOptionEnum(
         option_arg, g_option_table[option_idx].enum_values, 0, error);
     break;
 
   default:
-    error.SetErrorStringWithFormat("unrecognized short option '%c'",
-                                   short_option);
-    break;
+    llvm_unreachable("Unimplemented option");
   }
 
   return error;
 }
 
 void OptionGroupWatchpoint::OptionParsingStarting(
     ExecutionContext *execution_context) {
   watch_type_specified = false;
   watch_type = eWatchInvalid;
   watch_size = 0;
 }
 
 llvm::ArrayRef<OptionDefinition> OptionGroupWatchpoint::GetDefinitions() {
   return llvm::makeArrayRef(g_option_table);
 }