[lldb] Update custom commands to always be overrriden

[mib]

Summary

This is a follow-up patch to D140113.

As explained previously, when running from an IDE, it can happen that
the IDE imports some lldb scripts by itself. If the user also tries to
import these commands, lldb will show the following message:

error: cannot add command: user command exists and force replace not set

This message is confusing to the user, because it suggests that the
command import failed and that the execution should stop. However, in
this case, lldb will continue the execution with the command added
previously by the user.

To prevent that, this patch updates every first-party lldb-packaged
custom commands to override commands that were pre-imported in lldb.

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

Fix typo in crashlog.py

[JDevlieghere]

LGTM. The pattern of debugger.HandleCommand("command script add -o -c [...]") seems rather tedious. Would it make sense to add a wrapper to the SBAPI that takes care of that?

[mib]

In D140293#4044524, @JDevlieghere wrote:

LGTM. The pattern of debugger.HandleCommand("command script add -o -c [...]") seems rather tedious. Would it make sense to add a wrapper to the SBAPI that takes care of that?

I think that would make sense. I'll do it in a follow-up!

lldb/examples/darwin/heap_find/heap.py

def __lldb_init_module(debugger, internal_dict):
     # command line command prior to registering it with LLDB below. This way
     # if clients in LLDB type "help malloc_info", they will see the exact same
     # output as typing "malloc_info --help".
     ptr_refs.__doc__ = get_ptr_refs_options().format_help()
     cstr_refs.__doc__ = get_cstr_refs_options().format_help()
     malloc_info.__doc__ = get_malloc_info_options().format_help()
     objc_refs.__doc__ = get_objc_refs_options().format_help()
     debugger.HandleCommand(
-        'command script add -f %s.ptr_refs ptr_refs' %
+        'command script add -o -f %s.ptr_refs ptr_refs' %
         __name__)
     debugger.HandleCommand(
-        'command script add -f %s.cstr_refs cstr_refs' %
+        'command script add -o -f %s.cstr_refs cstr_refs' %
         __name__)
     debugger.HandleCommand(
-        'command script add -f %s.malloc_info malloc_info' %
+        'command script add -o -f %s.malloc_info malloc_info' %
         __name__)
     debugger.HandleCommand(
-        'command script add -f %s.find_variable find_variable' %
+        'command script add -o -f %s.find_variable find_variable' %
         __name__)
-    # debugger.HandleCommand('command script add -f %s.section_ptr_refs section_ptr_refs' % package_name)
+    # debugger.HandleCommand('command script add -o -f %s.section_ptr_refs section_ptr_refs' % package_name)
     debugger.HandleCommand(
-        'command script add -f %s.objc_refs objc_refs' %
+        'command script add -o -f %s.objc_refs objc_refs' %
         __name__)
     print('"malloc_info", "ptr_refs", "cstr_refs", "find_variable", and "objc_refs" commands have been installed, use the "--help" options on these commands for detailed help.')

lldb/examples/python/bsd.py

def __call__(self, debugger, command, exe_ctx, result):
                 print("No errors detected in debug map", file=result)
 
 
 def __lldb_init_module(debugger, dict):
     # This initializer is being run from LLDB in the embedded command
     # interpreter.
     # Add any commands contained in this module to LLDB
     debugger.HandleCommand(
-        'command script add -c %s.VerifyDebugMapCommand %s' % (
+        'command script add -o -c %s.VerifyDebugMapCommand %s' % (
             __name__, VerifyDebugMapCommand.name))
     print('The "%s" command has been installed, type "help %s" for detailed '
           'help.' % (VerifyDebugMapCommand.name, VerifyDebugMapCommand.name))

lldb/examples/python/cmdtemplate.py

 class FrameStatCommand:
     program = 'framestats'
 
     @classmethod
     def register_lldb_command(cls, debugger, module_name):
         parser = cls.create_options()
         cls.__doc__ = parser.format_help()
         # Add any commands contained in this module to LLDB
-        command = 'command script add -c %s.%s %s' % (module_name,
+        command = 'command script add -o -c %s.%s %s' % (module_name,
                                                       cls.__name__,
                                                       cls.program)
         debugger.HandleCommand(command)
         print('The "{0}" command has been installed, type "help {0}" or "{0} '
               '--help" for detailed help.'.format(cls.program))
 
     @classmethod
     def create_options(cls):

lldb/examples/python/delta.py

if __name__ == '__main__':
     import sys
     parse_time_log_args(sys.argv[1:])
 
 
 def __lldb_init_module(debugger, internal_dict):
         # This initializer is being run from LLDB in the embedded command interpreter
         # Add any commands contained in this module to LLDB
         debugger.HandleCommand(
-            'command script add -f delta.parse_time_log parse_time_log')
+            'command script add -o -f delta.parse_time_log parse_time_log')
         print('The "parse_time_log" command is now installed and ready for use, type "parse_time_log --help" for more information')

lldb/examples/python/diagnose_nsstring.py

"
     print("1K of data around location: %s\n" % read_memory(
         process, location, 1024), file=result)
     print("5K of data around string pointer: %s\n" % read_memory(
         process, nsstring_address, 1024 * 5), file=result)
 
 
 def __lldb_init_module(debugger, internal_dict):
     debugger.HandleCommand(
-        "command script add -f %s.diagnose_nsstring_Command_Impl diagnose-nsstring" %
+        "command script add -o -f %s.diagnose_nsstring_Command_Impl diagnose-nsstring" %
         __name__)
     print('The "diagnose-nsstring" command has been installed, type "help diagnose-nsstring" for detailed help.')
 
 __lldb_init_module(lldb.debugger, None)
 __lldb_init_module = None

lldb/examples/python/diagnose_unwind.py

def create_diagnose_unwind_options():
     parser = optparse.OptionParser(
         description=description,
         prog='diagnose_unwind',
         usage=usage)
     return parser
 
 def __lldb_init_module(debugger, internal_dict):
     debugger.HandleCommand(
-        'command script add -f %s.diagnose_unwind diagnose-unwind' %
+        'command script add -o -f %s.diagnose_unwind diagnose-unwind' %
         __name__)
     print('The "diagnose-unwind" command has been installed, type "help diagnose-unwind" for detailed help.')

lldb/examples/python/disassembly_mode.py

def __call__(self, debugger, command, exe_ctx, result):
             self.set_value("stop-line-count-before", self.before_count)
             self.set_value("stop-line-count-after", self.after_count)
             result.AppendMessage("Disassembly mode off.")
 
     def get_short_help(self):
         return "Toggles between a disassembly only mode and normal source mode\n"
 
 def __lldb_init_module(debugger, unused):
-    debugger.HandleCommand("command script add -c disassembly_mode.DisassemblyMode toggle-disassembly")
+    debugger.HandleCommand("command script add -o -c disassembly_mode.DisassemblyMode toggle-disassembly")

lldb/examples/python/gdb_disassemble.py

for inst in instructions:
         if comment:
             print("<%s + %-4u> 0x%x %8s  %s ; %s" % (name, inst_offset, inst_addr, inst.mnemonic, inst.operands, comment))
         else:
             print("<%s + %-4u> 0x%x %8s  %s" % (name, inst_offset, inst_addr, inst.mnemonic, inst.operands))
 
 # Install the command when the module gets imported
 def __lldb_init_module(debugger, internal_dict):
     debugger.HandleCommand(
-        'command script add -f gdb_disassemble.disassemble gdb-disassemble')
+        'command script add -o -f gdb_disassemble.disassemble gdb-disassemble')
     print('Installed "gdb-disassemble" command for disassembly')

lldb/examples/python/gdbremote.py

if len(args):
             print('%s' % (options.symbolicator))
     else:
         parse_gdb_log(sys.stdin, options)
 
 def __lldb_init_module(debugger, internal_dict):
     # This initializer is being run from LLDB in the embedded command interpreter
     # Add any commands contained in this module to LLDB
     debugger.HandleCommand(
-        'command script add -f gdbremote.start_gdb_log start_gdb_log')
+        'command script add -o -f gdbremote.start_gdb_log start_gdb_log')
     debugger.HandleCommand(
-        'command script add -f gdbremote.stop_gdb_log stop_gdb_log')
+        'command script add -o -f gdbremote.stop_gdb_log stop_gdb_log')
     print('The "start_gdb_log" and "stop_gdb_log" commands are now installed and ready for use, type "start_gdb_log --help" or "stop_gdb_log --help" for more information')

lldb/examples/python/jump.py

if len(addresses) > 1:
                 " <location-id>' to choose one.")
             return
 
     frame.SetPC(desired_address.GetLoadAddress(target))
 
 def __lldb_init_module(debugger, internal_dict):
     # Module is being run inside the LLDB interpreter
     jump.__doc__ = usage_string()
-    debugger.HandleCommand('command script add -f jump.jump jump')
+    debugger.HandleCommand('command script add -o -f jump.jump jump')
     print('The "jump" command has been installed, type "help jump" or "jump <ENTER>" for detailed help.')

lldb/examples/python/lldb_module_utils.py

def __call__(self, debugger, command, exe_ctx, result):
                         print('    file[%u]: %s' % (j, path), file=result)
 
 
 def __lldb_init_module(debugger, dict):
     # This initializer is being run from LLDB in the embedded command interpreter
 
     # Add any commands contained in this module to LLDB
     debugger.HandleCommand(
-        'command script add -c %s.DumpLineTables %s' % (__name__,
+        'command script add -o -c %s.DumpLineTables %s' % (__name__,
                                                         DumpLineTables.command_name))
     debugger.HandleCommand(
-        'command script add -c %s.DumpFiles %s' % (__name__, DumpFiles.command_name))
+        'command script add -o -c %s.DumpFiles %s' % (__name__, DumpFiles.command_name))
     print('The "%s" and "%s" commands have been installed.' % (DumpLineTables.command_name,
                                                                DumpFiles.command_name))

lldb/examples/python/memory.py

 
 
 if __name__ == '__main__':
     print('error: this script is designed to be used within the embedded script interpreter in LLDB')
 
 def __lldb_init_module(debugger, internal_dict):
     memfind_command.__doc__ = create_memfind_options().format_help()
     debugger.HandleCommand(
-        'command script add -f memory.memfind_command memfind')
+        'command script add -o -f memory.memfind_command memfind')
     print('"memfind" command installed, use the "--help" option for detailed help')

lldb/examples/python/sources.py

def info_sources(debugger, command, result, dict):
     else:
         for module in target.modules:
             dump_module_sources(module, result)
 
 
 def __lldb_init_module(debugger, dict):
     # Add any commands contained in this module to LLDB
     debugger.HandleCommand(
-        'command script add -f sources.info_sources info_sources')
+        'command script add -o -f sources.info_sources info_sources')
     print('The "info_sources" command has been installed, type "help info_sources" or "info_sources --help" for detailed help.')

lldb/examples/python/stacks.py

for thread in process:
                     else:
                         frame_info[name] += frame_size
             last_frame = frame
     print(frame_info)
 
 
 def __lldb_init_module(debugger, internal_dict):
     debugger.HandleCommand(
-        "command script add -f stacks.stack_frames stack_frames")
+        "command script add -o -f stacks.stack_frames stack_frames")
     print("A new command called 'stack_frames' was added, type 'stack_frames --help' for more information.")

lldb/examples/python/step_and_print.py

def __call__(self, debugger, command, exe_ctx, result):
         debugger.HandleCommand("frame variable %s"%(command))
 
         debugger.SetAsync(old_async)
 
     def get_short_help(self):
         return "Does a step-over then runs frame variable passing the command args to it\n"
 
 def __lldb_init_module(debugger, unused):
-    debugger.HandleCommand("command script add -c step_and_print.StepAndPrint sap")
+    debugger.HandleCommand("command script add -o -c step_and_print.StepAndPrint sap")

lldb/examples/python/types.py

for path in args:
                                        error)
         if error.Fail():
             print(error.GetCString())
             continue
         verify_types(target, options)
 
 def __lldb_init_module(debugger, internal_dict):
     debugger.HandleCommand(
-        'command script add -f types.check_padding_command check_padding')
+        'command script add -o -f types.check_padding_command check_padding')
     print('"check_padding" command installed, use the "--help" option for detailed help')