[lldb] fix #61728 wrong parameter value display represented via DW_OP_deref and DW_OP_lt

[jwnhy]

Summary

This patch resolves an issue where a value is incorrectly displayed
if it is represented by DW_OP_deref and DW_OP_lt combined.

This issue is caused by lldb treating DW_OP_deref generic types
as unsigned by default, while DW_OP_lt should perform signed
comparison with these generic types by DWARF v5 standard.

This patch resolves this issue by making everything loaded by
DW_OP_deref as signed. As lldb does not really support generic
type, this is probably the best we can do.

A small regression test is also included in this patch.

lldb/source/Expression/DWARFExpression.cpp

case DW_OP_deref: {
                 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
             Status error;
             lldb::addr_t pointer_value =
                 process->ReadPointerFromMemory(pointer_addr, error);
             if (pointer_value != LLDB_INVALID_ADDRESS) {
               if (ABISP abi_sp = process->GetABI())
                 pointer_value = abi_sp->FixCodeAddress(pointer_value);
               stack.back().GetScalar() = pointer_value;
+              stack.back().GetScalar().MakeSigned();
               stack.back().ClearContext();
             } else {
               if (error_ptr)
                 error_ptr->SetErrorStringWithFormat(
                     "Failed to dereference pointer from 0x%" PRIx64
                     " for DW_OP_deref: %s\n",
                     pointer_addr, error.AsCString());
               return false;
case DW_OP_deref_size: {
           break;
         case 7:
           ptr = (intptr_t)ptr & 0xffffffffffffffULL;
           break;
         default:
           break;
         }
         stack.back().GetScalar() = ptr;
+        stack.back().GetScalar().MakeSigned();
         stack.back().ClearContext();
       } break;
       case Value::ValueType::FileAddress: {
         auto file_addr =
             stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
         Address so_addr;
         auto maybe_load_addr =
             ResolveLoadAddress(exe_ctx, module_sp, error_ptr,
case DW_OP_deref_size: {
 
           if (target &&
               target->ReadMemory(so_addr, &addr_bytes, size, error,
                                  /*force_live_memory=*/false) == size) {
             ObjectFile *objfile = module_sp->GetObjectFile();
 
             stack.back().GetScalar() = DerefSizeExtractDataHelper(
                 addr_bytes, size, objfile->GetByteOrder(), size);
+            stack.back().GetScalar().MakeSigned();
             stack.back().ClearContext();
             break;
           } else {
             if (error_ptr)
               error_ptr->SetErrorStringWithFormat(
                   "Failed to dereference pointer for for DW_OP_deref_size: "
                   "%s\n",
                   error.AsCString());
case DW_OP_deref_size: {
             uint8_t addr_bytes[sizeof(lldb::addr_t)];
             Status error;
             if (process->ReadMemory(pointer_addr, &addr_bytes, size, error) ==
                 size) {
 
               stack.back().GetScalar() =
                   DerefSizeExtractDataHelper(addr_bytes, sizeof(addr_bytes),
                                              process->GetByteOrder(), size);
+              stack.back().GetScalar().MakeSigned();
               stack.back().ClearContext();
             } else {
               if (error_ptr)
                 error_ptr->SetErrorStringWithFormat(
                     "Failed to dereference pointer from 0x%" PRIx64
                     " for DW_OP_deref: %s\n",
                     pointer_addr, error.AsCString());
               return false;

lldb/test/API/commands/expression/signed-dw-op-deref/Makefile

+C_SOURCES := main.c
+CFLAGS_EXTRAS := -g -O1
+override CC := gcc
+
+include Makefile.rules

lldb/test/API/commands/expression/signed-dw-op-deref/TestSignedDeref.py

+"""Test that we can print values represented via DW_OP_deref and DW_OP_lt"""
+
+import lldb
+from lldbsuite.test.lldbtest import *
+
+class SignedDerefTestCase(TestBase):
+    def test_signed_div(self):
+        """Test that we can print values represented via DW_OP_deref and DW_OP_lt"""
+        self.build()
+        _, process, _, bkpt = lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec('main.c'))
+        self.expect_expr('p_13', result_type='int', result_value='1')

lldb/test/API/commands/expression/signed-dw-op-deref/main.c

+#include <stdio.h>
+int a;
+signed char b = -48;
+static int func_12(int p_13) {
+  for (;a;); // break here
+  return 0;
+}
+int main() {
+  func_12(0 > b);
+  printf(0);
+  return 0;
+}