If the expression parser is unable to complete a TagDecl

in the context in which it was originally found, the
expression parser now goes hunting for it in all modules
(in the appropriate namespace, if applicable).  This means
that forward-declared types that exist in another shared
library will now be resolved correctly.

Added a test case to cover this.  The test case also tests
"frame variable," which does not have this functionality
yet.


git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@146204 91177308-0d34-0410-b5e6-96231b3b80d8

5 files changed, 133 insertions, 0 deletions

diff --git a/test/lang/c/shared_lib/Makefile b/test/lang/c/shared_lib/Makefile
new file mode 100644
index 000000000..9d9972acd
--- /dev/null
+++ b/test/lang/c/shared_lib/Makefile
@@ -0,0 +1,7 @@
+LEVEL = ../../../make
+
+DYLIB_NAME := libfoo
+DYLIB_C_SOURCES := foo.c
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
diff --git a/test/lang/c/shared_lib/TestSharedLib.py b/test/lang/c/shared_lib/TestSharedLib.py
new file mode 100644
index 000000000..f0dbbb76d
--- /dev/null
+++ b/test/lang/c/shared_lib/TestSharedLib.py
@@ -0,0 +1,79 @@
+"""Test that types defined in shared libraries work correctly."""
+
+import os, time
+import unittest2
+import lldb
+from lldbtest import *
+
+class SharedLibTestCase(TestBase):
+
+    mydir = os.path.join("lang", "c", "shared_lib")
+
+    def test_expr_with_dsym(self):
+        """Test that types work when defined in a shared library and forward-declared in the main executable"""
+        self.buildDsym()
+        self.expr()
+
+    def test_expr_with_dwarf(self):
+        """Test that types work when defined in a shared library and forward-declared in the main executable"""
+        self.buildDwarf()
+        self.expr()
+
+    def test_frame_variable_with_dsym(self):
+        """Test that types work when defined in a shared library and forward-declared in the main executable"""
+        self.buildDsym()
+        self.frame_var()
+
+    def test_frame_variable_with_dwarf(self):
+        """Test that types work when defined in a shared library and forward-declared in the main executable"""
+        self.buildDwarf()
+        self.frame_var()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break inside main().
+        self.line = line_number('main.c', '// Set breakpoint 0 here.')
+
+    def common_setup(self):
+        exe = os.path.join(os.getcwd(), "a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        # Break inside the foo function which takes a bar_ptr argument.
+        self.expect("breakpoint set -f main.c -l %d" % self.line, BREAKPOINT_CREATED,
+            startstr = "Breakpoint created")
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'stop reason = breakpoint'])
+
+        # The breakpoint should have a hit count of 1.
+        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
+            substrs = [' resolved, hit count = 1'])
+
+    def expr(self):
+        """Test that types work when defined in a shared library and forward-declared in the main executable"""
+	self.common_setup()
+
+        # This should display correctly.
+        self.expect("expression *my_foo_ptr", VARIABLES_DISPLAYED_CORRECTLY,
+            substrs = ["(foo)", "(sub_foo)", "other_element = 3"])
+
+    @unittest2.expectedFailure
+    # rdar://problem/10381325
+    def frame_var(self):
+        """Test that types work when defined in a shared library and forward-declared in the main executable"""
+	self.common_setup()
+
+        # This should display correctly.
+        self.expect("frame variable *my_foo_ptr", VARIABLES_DISPLAYED_CORRECTLY,
+            substrs = ["(foo)", "(sub_foo)", "other_element = 3"])
+                       
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()
diff --git a/test/lang/c/shared_lib/foo.c b/test/lang/c/shared_lib/foo.c
new file mode 100644
index 000000000..6431bc496
--- /dev/null
+++ b/test/lang/c/shared_lib/foo.c
@@ -0,0 +1,22 @@
+#include "foo.h"
+#include <stdlib.h>
+
+struct foo
+{
+  struct sub_foo sub_element;
+  int    other_element;
+};
+
+struct foo *
+GetMeAFoo()
+{
+  struct foo *ret_val = (struct foo *) malloc (sizeof (struct foo));
+  ret_val->other_element = 3;
+  return ret_val;
+}
+
+struct sub_foo *
+GetMeASubFoo (struct foo *in_foo)
+{
+  return &(in_foo->sub_element);
+}
diff --git a/test/lang/c/shared_lib/foo.h b/test/lang/c/shared_lib/foo.h
new file mode 100644
index 000000000..78b3c1245
--- /dev/null
+++ b/test/lang/c/shared_lib/foo.h
@@ -0,0 +1,12 @@
+struct foo;
+
+struct sub_foo
+{
+  int sub_1;
+  char *sub_2;
+};
+
+struct foo *GetMeAFoo();
+struct sub_foo *GetMeASubFoo (struct foo *in_foo);
+
+
diff --git a/test/lang/c/shared_lib/main.c b/test/lang/c/shared_lib/main.c
new file mode 100644
index 000000000..dc4dc3189
--- /dev/null
+++ b/test/lang/c/shared_lib/main.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include "foo.h"
+
+int 
+main ()
+{
+  struct foo *my_foo_ptr;
+  my_foo_ptr = GetMeAFoo();
+  // Set breakpoint 0 here.
+  printf ("My sub foo has: %d.\n", GetMeASubFoo(my_foo_ptr)->sub_1);
+
+  return 0;
+}