fixup! fix user-defined persistent variables

Author: igorkudrin

lldb/include/lldb/Expression/IRMemoryMap.h

@@ -50,8 +50,12 @@ class IRMemoryMap {
                                  ///only in the process.
   };
 
+  // If 'policy' is 'eAllocationPolicyMirror' but it is impossible to allocate
+  // memory in the process, 'eAllocationPolicyHostOnly' will be used instead.
+  // The actual policy is returned via 'used_policy'.
   lldb::addr_t Malloc(size_t size, uint8_t alignment, uint32_t permissions,
-                      AllocationPolicy policy, bool zero_memory, Status &error);
+                      AllocationPolicy policy, bool zero_memory, Status &error,
+                      AllocationPolicy *used_policy = nullptr);
   void Leak(lldb::addr_t process_address, Status &error);
   void Free(lldb::addr_t process_address, Status &error);
 

lldb/source/Expression/IRMemoryMap.cpp

@@ -321,7 +321,8 @@ IRMemoryMap::Allocation::Allocation(lldb::addr_t process_alloc,
 
 lldb::addr_t IRMemoryMap::Malloc(size_t size, uint8_t alignment,
                                  uint32_t permissions, AllocationPolicy policy,
-                                 bool zero_memory, Status &error) {
+                                 bool zero_memory, Status &error,
+                                 AllocationPolicy *used_policy) {
   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
   error.Clear();
 
@@ -455,6 +456,9 @@ lldb::addr_t IRMemoryMap::Malloc(size_t size, uint8_t alignment,
               (uint64_t)permissions, policy_string, aligned_address);
   }
 
+  if (used_policy)
+    *used_policy = policy;
+
   return aligned_address;
 }
 

lldb/source/Expression/Materializer.cpp

@@ -76,12 +76,14 @@ class EntityPersistentVariable : public Materializer::Entity {
 
     Status allocate_error;
     const bool zero_memory = false;
+    IRMemoryMap::AllocationPolicy used_policy;
 
     lldb::addr_t mem = map.Malloc(
         llvm::expectedToOptional(m_persistent_variable_sp->GetByteSize())
             .value_or(0),
         8, lldb::ePermissionsReadable | lldb::ePermissionsWritable,
-        IRMemoryMap::eAllocationPolicyMirror, zero_memory, allocate_error);
+        IRMemoryMap::eAllocationPolicyMirror, zero_memory, allocate_error,
+        &used_policy);
 
     if (!allocate_error.Success()) {
       err = Status::FromErrorStringWithFormat(
@@ -103,14 +105,22 @@ class EntityPersistentVariable : public Materializer::Entity {
         m_persistent_variable_sp->GetName(), mem, eAddressTypeLoad,
         map.GetAddressByteSize());
 
-    // Clear the flag if the variable will never be deallocated.
-
     if (m_persistent_variable_sp->m_flags &
         ExpressionVariable::EVKeepInTarget) {
-      Status leak_error;
-      map.Leak(mem, leak_error);
-      m_persistent_variable_sp->m_flags &=
-          ~ExpressionVariable::EVNeedsAllocation;
+      if (used_policy == IRMemoryMap::eAllocationPolicyMirror) {
+        // Clear the flag if the variable will never be deallocated.
+        Status leak_error;
+        map.Leak(mem, leak_error);
+        m_persistent_variable_sp->m_flags &=
+            ~ExpressionVariable::EVNeedsAllocation;
+      } else {
+        // If the variable cannot be kept in target, clear this flag...
+        m_persistent_variable_sp->m_flags &=
+            ~ExpressionVariable::EVKeepInTarget;
+        // ...and set the flag to copy the value during dematerialization.
+        m_persistent_variable_sp->m_flags |=
+            ExpressionVariable::EVNeedsFreezeDry;
+      }
     }
 
     // Write the contents of the variable to the area.

lldb/test/API/functionalities/postmortem/elf-core/expr/TestExpr.py

@@ -10,13 +10,15 @@
 
 @skipIfLLVMTargetMissing("X86")
 class CoreExprTestCase(TestBase):
+    def setUp(self):
+        TestBase.setUp(self)
+        self.target = self.dbg.CreateTarget("linux-x86_64.out")
+        self.process = self.target.LoadCore("linux-x86_64.core")
+        self.assertTrue(self.process, PROCESS_IS_VALID)
+
     def test_result_var(self):
         """Test that the result variable can be used in subsequent expressions."""
 
-        target = self.dbg.CreateTarget("linux-x86_64.out")
-        process = target.LoadCore("linux-x86_64.core")
-        self.assertTrue(process, PROCESS_IS_VALID)
-
         self.expect_expr(
             "outer",
             result_type="Outer",
@@ -29,12 +31,14 @@ def test_result_var(self):
         )
         self.expect_expr("$1.val", result_type="int", result_value="5")
 
-    def test_context_object(self):
-        """Tests expression evaluation in context of an object."""
+    def test_persist_var(self):
+        """Test that user-defined variables can be used in subsequent expressions."""
 
-        target = self.dbg.CreateTarget("linux-x86_64.out")
-        process = target.LoadCore("linux-x86_64.core")
-        self.assertTrue(process, PROCESS_IS_VALID)
+        self.target.EvaluateExpression("int $my_int = 5")
+        self.expect_expr("$my_int * 2", result_type="int", result_value="10")
+
+    def test_context_object(self):
+        """Test expression evaluation in context of an object."""
 
         val_outer = self.expect_expr("outer", result_type="Outer")