save_crashlog should not be using the load_addr property of an SBAddress

[jingham]

Summary

The load_addr property relies on there being a variable called "target" in the current module. It is explicitly marked only to be used in the interactive interpreter, and not in commands.

We used to be sloppy about leaving lldb.target sitting around in the script interpreter between uses of the interactive interpreter, so this mostly worked (unless the current target the last time you used the script interpreter wasn't the current target when you ran the command...)

But Jonas cleaned that up a little while ago. That uncovered the bug in save_crashlog.

I added a quick test. You could definitely do more rigorous testing of the output here, but this is better than the previous nothing, and what I have time for.

[friss]

Thanks for adding a test! this LGTM

lldb/examples/python/crashlog.py

if target:
             for (frame_idx, frame) in enumerate(thread.frames):
                 frame_pc = frame.pc
                 frame_offset = 0
                 if frame.function:
                     block = frame.GetFrameBlock()
                     block_range = block.range[frame.addr]
                     if block_range:
                         block_start_addr = block_range[0]
-                        frame_offset = frame_pc - block_start_addr.load_addr
+                        frame_offset = frame_pc - block_start_addr.GetLoadAddress(target)
                     else:
-                        frame_offset = frame_pc - frame.function.addr.load_addr
+                        frame_offset = frame_pc - frame.function.addr.GetLoadAddress(target)
                 elif frame.symbol:
-                    frame_offset = frame_pc - frame.symbol.addr.load_addr
+                    frame_offset = frame_pc - frame.symbol.addr.GetLoadAddress(target)
                 out_file.write(
                     '%-3u %-32s 0x%16.16x %s' %
                     (frame_idx, frame.module.file.basename, frame_pc, frame.name))
                 if frame_offset > 0:
                     out_file.write(' + %u' % (frame_offset))
                 line_entry = frame.line_entry
                 if line_entry:
                     if options.verbose:

lldb/test/API/macosx/save_crashlog/Makefile

+C_SOURCES := main.c
+CFLAGS_EXTRAS := -std=c99
+
+include Makefile.rules

lldb/test/API/macosx/save_crashlog/TestSaveCrashlog.py

+"""
+Test that the save_crashlog command functions
+"""
+
+
+import os
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+
+
+class TestSaveCrashlog(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    # If your test case doesn't stress debug info, the
+    # set this to true.  That way it won't be run once for
+    # each debug info format.
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @skipUnlessDarwin
+    def test_save_crashlog(self):
+        """There can be many tests in a test case - describe this test here."""
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.c")
+        self.save_crashlog()
+
+    def save_crashlog(self):
+
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                   "I was called", self.main_source_file)
+
+        self.runCmd("command script import lldb.macosx.crashlog")
+        out_file = os.path.join(self.getBuildDir(), "crash.log")
+        self.runCmd("save_crashlog '%s'"%(out_file))
+
+        # Make sure we wrote the file:
+        self.assertTrue(os.path.exists(out_file), "We wrote our file")
+        
+        # Now scan the file to make sure it looks right:
+        # First get a few facts we'll use:
+        exe_module = target.FindModule(target.GetExecutable())
+        uuid_str = exe_module.GetUUIDString()
+
+        # We'll set these to true when we find the elements in the file
+        found_call_me = False
+        found_main_line = False
+        found_thread_header = False
+        found_uuid_str = False
+
+        with open(out_file, "r") as f:
+            # We want to see a line with
+            for line in f:
+                if "Thread 0:" in line:
+                    found_thread_header = True
+                if "call_me" in line and "main.c:" in line:
+                    found_call_me = True
+                if "main" in line and "main.c:" in line:
+                    found_main_line = True
+                if uuid_str in line and "a.out" in line:
+                    found_uuid_str = True
+        
+        self.assertTrue(found_thread_header, "Found thread header")
+        self.assertTrue(found_call_me, "Found call_me line in stack")
+        self.assertTrue(found_uuid_str, "Found main binary UUID")
+        self.assertTrue(found_main_line, "Found main line in call stack")
+                        

lldb/test/API/macosx/save_crashlog/main.c

+#include <stdio.h>
+
+void
+call_me() {
+  printf("I was called");
+}
+
+int
+main()
+{
+  call_me();
+  return 0;
+}