Fix Pavel's patch for ValueObjectVariables with complex DWARF expressions

to work with Swift's complex Synthetic variable structures.

Pavel's patch is appropriate for children of ValueObjectVariables but
not for synthetic children.  This patch ensures that we only do the
computation where appropriate.

The patch is being discussed w.r.t. the llvm.org sources as:

https://reviews.llvm.org/D83450

This change is to get it onto the 5.3 branch w/o having to wait for
the resolution of that discussion.

<rdar://problem/64209516>

Author: jimingham

lldb/include/lldb/Core/ValueObject.h

@@ -971,6 +971,13 @@ class ValueObject : public UserID {
 
   void SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType);
 
+  void UpdateChildrenAddressType() {
+    GetRoot()->DoUpdateChildrenAddressType(*this);
+  }
+
+protected:
+  virtual void DoUpdateChildrenAddressType(ValueObject &valobj) { return; };
+
 private:
   virtual CompilerType MaybeCalculateCompleteType();
 

lldb/include/lldb/Core/ValueObjectVariable.h

@@ -67,6 +67,8 @@ class ValueObjectVariable : public ValueObject {
 
 protected:
   bool UpdateValue() override;
+  
+  void DoUpdateChildrenAddressType(ValueObject &valobj) override;
 
   CompilerType GetCompilerTypeImpl() override;
 

lldb/source/Core/ValueObjectVariable.cpp

@@ -331,9 +331,64 @@ bool ValueObjectVariable::UpdateValue() {
       m_resolved_value.SetContext(Value::eContextTypeInvalid, nullptr);
     }
   }
+  
   return m_error.Success();
 }
 
+void ValueObjectVariable::DoUpdateChildrenAddressType(ValueObject &valobj) {
+  Value::ValueType value_type = valobj.GetValue().GetValueType();
+  ExecutionContext exe_ctx(GetExecutionContextRef());
+  Process *process = exe_ctx.GetProcessPtr();
+  const bool process_is_alive = process && process->IsAlive();
+  const uint32_t type_info = valobj.GetCompilerType().GetTypeInfo();
+  const bool is_pointer_or_ref =
+      (type_info & (lldb::eTypeIsPointer | lldb::eTypeIsReference)) != 0;
+
+  switch (value_type) {
+  case Value::eValueTypeFileAddress:
+    // If this type is a pointer, then its children will be considered load
+    // addresses if the pointer or reference is dereferenced, but only if
+    // the process is alive.
+    //
+    // There could be global variables like in the following code:
+    // struct LinkedListNode { Foo* foo; LinkedListNode* next; };
+    // Foo g_foo1;
+    // Foo g_foo2;
+    // LinkedListNode g_second_node = { &g_foo2, NULL };
+    // LinkedListNode g_first_node = { &g_foo1, &g_second_node };
+    //
+    // When we aren't running, we should be able to look at these variables
+    // using the "target variable" command. Children of the "g_first_node"
+    // always will be of the same address type as the parent. But children
+    // of the "next" member of LinkedListNode will become load addresses if
+    // we have a live process, or remain a file address if it was a file
+    // address.
+    if (process_is_alive && is_pointer_or_ref)
+      valobj.SetAddressTypeOfChildren(eAddressTypeLoad);
+    else
+      valobj.SetAddressTypeOfChildren(eAddressTypeFile);
+    break;
+  case Value::eValueTypeHostAddress:
+    // Same as above for load addresses, except children of pointer or refs
+    // are always load addresses. Host addresses are used to store freeze
+    // dried variables. If this type is a struct, the entire struct
+    // contents will be copied into the heap of the
+    // LLDB process, but we do not currently follow any pointers.
+    if (is_pointer_or_ref)
+      valobj.SetAddressTypeOfChildren(eAddressTypeLoad);
+    else
+      valobj.SetAddressTypeOfChildren(eAddressTypeHost);
+    break;
+  case Value::eValueTypeLoadAddress:
+  case Value::eValueTypeScalar:
+  case Value::eValueTypeVector:
+    valobj.SetAddressTypeOfChildren(eAddressTypeLoad);
+    break;
+  }
+}
+
+
+
 bool ValueObjectVariable::IsInScope() {
   const ExecutionContextRef &exe_ctx_ref = GetExecutionContextRef();
   if (exe_ctx_ref.HasFrameRef()) {

lldb/test/API/lang/swift/optional_of_resilient/Makefile

@@ -0,0 +1,14 @@
+SWIFT_SOURCES := main.swift
+
+all: libmod.dylib a.out
+
+include Makefile.rules
+LD_EXTRAS = -lmod -L$(BUILDDIR)
+SWIFTFLAGS_EXTRAS = -I$(BUILDDIR)
+
+libmod.dylib: mod.swift
+	$(MAKE) MAKE_DSYM=YES CC=$(CC) SWIFTC=$(SWIFTC) \
+		ARCH=$(ARCH) DSYMUTIL=$(DSYMUTIL) \
+		BASENAME=mod \
+		SWIFTFLAGS_EXTRAS="-I$(BUILDDIR) -enable-library-evolution" \
+		VPATH=$(SRCDIR) -I $(SRCDIR) -f $(SRCDIR)/dylib.mk all

lldb/test/API/lang/swift/optional_of_resilient/TestResilientObjectInOptional.py

@@ -0,0 +1,73 @@
+# TestResilientObjectInOptional.py
+#
+# This source file is part of the Swift.org open source project
+#
+# Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+# Licensed under Apache License v2.0 with Runtime Library Exception
+#
+# See https://swift.org/LICENSE.txt for license information
+# See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+#
+# ------------------------------------------------------------------------------
+"""
+Test that we can extract a resilient object from an Optional
+"""
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import unittest2
+
+class TestResilientObjectInOptional(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipUnlessDarwin
+    @swiftTest
+    def test_optional_of_resilient(self):
+        """Test that can extract resilient objects from an Optional"""
+        self.build()
+        self.doTest()
+
+    def setUp(self):
+        TestBase.setUp(self)
+
+    def doTest(self):
+        exe_name = "a.out"
+        exe_path = self.getBuildArtifact(exe_name)
+        
+        source_name = "main.swift"
+        source_spec = lldb.SBFileSpec(source_name)
+        print("Looking for executable at: %s"%(exe_name))
+        target = self.dbg.CreateTarget(exe_path)
+        self.assertTrue(target, VALID_TARGET)
+        self.registerSharedLibrariesWithTarget(target, ['mod'])
+
+        target, process, thread, breakpoint = lldbutil.run_to_source_breakpoint(
+            self, "break here", source_spec, exe_name=exe_path)
+
+        frame = thread.frames[0]
+        
+        # First try getting a non-resilient optional, to make sure that
+        # part isn't broken:
+        t_opt_var = frame.FindVariable("t_opt")
+        self.assertTrue(t_opt_var.GetError().Success(), "Made t_opt value object")
+        t_a_var = t_opt_var.GetChildMemberWithName("a")
+        self.assertTrue(t_a_var.GetError().Success(), "The child was a")
+        lldbutil.check_variable(self, t_a_var, False, value="2")
+        
+        # Make sure we can print an optional of a resilient type...
+        # If we got the value out of the optional correctly, then
+        # it's child will be "a".
+        # First do this with "frame var":
+        opt_var = frame.FindVariable("s_opt")
+        self.assertTrue(opt_var.GetError().Success(), "Made s_opt value object")
+        a_var = opt_var.GetChildMemberWithName("a")
+        self.assertTrue(a_var.GetError().Success(), "The resilient child was 'a'")
+        lldbutil.check_variable(self, a_var, False, value="1")
+        
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lldb.SBDebugger.Terminate)
+    unittest2.main()

lldb/test/API/lang/swift/optional_of_resilient/dylib.mk

@@ -0,0 +1,4 @@
+DYLIB_ONLY := YES
+DYLIB_NAME := $(BASENAME)
+DYLIB_SWIFT_SOURCES := $(DYLIB_NAME).swift
+include Makefile.rules

lldb/test/API/lang/swift/optional_of_resilient/main.swift

@@ -0,0 +1,36 @@
+// main.swift
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+// -----------------------------------------------------------------------------
+import mod
+
+// This is the same as mod.S to make it easier to
+// compare the reconstruction of the resilient and non-resilient types.
+struct T {
+  public var a = 2
+  fileprivate var s1 = "I"
+  fileprivate var s2 = "AM"
+  fileprivate var s3 = "LARGE"
+  fileprivate var s4 = "!!"
+
+  public init() {}
+}
+
+func main() {
+  initGlobal()
+  let s = S()
+  let s_opt : Optional<S> = s
+  let t = T()
+  let t_opt : Optional<T> = t
+  print(s.a) // break here
+}
+
+main()
+

lldb/test/API/lang/swift/optional_of_resilient/mod.swift

@@ -0,0 +1,45 @@
+// mod.a.swift
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+// -----------------------------------------------------------------------------
+
+public struct S {
+  public var a = 1
+  fileprivate var s1 = "i"
+  fileprivate var s2 = "am"
+  fileprivate var s3 = "large"
+  fileprivate var s4 = "!"
+
+  public init() {}
+}
+
+fileprivate class Message { fileprivate var s = "hello" }
+fileprivate struct NotBitwiseTakable {
+  fileprivate weak var msg : Message?
+}
+
+fileprivate struct FixedContainer {
+    var s = S()
+}
+
+fileprivate var g_msg = Message()
+fileprivate var g_b = NotBitwiseTakable()
+fileprivate var g_s = S()
+fileprivate var g_t = (S(), S())
+fileprivate var g_c = FixedContainer()
+
+public func initGlobal() -> Int {
+  g_b.msg = g_msg
+  return g_s.a + g_t.0.a + g_c.s.a
+}
+
+public func fA(_ x: S) -> Int {
+  return x.a
+}