Merge branch 'main' into orc-drop-debugobjectregistrar

Author: weliveindetail

clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicExtent.h

@@ -58,6 +58,8 @@ SVal getDynamicExtentWithOffset(ProgramStateRef State, SVal BufV);
 DefinedOrUnknownSVal getDynamicElementCountWithOffset(ProgramStateRef State,
                                                       SVal BufV, QualType Ty);
 
+void markAllDynamicExtentLive(ProgramStateRef State, SymbolReaper &SymReaper);
+
 } // namespace ento
 } // namespace clang
 

clang/lib/StaticAnalyzer/Core/DynamicExtent.cpp

@@ -128,5 +128,12 @@ ProgramStateRef setDynamicExtent(ProgramStateRef State, const MemRegion *MR,
   return State->set<DynamicExtentMap>(MR->StripCasts(), Size);
 }
 
+void markAllDynamicExtentLive(ProgramStateRef State, SymbolReaper &SymReaper) {
+  for (const auto &I : State->get<DynamicExtentMap>())
+    if (SymbolRef Sym = I.second.getAsSymbol())
+      if (SymReaper.isLiveRegion(I.first))
+        SymReaper.markLive(Sym);
+}
+
 } // namespace ento
 } // namespace clang

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

@@ -1079,6 +1079,11 @@ void ExprEngine::removeDead(ExplodedNode *Pred, ExplodedNodeSet &Out,
   getCheckerManager().runCheckersForDeadSymbols(CheckedSet, Pred, SymReaper,
                                                 DiagnosticStmt, *this, K);
 
+  // Extend lifetime of symbols used for dynamic extent while the parent region
+  // is live. In this way size information about memory allocations is not lost
+  // if the region remains live.
+  markAllDynamicExtentLive(CleanedState, SymReaper);
+
   // For each node in CheckedSet, generate CleanedNodes that have the
   // environment, the store, and the constraints cleaned up but have the
   // user-supplied states as the predecessors.

clang/test/Analysis/ArrayBound/verbose-tests.c

@@ -381,30 +381,12 @@ int *symbolicExtent(int arg) {
     return 0;
   int *mem = (int*)malloc(arg);
 
-  // TODO: without the following reference to 'arg', the analyzer would discard
-  // the range information about (the symbolic value of) 'arg'. This is
-  // incorrect because while the variable itself is inaccessible, it becomes
-  // the symbolic extent of 'mem', so we still want to reason about its
-  // potential values.
-  (void)arg;
-
   mem[8] = -2;
   // expected-warning@-1 {{Out of bound access to memory after the end of the heap area}}
   // expected-note@-2 {{Access of 'int' element in the heap area at index 8}}
   return mem;
 }
 
-int *symbolicExtentDiscardedRangeInfo(int arg) {
-  // This is a copy of the case 'symbolicExtent' without the '(void)arg' hack.
-  // TODO: if the analyzer can detect the out-of-bounds access within this
-  // testcase, then remove this and the `(void)arg` hack from `symbolicExtent`.
-  if (arg >= 5)
-    return 0;
-  int *mem = (int*)malloc(arg);
-  mem[8] = -2;
-  return mem;
-}
-
 void symbolicIndex(int arg) {
   // expected-note@+2 {{Assuming 'arg' is >= 12}}
   // expected-note@+1 {{Taking true branch}}
@@ -426,9 +408,5 @@ int *nothingIsCertain(int x, int y) {
   //   {{Access of 'int' element in the heap area at an overflowing index}}
   // but apparently the analyzer isn't smart enough to deduce this.
 
-  // Keep constraints alive. (Without this, the overeager garbage collection of
-  // constraints would _also_ prevent the intended behavior in this testcase.)
-  (void)x;
-
   return mem;
 }

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

@@ -1705,8 +1705,11 @@ void DWARFASTParserClang::GetUniqueTypeNameAndDeclaration(
   // For C++, we rely solely upon the one definition rule that says
   // only one thing can exist at a given decl context. We ignore the
   // file and line that things are declared on.
-  if (!die.IsValid() || !Language::LanguageIsCPlusPlus(language) ||
-      unique_typename.IsEmpty())
+  // FIXME: Rust pretends to be C++ for now, so use C++ name qualification rules
+  if (!Language::LanguageIsCPlusPlus(language) &&
+      language != lldb::eLanguageTypeRust)
+    return;
+  if (!die.IsValid() || unique_typename.IsEmpty())
     return;
   decl_declaration.Clear();
   std::string qualified_name;

lldb/test/API/lang/rust/enum-variant-same-name/RustEnumValue.py

@@ -0,0 +1,69 @@
+"""Helper library to traverse data emitted for Rust enums """
+from lldbsuite.test.lldbtest import *
+
+DISCRIMINANT_MEMBER_NAME = "$discr$"
+VALUE_MEMBER_NAME = "value"
+
+
+class RustEnumValue:
+    def __init__(self, value: lldb.SBValue):
+        self.value = value
+
+    def getAllVariantTypes(self):
+        result = []
+        for i in range(self._inner().GetNumChildren()):
+            result.append(self.getVariantByIndex(i).GetDisplayTypeName())
+        return result
+
+    def _inner(self) -> lldb.SBValue:
+        return self.value.GetChildAtIndex(0)
+
+    def getVariantByIndex(self, index):
+        return (
+            self._inner()
+            .GetChildAtIndex(index)
+            .GetChildMemberWithName(VALUE_MEMBER_NAME)
+        )
+
+    @staticmethod
+    def _getDiscriminantValueAsUnsigned(discr_sbvalue: lldb.SBValue):
+        byte_size = discr_sbvalue.GetType().GetByteSize()
+        error = lldb.SBError()
+
+        # when discriminant is u16 Clang emits 'unsigned char'
+        # and LLDB seems to treat it as character type disalowing to call GetValueAsUnsigned
+        if byte_size == 1:
+            return discr_sbvalue.GetData().GetUnsignedInt8(error, 0)
+        elif byte_size == 2:
+            return discr_sbvalue.GetData().GetUnsignedInt16(error, 0)
+        elif byte_size == 4:
+            return discr_sbvalue.GetData().GetUnsignedInt32(error, 0)
+        elif byte_size == 8:
+            return discr_sbvalue.GetData().GetUnsignedInt64(error, 0)
+        else:
+            return discr_sbvalue.GetValueAsUnsigned()
+
+    def getCurrentVariantIndex(self):
+        default_index = 0
+        for i in range(self._inner().GetNumChildren()):
+            variant: lldb.SBValue = self._inner().GetChildAtIndex(i)
+            discr = variant.GetChildMemberWithName(DISCRIMINANT_MEMBER_NAME)
+            if discr.IsValid():
+                discr_unsigned_value = RustEnumValue._getDiscriminantValueAsUnsigned(
+                    discr
+                )
+                if variant.GetName() == f"$variant${discr_unsigned_value}":
+                    return discr_unsigned_value
+            else:
+                default_index = i
+        return default_index
+
+    def getFields(self):
+        result = []
+        for i in range(self._inner().GetNumChildren()):
+            type: lldb.SBType = self._inner().GetType()
+            result.append(type.GetFieldAtIndex(i).GetName())
+        return result
+
+    def getCurrentValue(self) -> lldb.SBValue:
+        return self.getVariantByIndex(self.getCurrentVariantIndex())

lldb/test/API/lang/rust/enum-variant-same-name/TestRustEnumVariantSameName.py

@@ -0,0 +1,36 @@
+"""Test that lldb recognizes enum variant emitted by Rust compiler """
+import logging
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from RustEnumValue import RustEnumValue
+
+
+class TestRustEnumStructs(TestBase):
+    def setUp(self):
+        TestBase.setUp(self)
+        src_dir = self.getSourceDir()
+        yaml_path = os.path.join(src_dir, "main.yaml")
+        obj_path = self.getBuildArtifact("main.o")
+        self.yaml2obj(yaml_path, obj_path)
+        self.dbg.CreateTarget(obj_path)
+
+    def getFromGlobal(self, name):
+        values = self.target().FindGlobalVariables(name, 1)
+        self.assertEqual(values.GetSize(), 1)
+        return RustEnumValue(values[0])
+
+    def test_enum_instance(self):
+        # static ENUM_INSTANCE: A = A::A(B::B(10));
+        value = self.getFromGlobal("ENUM_INSTANCE").getCurrentValue()
+        self.assertEqual(value.GetType().GetDisplayTypeName(), "main::A::A")
+
+        value_b = RustEnumValue(value.GetChildAtIndex(0))
+        self.assertEqual(
+            value_b.getCurrentValue()
+            .GetChildAtIndex(0)
+            .GetData()
+            .GetUnsignedInt8(lldb.SBError(), 0),
+            10,
+        )

lldb/test/API/lang/rust/enum-variant-same-name/main.rs

@@ -0,0 +1,15 @@
+/// Command:
+/// rustc -g --emit=obj --crate-type=bin -C panic=abort -C link-arg=-nostdlib main.rs && obj2yaml main.o -o main.yaml
+
+pub enum A {
+    A(B),
+}
+
+pub enum B {
+    B(u8),
+}
+
+static ENUM_INSTANCE: A = A::A(B::B(10));
+
+pub fn main() {
+}