[lldb/crashlog] Remove tempfile prefix from inlined symbol object file

[mib]

Summary

This patch changes the way we generate the ObjectFileJSON files
containing the inlined symbols from the crash report to remove the
tempfile prefix from the object file name.

To do so, instead of creating a new tempfile for each module, we create a
temporary directory that contains each module object file with the same
name as the module.

This makes the backtraces only contain the module name without the
temfile prefix which makes it look like a regular stackframe.

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

[JDevlieghere]

lldb/examples/python/crashlog.py

1162–1165

Can you call obj_dir.cleanup(), or better, can you wrap this in a with tempfile.TemporaryDirectory() as obj_dir:?

lldb/examples/python/scripted_process/crashlog_scripted_process.py

41

Same comment/question here.

lldb/examples/python/symbolication.py

371

If the obj_dir is created this way, it will never be removed. Is anyone relying on the default argument? If not I would make it None and change the check on line 387 to if obj_dir:.

[bulbazord]

lldb/examples/python/crashlog.py

1162–1165

+1

lldb/examples/python/symbolication.py

371

+1 on this, we need to cleanup resources.

[mib]

Address @JDevlieghere & @bulbazord comments.

[mib]

More refactoring

[bulbazord]

LGTM

lldb/examples/python/crashlog.py

 import os
 import platform
 import plistlib
 import re
 import shlex
 import string
 import subprocess
 import sys
+import tempfile
 import threading
 import time
 import uuid
 
 
 print_lock = threading.RLock()
 
 try:
elif options.crashed_only:
             if thread.did_crash():
                 for ident in thread.idents:
                     for image in self.crashlog.find_images_with_identifier(ident):
                         image.resolve = True
 
     futures = []
     loaded_images = []
     with concurrent.futures.ThreadPoolExecutor() as executor:
-        def add_module(image, target):
-            return image, image.add_module(target)
+        with tempfile.TemporaryDirectory() as obj_dir:
 
-        for image in crash_log.images:
-            futures.append(executor.submit(add_module, image=image, target=target))
+            def add_module(image, target, obj_dir):
+                return image, image.add_module(target, obj_dir)
 
+            for image in crash_log.images:
+                futures.append(
+                    executor.submit(
+                        add_module, image=image, target=target, obj_dir=obj_dir
+                    )
+                )
         for future in concurrent.futures.as_completed(futures):
             image, err = future.result()
             if err:
                 print(err)
             else:
                 loaded_images.append(image)
 
     if crash_log.backtraces:

lldb/examples/python/scripted_process/crashlog_scripted_process.py

-import os,json,struct,signal,uuid
+import os, json, struct, signal, uuid, tempfile
 
 from typing import Any, Dict
 
 import lldb
 from lldb.plugins.scripted_process import ScriptedProcess
 from lldb.plugins.scripted_process import ScriptedThread
 
 from lldb.macosx.crashlog import CrashLog,CrashLogParser
def set_crashlog(self, crashlog):
                 image.resolve = True
         else:
             for thread in self.crashlog.threads:
                 if thread.did_crash():
                     for ident in thread.idents:
                         for image in self.crashlog.find_images_with_identifier(ident):
                             image.resolve = True
 
+        with tempfile.TemporaryDirectory() as obj_dir:
             for image in self.crashlog.images:
                 if image not in self.loaded_images:
                     if image.uuid == uuid.UUID(int=0):
                         continue
-                err = image.add_module(self.target)
+                    err = image.add_module(self.target, obj_dir)
                     if err:
                         # Append to SBCommandReturnObject
                         print(err)
                     else:
                         self.loaded_images.append(image)
 
         for thread in self.crashlog.threads:
             if hasattr(thread, 'app_specific_backtrace') and thread.app_specific_backtrace:
                 # We don't want to include the Application Specific Backtrace
                 # Thread into the Scripted Process' Thread list.
                 # Instead, we will try to extract the stackframe pcs from the
                 # backtrace and inject that as the extended thread info.
                 self.app_specific_thread = thread

lldb/examples/python/symbolication.py

def load_module(self, target):
                     return None
                 else:
                     return 'error: invalid module'
             else:
                 return 'error: invalid target'
         else:
             return 'error: no section infos'
 
-    def add_module(self, target):
+    def add_module(self, target, obj_dir=None):
         '''Add the Image described in this object to "target" and load the sections if "load" is True.'''
         if target:
             # Try and find using UUID only first so that paths need not match
             # up
             uuid_str = self.get_normalized_uuid_string()
             if uuid_str:
                 self.module = target.AddModule(None, None, uuid_str)
             if not self.module and self.resolve:
                 self.locate_module_and_debug_symbols()
                 if not self.unavailable:
                     resolved_path = self.get_resolved_path()
                     self.module = target.AddModule(
                         resolved_path, None, uuid_str, self.symfile)
             if not self.module and self.section_infos:
                 name = os.path.basename(self.path)
-                with tempfile.NamedTemporaryFile(suffix='.' + name) as tf:
+                if obj_dir and os.path.isdir(obj_dir):
                     data = {
                         'triple': target.triple,
                         'uuid': uuid_str,
                         'type': 'sharedlibrary',
                         'sections': list(),
                         'symbols': list()
                     }
                     for section in self.section_infos:
                         data['sections'].append({
                             'name' : section.name,
                             'size': section.end_addr - section.start_addr
                             })
                     data['symbols'] = list(self.symbols.values())
-                    with open(tf.name, 'w') as f:
+                    obj_file = os.path.join(obj_dir, name)
+                    with open(obj_file, "w") as f:
                         f.write(json.dumps(data, indent=4))
-                    self.module = target.AddModule(tf.name, None, uuid_str)
+                    self.module = target.AddModule(obj_file, None, uuid_str)
                     if self.module:
                         # If we were able to add the module with inlined
                         # symbols, we should mark it as available so load_module
                         # does not exit early.
                         self.unavailable = False
             if not self.module and not self.unavailable:
                 return 'error: unable to get module for (%s) "%s"' % (
                     self.arch, self.get_resolved_path())