[lldb] Fix failure in TestStackCoreScriptedProcess on x86_64

[mib]

Summary

This patch should address the failure of TestStackCoreScriptedProcess
that is happening specifically on x86_64.

It turns out that in 1370a1cb5b97, I changed the way we extract integers
from a StructuredData::Dictionary and in order to get a stop info from
the scripted process, we call a method that returns a SBStructuredData
containing the stop reason data.

TestStackCoreScriptedProcess` was failing specifically on x86_64 because
the stop info dictionary contains the signal number, that the `Scripted
Thread` was trying to extract as a signed integer where it was actually
parsed as an unsigned integer. That caused GetValueForKeyAsInteger to
return the default value parameter, LLDB_INVALID_SIGNAL_NUMBER.

This patch address the issue by extracting the signal number with the
appropriate type and re-enables the test.

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

Re-enable test

[bulbazord]

Makes sense.

lldb/source/Plugins/Process/scripted/ScriptedThread.cpp

253

Is there a more specific type we can use other than unsigned int? Maybe uint32_t?

lldb/include/lldb/Utility/StructuredData.h

bool GetValueForKeyAsBoolean(llvm::StringRef key, bool &result) const {
         Boolean *result_ptr = value_sp->GetAsBoolean();
         if (result_ptr) {
           result = result_ptr->GetValue();
           success = true;
         }
       }
       return success;
     }
+      
     template <class IntType>
     bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const {
       ObjectSP value_sp = GetValueForKey(key);
       if (value_sp) {
         if constexpr (std::numeric_limits<IntType>::is_signed) {
           if (auto signed_value = value_sp->GetAsSignedInteger()) {
             result = static_cast<IntType>(signed_value->GetValue());
             return true;

lldb/source/Plugins/Process/scripted/ScriptedThread.cpp

bool ScriptedThread::CalculateStopInfo() {
   case lldb::eStopReasonBreakpoint: {
     lldb::break_id_t break_id;
     data_dict->GetValueForKeyAsInteger("break_id", break_id,
                                        LLDB_INVALID_BREAK_ID);
     stop_info_sp =
         StopInfo::CreateStopReasonWithBreakpointSiteID(*this, break_id);
   } break;
   case lldb::eStopReasonSignal: {
-    int signal;
+    unsigned int signal;
     llvm::StringRef description;
-    data_dict->GetValueForKeyAsInteger("signal", signal,
-                                       LLDB_INVALID_SIGNAL_NUMBER);
+    if (!data_dict->GetValueForKeyAsInteger("signal", signal)) {
+        signal = LLDB_INVALID_SIGNAL_NUMBER;
+        return false;
+    }
     data_dict->GetValueForKeyAsString("desc", description);
     stop_info_sp =
         StopInfo::CreateStopReasonWithSignal(*this, signal, description.data());
   } break;
   case lldb::eStopReasonTrace: {
     stop_info_sp = StopInfo::CreateStopReasonToTrace(*this);
   } break;
   case lldb::eStopReasonException: {

lldb/test/API/functionalities/scripted_process/TestStackCoreScriptedProcess.py

def get_module_with_name(self, target, name):
             if name in module.GetFileSpec().GetFilename():
                 return module
         return None
 
     @skipUnlessDarwin
     @skipIfOutOfTreeDebugserver
     @skipIfRemote
     @skipIfAsan  # On ASAN builds, this test times-out (rdar://98678134)
-    @skipIfDarwin
     def test_launch_scripted_process_stack_frames(self):
         """Test that we can launch an lldb scripted process from the command
         line, check its process ID and read string from memory."""
         self.build()
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 
         main_module = self.get_module_with_name(target, "a.out")