[lldb/crashlog] Fix sticky image parsing logic

[mib]

Summary

Prior to this patch, when a user loaded multiple crash report in lldb,
they could get in a situation where all the targets would keep the same
architecture and executable path as the first one that we've created.

The reason behind this was that even if we created a new CrashLog
object, which is derived from a Symbolicator class that has a newly
constructoted image list as a default argument, because that default
argument is only created once when the function is defined, every CrashLog
object would share the same list.

That will cause use to append newly parsed images to the same
Symbolicator image list accross multiple CrashLog objects.

To address this, this patch changes the default argument value for the
image parameter to None and only initialize it as an empty list when
no argument was passed.

This also removes the image list stored in each CrashLog parsers since
they shouldn't have any state and should be re-usable. So now, the only
source of truth is stored in the CrashLog object.

rdar://84984949

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

[bulbazord]

Python default parameter values strike again!

[JDevlieghere]

LGTM. The images list was added in D146765. Do you remember why we needed it there and why we don't anymore?

lldb/examples/python/crashlog.py

def create(debugger, path, options):
             parser.data = data
             return parser
         else:
             return TextCrashLogParser(debugger, path, options)
 
     def __init__(self, debugger, path, options):
         self.path = os.path.expanduser(path)
         self.options = options
-        # List of DarwinImages sorted by their index.
-        self.images = list()
         self.crashlog = CrashLog(debugger, self.path, self.options.verbose)
 
     @abc.abstractmethod
     def parse(self):
         pass
 
 
 class JSONCrashLogParser(CrashLogParser):
def parse_images(self, json_images):
             version = ""
             darwin_image = self.crashlog.DarwinImage(
                 low, high, name, version, img_uuid, path, self.options.verbose
             )
             if "arch" in json_image:
                 darwin_image.arch = json_image["arch"]
                 if path == self.crashlog.process_path:
                     self.crashlog.process_arch = darwin_image.arch
-            self.images.append(darwin_image)
             self.crashlog.images.append(darwin_image)
 
     def parse_main_image(self, json_data):
         if "procName" in json_data:
             proc_name = json_data["procName"]
             self.crashlog.set_main_image(proc_name)
 
     def parse_frames(self, thread, json_frames):
def parse_frames(self, thread, json_frames):
             image_addr = self.get_used_image(image_id)["base"]
             pc = image_addr + frame_offset
 
             if "symbol" in json_frame:
                 symbol = json_frame["symbol"]
                 location = 0
                 if "symbolLocation" in json_frame and json_frame["symbolLocation"]:
                     location = int(json_frame["symbolLocation"])
-                image = self.images[image_id]
+                image = self.crashlog.images[image_id]
                 image.symbols[symbol] = {
                     "name": symbol,
                     "type": "code",
                     "address": frame_offset - location,
                 }
 
             thread.frames.append(self.crashlog.Frame(idx, pc, frame_offset))
 
def parse_asi_backtrace(self, thread, bt):
 
             description = ""
             if frame_img_name and frame_addr and frame_symbol:
                 description = frame_symbol
                 frame_offset_value = 0
                 if frame_offset:
                     description += " + " + frame_offset
                     frame_offset_value = int(frame_offset, 0)
-                for image in self.images:
+                for image in self.crashlog.images:
                     if image.identifier == frame_img_name:
                         image.symbols[frame_symbol] = {
                             "name": frame_symbol,
                             "type": "code",
                             "address": int(frame_addr, 0) - frame_offset_value,
                         }
 
             thread.frames.append(
def parse_thread_registers(self, json_thread_state, prefix=None):
             except (KeyError, ValueError, TypeError):
                 pass
         return registers
 
     def parse_errors(self, json_data):
         if "reportNotes" in json_data:
             self.crashlog.errors = json_data["reportNotes"]
 
+
 class TextCrashLogParser(CrashLogParser):
     parent_process_regex = re.compile(r"^Parent Process:\s*(.*)\[(\d+)\]")
     thread_state_regex = re.compile(r"^Thread \d+ crashed with")
     thread_instrs_regex = re.compile(r"^Thread \d+ instruction stream")
     thread_regex = re.compile(r"^Thread (\d+).*:")
     app_backtrace_regex = re.compile(r"^Application Specific Backtrace (\d+).*:")
 
     class VersionRegex:
class TextCrashLogParser(CrashLogParser):
     exception_type_regex = re.compile(
         r"^Exception Type:\s+(EXC_[A-Z_]+)(?:\s+\((.*)\))?"
     )
     exception_codes_regex = re.compile(
         r"^Exception Codes:\s+(0x[0-9a-fA-F]+),\s*(0x[0-9a-fA-F]+)"
     )
     exception_extra_regex = re.compile(r"^Exception\s+.*:\s+(.*)")
 
-
     class CrashLogParseMode:
         NORMAL = 0
         THREAD = 1
         IMAGES = 2
         THREGS = 3
         SYSTEM = 4
         INSTRS = 5
 
def parse_images(self, line):
                 for symbol in self.symbols[unqualified_img_name]:
                     image.symbols[symbol["name"]] = {
                         "name": symbol["name"],
                         "type": "code",
                         # NOTE: "address" is actually the symbol image offset
                         "address": symbol["address"] - int(img_lo, 0),
                     }
 
-            self.images.append(image)
             self.crashlog.images.append(image)
             return True
         else:
             if self.options.debug:
                 print("error: image regex failed for: %s" % line)
             return False
 
     def parse_thread_registers(self, line):

lldb/examples/python/symbolication.py

def create_target(self, debugger):
             print(
                 'error: unable to locate main executable (%s) "%s"'
                 % (self.arch, self.path)
             )
         return None
 
 
 class Symbolicator:
-    def __init__(self, debugger=None, target=None, images=list()):
+    def __init__(self, debugger=None, target=None, images=None):
         """A class the represents the information needed to symbolicate
         addresses in a program.
 
         Do not call this initializer directly, but rather use the factory
         methods.
         """
         self.debugger = debugger
         self.target = target
-        self.images = images  # a list of images to be used when symbolicating
+        # a list of images to be used when symbolicating
+        self.images = images if images else list()
         self.addr_mask = 0xFFFFFFFFFFFFFFFF
 
     @classmethod
     def InitWithSBTarget(cls, target):
         """Initialize a new Symbolicator with an existing SBTarget."""
         obj = cls(target=target)
         triple = target.triple
         if triple: