[lldb] Fix HeapCFA comparison to be symmetric

A swift async frame A is younger than frame B if the async ctx of B can
be reached from the async ctx of A. This is implemented today.

But we fail to check the opposite:
A swift async frame A is _older_ than frame B if the async ctx of A can
be reached from the async ctx of B.

Because we lacked the opposite check, we were falling back to "vanilla"
CFA comparison, and were just being lucky that the vast majority of
cases are only interested in the "Younger" case.

Author: felipepiovezan

lldb/source/Target/StackID.cpp

@@ -139,6 +139,11 @@ CompareHeapCFAs(const StackID &lhs, const StackID &rhs, Process &process) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Unwind), std::move(E), "{0}");
   else if (*lhs_younger)
     return HeapCFAComparisonResult::Younger;
+  llvm::Expected<bool> lhs_older = IsReachableParent(rhs_cfa, lhs_cfa, process);
+  if (auto E = lhs_older.takeError())
+    LLDB_LOG_ERROR(GetLog(LLDBLog::Unwind), std::move(E), "{0}");
+  else if (*lhs_older)
+    return HeapCFAComparisonResult::Older;
   return HeapCFAComparisonResult::NoOpinion;
 }
 // END SWIFT

lldb/unittests/StackID/StackIDTest.cpp

@@ -123,3 +123,30 @@ TEST_F(StackIDTest, HeapHeapCFAComparison) {
   EXPECT_TRUE(StackID::IsYounger(middle_cfa, oldest_cfa, process));
   EXPECT_FALSE(StackID::IsYounger(oldest_cfa, middle_cfa, process));
 }
+
+TEST_F(StackIDTest, HeapHeapCFAComparisonDecreasing) {
+  // Create a mock async continuation chain:
+  // 100 -> 90 -> 80 -> 0
+  // This should be read as:
+  // "Async context whose address is 100 has a continuation context whose
+  // address is 90", etc.
+  llvm::DenseMap<addr_t, addr_t> memory_map;
+  memory_map[100] = 90;
+  memory_map[90] = 80;
+  memory_map[80] = 0;
+  auto process = MockProcess(m_target_sp, Listener::MakeListener("dummy"),
+                             std::move(memory_map));
+
+  MockStackID oldest_cfa(/*cfa*/ 80, OnStack::No);
+  MockStackID middle_cfa(/*cfa*/ 90, OnStack::No);
+  MockStackID youngest_cfa(/*cfa*/ 100, OnStack::No);
+
+  EXPECT_TRUE(StackID::IsYounger(youngest_cfa, oldest_cfa, process));
+  EXPECT_FALSE(StackID::IsYounger(oldest_cfa, youngest_cfa, process));
+
+  EXPECT_TRUE(StackID::IsYounger(youngest_cfa, middle_cfa, process));
+  EXPECT_FALSE(StackID::IsYounger(middle_cfa, youngest_cfa, process));
+
+  EXPECT_TRUE(StackID::IsYounger(middle_cfa, oldest_cfa, process));
+  EXPECT_FALSE(StackID::IsYounger(oldest_cfa, middle_cfa, process));
+}