Merge pull request #5562 from medismailben/stable/20220421

Cherry-pick many LLDB improvements

Author: medismailben

lldb/examples/python/crashlog.py

@@ -462,6 +462,12 @@ def parse(self):
             self.parse_images(self.data['usedImages'])
             self.parse_main_image(self.data)
             self.parse_threads(self.data['threads'])
+            if 'asi' in self.data:
+                self.crashlog.asi = self.data['asi']
+            if 'asiBacktraces' in self.data:
+                self.parse_app_specific_backtraces(self.data['asiBacktraces'])
+            if 'lastExceptionBacktrace' in self.data:
+                self.crashlog.asb = self.data['lastExceptionBacktrace']
             self.parse_errors(self.data)
             thread = self.crashlog.threads[self.crashlog.crashed_thread_idx]
             reason = self.parse_crash_reason(self.data['exception'])
@@ -573,6 +579,31 @@ def parse_threads(self, json_threads):
             self.crashlog.threads.append(thread)
             idx += 1
 
+    def parse_asi_backtrace(self, thread, bt):
+        for line in bt.split('\n'):
+            frame_match = TextCrashLogParser.frame_regex.search(line)
+            if not frame_match:
+                print("error: can't parse application specific backtrace.")
+                return False
+
+            (frame_id, frame_img_name, frame_addr,
+                frame_ofs) = frame_match.groups()
+
+            thread.add_ident(frame_img_name)
+            if frame_img_name not in self.crashlog.idents:
+                self.crashlog.idents.append(frame_img_name)
+            thread.frames.append(self.crashlog.Frame(int(frame_id), int(
+                frame_addr, 0), frame_ofs))
+
+        return True
+
+    def parse_app_specific_backtraces(self, json_app_specific_bts):
+        for idx, backtrace in enumerate(json_app_specific_bts):
+            thread = self.crashlog.Thread(idx, True)
+            thread.queue = "Application Specific Backtrace"
+            if self.parse_asi_backtrace(thread, backtrace):
+                self.crashlog.threads.append(thread)
+
     def parse_thread_registers(self, json_thread_state, prefix=None):
         registers = dict()
         for key, state in json_thread_state.items():
@@ -613,17 +644,17 @@ class TextCrashLogParser(CrashLogParser):
     frame_regex = re.compile(r'^(\d+)\s+'              # id
                              r'(.+?)\s+'               # img_name
                              r'(?:' +version+ r'\s+)?' # img_version
-                             r'(0x[0-9a-fA-F]{7,})'    # addr (7 chars or more)
+                             r'(0x[0-9a-fA-F]{4,})'    # addr (4 chars or more)
                              r' +(.*)'                 # offs
                             )
-    null_frame_regex = re.compile(r'^\d+\s+\?\?\?\s+0{7,} +')
+    null_frame_regex = re.compile(r'^\d+\s+\?\?\?\s+0{4,} +')
     image_regex_uuid = re.compile(r'(0x[0-9a-fA-F]+)'          # img_lo
                                   r'\s+-\s+'                   #   -
                                   r'(0x[0-9a-fA-F]+)\s+'       # img_hi
                                   r'[+]?(.+?)\s+'              # img_name
                                   r'(?:(' +version+ r')\s+)?'  # img_version
                                   r'(?:<([-0-9a-fA-F]+)>\s+)?' # img_uuid
-                                  r'(/.*)'                     # img_path
+                                  r'(\?+|/.*)'                 # img_path
                                  )
     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]+)')
@@ -1102,8 +1133,8 @@ def synchronous(debugger):
             run_options.SetEchoCommands(True)
 
             commands_stream = lldb.SBStream()
-            commands_stream.Print("process status\n")
-            commands_stream.Print("thread backtrace\n")
+            commands_stream.Print("process status --verbose\n")
+            commands_stream.Print("thread backtrace --extended true\n")
             error = debugger.SetInputString(commands_stream.GetData())
             if error.Success():
                 debugger.RunCommandInterpreter(True, False, run_options, 0, False, True)

lldb/examples/python/scripted_process/crashlog_scripted_process.py

@@ -18,6 +18,11 @@ def parse_crashlog(self):
         self.crashed_thread_idx = crash_log.crashed_thread_idx
         self.loaded_images = []
         self.exception = crash_log.exception
+        self.app_specific_thread = None
+        if hasattr(crash_log, 'asi'):
+            self.metadata['asi'] = crash_log.asi
+        if hasattr(crash_log, 'asb'):
+            self.extended_thread_info = crash_log.asb
 
         def load_images(self, images):
             #TODO: Add to self.loaded_images and load images in lldb
@@ -40,8 +45,23 @@ def load_images(self, images):
                 for ident in thread.idents:
                     load_images(self, crash_log.find_images_with_identifier(ident))
 
+            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
+                continue
+
             self.threads[thread.index] = CrashLogScriptedThread(self, None, thread)
 
+
+        if self.app_specific_thread:
+            self.extended_thread_info = \
+                    CrashLogScriptedThread.resolve_stackframes(self.app_specific_thread,
+                                                               self.addr_mask,
+                                                               self.target)
+
     def __init__(self, target: lldb.SBTarget, args : lldb.SBStructuredData):
         super().__init__(target, args)
 
@@ -71,6 +91,7 @@ def __init__(self, target: lldb.SBTarget, args : lldb.SBStructuredData):
         self.pid = super().get_process_id()
         self.crashed_thread_idx = 0
         self.exception = None
+        self.extended_thread_info = None
         self.parse_crashlog()
 
     def get_memory_region_containing_address(self, addr: int) -> lldb.SBMemoryRegionInfo:
@@ -103,6 +124,9 @@ def is_alive(self) -> bool:
     def get_scripted_thread_plugin(self):
         return CrashLogScriptedThread.__module__ + "." + CrashLogScriptedThread.__name__
 
+    def get_process_metadata(self):
+        return self.metadata
+
 class CrashLogScriptedThread(ScriptedThread):
     def create_register_ctx(self):
         if not self.has_crashed:
@@ -120,21 +144,29 @@ def create_register_ctx(self):
 
         return self.register_ctx
 
+    def resolve_stackframes(thread, addr_mask, target):
+        frames = []
+        for frame in thread.frames:
+            frame_pc = frame.pc & addr_mask
+            pc = frame_pc if frame.index == 0  or frame_pc == 0 else frame_pc - 1
+            sym_addr = lldb.SBAddress()
+            sym_addr.SetLoadAddress(pc, target)
+            if not sym_addr.IsValid():
+                continue
+            frames.append({"idx": frame.index, "pc": pc})
+        return frames
+
+
     def create_stackframes(self):
         if not (self.scripted_process.load_all_images or self.has_crashed):
             return None
 
         if not self.backing_thread or not len(self.backing_thread.frames):
             return None
 
-        for frame in self.backing_thread.frames:
-            frame_pc = frame.pc & self.scripted_process.addr_mask
-            pc = frame_pc if frame.index == 0  or frame_pc == 0 else frame_pc - 1
-            sym_addr = lldb.SBAddress()
-            sym_addr.SetLoadAddress(pc, self.target)
-            if not sym_addr.IsValid():
-                continue
-            self.frames.append({"idx": frame.index, "pc": pc})
+        self.frames = CrashLogScriptedThread.resolve_stackframes(self.backing_thread,
+                                                                 self.scripted_process.addr_mask,
+                                                                 self.target)
 
         return self.frames
 
@@ -144,7 +176,10 @@ def __init__(self, process, args, crashlog_thread):
         self.backing_thread = crashlog_thread
         self.idx = self.backing_thread.index
         self.tid = self.backing_thread.id
-        self.name = self.backing_thread.name
+        if self.backing_thread.app_specific_backtrace:
+            self.name = "Application Specific Backtrace - " + str(self.idx)
+        else:
+            self.name = self.backing_thread.name
         self.queue = self.backing_thread.queue
         self.has_crashed = (self.scripted_process.crashed_thread_idx == self.idx)
         self.create_stackframes()
@@ -168,3 +203,9 @@ def get_register_context(self) -> str:
             self.register_ctx = self.create_register_ctx()
 
         return struct.pack("{}Q".format(len(self.register_ctx)), *self.register_ctx.values())
+
+    def get_extended_info(self):
+        if (self.has_crashed):
+            self.extended_info = self.scripted_process.extended_thread_info
+        return self.extended_info
+

lldb/examples/python/scripted_process/scripted_process.py

@@ -18,6 +18,7 @@ class ScriptedProcess(metaclass=ABCMeta):
     stack_memory_dump = None
     loaded_images = None
     threads = None
+    metadata = None
 
     @abstractmethod
     def __init__(self, target, args):
@@ -41,6 +42,7 @@ def __init__(self, target, args):
             self.args = args
         self.threads = {}
         self.loaded_images = []
+        self.metadata = {}
 
     @abstractmethod
     def get_memory_region_containing_address(self, addr):
@@ -138,7 +140,6 @@ def get_process_id(self):
         """
         return 0
 
-
     def launch(self):
         """ Simulate the scripted process launch.
 
@@ -191,6 +192,15 @@ def get_scripted_thread_plugin(self):
         """
         return None
 
+    def get_process_metadata(self):
+        """ Get some metadata for the scripted process.
+
+        Returns:
+            Dict: A dictionary containing metadata for the scripted process.
+                  None is the process as no metadata.
+        """
+        return self.metadata
+
 class ScriptedThread(metaclass=ABCMeta):
 
     """
@@ -226,6 +236,7 @@ def __init__(self, scripted_process, args):
         self.register_info = None
         self.register_ctx = {}
         self.frames = []
+        self.extended_info = []
 
         if isinstance(scripted_process, ScriptedProcess):
             self.target = scripted_process.target
@@ -334,6 +345,15 @@ def get_register_context(self):
         """
         pass
 
+    def get_extended_info(self):
+        """ Get scripted thread extended information.
+
+        Returns:
+            List: A list containing the extended information for the scripted process.
+                  None is the thread as no extended information.
+        """
+        return self.extended_info
+
 ARM64_GPR = [ {'name': 'x0',   'bitsize': 64, 'offset': 0,   'encoding': 'uint', 'format': 'hex', 'set': 0, 'gcc': 0,  'dwarf': 0,  'generic': 'arg0', 'alt-name': 'arg0'},
               {'name': 'x1',   'bitsize': 64, 'offset': 8,   'encoding': 'uint', 'format': 'hex', 'set': 0, 'gcc': 1,  'dwarf': 1,  'generic': 'arg1', 'alt-name': 'arg1'},
               {'name': 'x2',   'bitsize': 64, 'offset': 16,  'encoding': 'uint', 'format': 'hex', 'set': 0, 'gcc': 2,  'dwarf': 2,  'generic': 'arg2', 'alt-name': 'arg2'},

lldb/include/lldb/Core/StructuredDataImpl.h

@@ -80,7 +80,7 @@ class StructuredDataImpl {
         error.SetErrorString("No data to describe.");
         return error;
       }
-      m_data_sp->Dump(stream, true);
+      m_data_sp->GetDescription(stream);
       return error;
     }
     // Get the data's description.

lldb/include/lldb/Interpreter/CommandInterpreter.h

@@ -551,6 +551,9 @@ class CommandInterpreter : public Broadcaster,
   bool GetSaveSessionOnQuit() const;
   void SetSaveSessionOnQuit(bool enable);
 
+  bool GetOpenTranscriptInEditor() const;
+  void SetOpenTranscriptInEditor(bool enable);
+
   FileSpec GetSaveSessionDirectory() const;
   void SetSaveSessionDirectory(llvm::StringRef path);
 

lldb/include/lldb/Interpreter/ScriptedProcessInterface.h

@@ -24,7 +24,7 @@ class ScriptedProcessInterface : virtual public ScriptedInterface {
   CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx,
                      StructuredData::DictionarySP args_sp,
                      StructuredData::Generic *script_obj = nullptr) override {
-    return nullptr;
+    return {};
   }
 
   virtual Status Launch() { return Status("ScriptedProcess did not launch"); }
@@ -41,22 +41,22 @@ class ScriptedProcessInterface : virtual public ScriptedInterface {
     return {};
   }
 
-  virtual StructuredData::DictionarySP GetThreadsInfo() { return nullptr; }
+  virtual StructuredData::DictionarySP GetThreadsInfo() { return {}; }
 
   virtual StructuredData::DictionarySP GetThreadWithID(lldb::tid_t tid) {
-    return nullptr;
+    return {};
   }
 
   virtual StructuredData::DictionarySP GetRegistersForThread(lldb::tid_t tid) {
-    return nullptr;
+    return {};
   }
 
   virtual lldb::DataExtractorSP
   ReadMemoryAtAddress(lldb::addr_t address, size_t size, Status &error) {
-    return nullptr;
+    return {};
   }
 
-  virtual StructuredData::ArraySP GetLoadedImages() { return nullptr; }
+  virtual StructuredData::ArraySP GetLoadedImages() { return {}; }
 
   virtual lldb::pid_t GetProcessID() { return LLDB_INVALID_PROCESS_ID; }
 
@@ -66,10 +66,12 @@ class ScriptedProcessInterface : virtual public ScriptedInterface {
     return llvm::None;
   }
 
+  virtual StructuredData::DictionarySP GetMetadata() { return {}; }
+
 protected:
   friend class ScriptedThread;
   virtual lldb::ScriptedThreadInterfaceSP CreateScriptedThreadInterface() {
-    return nullptr;
+    return {};
   }
 };
 
@@ -79,7 +81,7 @@ class ScriptedThreadInterface : virtual public ScriptedInterface {
   CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx,
                      StructuredData::DictionarySP args_sp,
                      StructuredData::Generic *script_obj = nullptr) override {
-    return nullptr;
+    return {};
   }
 
   virtual lldb::tid_t GetThreadID() { return LLDB_INVALID_THREAD_ID; }
@@ -90,15 +92,17 @@ class ScriptedThreadInterface : virtual public ScriptedInterface {
 
   virtual llvm::Optional<std::string> GetQueue() { return llvm::None; }
 
-  virtual StructuredData::DictionarySP GetStopReason() { return nullptr; }
+  virtual StructuredData::DictionarySP GetStopReason() { return {}; }
 
-  virtual StructuredData::ArraySP GetStackFrames() { return nullptr; }
+  virtual StructuredData::ArraySP GetStackFrames() { return {}; }
 
-  virtual StructuredData::DictionarySP GetRegisterInfo() { return nullptr; }
+  virtual StructuredData::DictionarySP GetRegisterInfo() { return {}; }
 
   virtual llvm::Optional<std::string> GetRegisterContext() {
     return llvm::None;
   }
+
+  virtual StructuredData::ArraySP GetExtendedInfo() { return {}; }
 };
 } // namespace lldb_private
 

lldb/include/lldb/Target/Process.h

@@ -2447,6 +2447,13 @@ void PruneThreadPlans();
     return Status("Not supported");
   }
 
+  /// Fetch process defined metadata.
+  ///
+  /// \return
+  ///     A StructuredDataSP object which, if non-empty, will contain the
+  ///     information related to the process.
+  virtual StructuredData::DictionarySP GetMetadata() { return nullptr; }
+
   size_t AddImageToken(lldb::addr_t image_ptr);
 
   lldb::addr_t GetImagePtrFromToken(size_t token) const;