Fix for clang 14: new check was added against substracting from a potential nullptr.

[simgrid.git] / src / mc / remote / AppSide.cpp

diff --git a/src/mc/remote/AppSide.cpp b/src/mc/remote/AppSide.cpp
index d27c534..eeee309 100644 (file)
--- a/src/mc/remote/AppSide.cpp
+++ b/src/mc/remote/AppSide.cpp
@@ -5,6 +5,7 @@
 
 #include "src/mc/remote/AppSide.hpp"
 #include "src/internal_config.h"
+#include "src/kernel/EngineImpl.hpp"
 #include "src/kernel/actor/ActorImpl.hpp"
 #include "src/kernel/actor/SimcallObserver.hpp"
 #include "src/mc/mc_base.hpp"
@@ -18,6 +19,7 @@
 #include <simgrid/modelchecker.h>
 
 #include <cerrno>
+#include <cstdio> // setvbuf
 #include <cstdlib>
 #include <cstring>
 #include <memory>
@@ -43,11 +45,11 @@ AppSide* AppSide::initialize()
 
   _sg_do_model_check = 1;
 
-  setvbuf(stdout, NULL, _IOLBF, 0);
+  setvbuf(stdout, nullptr, _IOLBF, 0);
 
   // Fetch socket from MC_ENV_SOCKET_FD:
   const char* fd_env = std::getenv(MC_ENV_SOCKET_FD);
-  int fd = xbt_str_parse_int(fd_env, "Variable '" MC_ENV_SOCKET_FD "' should contain a number but contains '%s'");
+  int fd             = xbt_str_parse_int(fd_env, "Not a number in variable '" MC_ENV_SOCKET_FD "'");
   XBT_DEBUG("Model-checked application found socket FD %i", fd);
 
   // Check the socket type/validity:
@@ -71,9 +73,9 @@ AppSide* AppSide::initialize()
   xbt_assert(errno == 0 && raise(SIGSTOP) == 0, "Could not wait for the model-checker (errno = %d: %s)", errno,
              strerror(errno));
 
-  s_mc_message_initial_addresses_t message{
-      MessageType::INITIAL_ADDRESSES, mmalloc_preinit(), simgrid::kernel::actor::get_maxpid_addr(),
-      simgrid::simix::simix_global_get_actors_addr(), simgrid::simix::simix_global_get_dead_actors_addr()};
+  s_mc_message_initial_addresses_t message{MessageType::INITIAL_ADDRESSES, mmalloc_preinit(),
+                                           kernel::actor::get_maxpid_addr(), simix::simix_global_get_actors_addr(),
+                                           simix::simix_global_get_dead_actors_addr()};
   xbt_assert(instance_->channel_.send(message) == 0, "Could not send the initial message with addresses.");
 
   instance_->handle_messages();
@@ -82,15 +84,10 @@ AppSide* AppSide::initialize()
 
 void AppSide::handle_deadlock_check(const s_mc_message_t*) const
 {
-  bool deadlock = false;
-  if (not simix_global->process_list.empty()) {
-    deadlock = true;
-    for (auto const& kv : simix_global->process_list)
-      if (simgrid::mc::actor_is_enabled(kv.second)) {
-        deadlock = false;
-        break;
-      }
-  }
+  const auto& actor_list = kernel::EngineImpl::get_instance()->get_actor_list();
+  bool deadlock = not actor_list.empty() && std::none_of(begin(actor_list), end(actor_list), [](const auto& kv) {
+    return mc::actor_is_enabled(kv.second);
+  });
 
   // Send result:
   s_mc_message_int_t answer{MessageType::DEADLOCK_CHECK_REPLY, deadlock};
@@ -98,17 +95,19 @@ void AppSide::handle_deadlock_check(const s_mc_message_t*) const
 }
 void AppSide::handle_simcall_execute(const s_mc_message_simcall_handle_t* message) const
 {
-  kernel::actor::ActorImpl* process = kernel::actor::ActorImpl::by_pid(message->aid_);
-  xbt_assert(process != nullptr, "Invalid pid %ld", message->aid_);
-  process->simcall_handle(message->times_considered_);
+  kernel::actor::ActorImpl* actor = kernel::actor::ActorImpl::by_pid(message->aid_);
+  xbt_assert(actor != nullptr, "Invalid pid %ld", message->aid_);
+  if (actor->simcall_.observer_ != nullptr)
+    actor->observer_stack_.push_back(actor->simcall_.observer_->clone());
+  actor->simcall_handle(message->times_considered_);
   xbt_assert(channel_.send(MessageType::WAITING) == 0, "Could not send MESSAGE_WAITING to model-checker");
 }
 
 void AppSide::handle_actor_enabled(const s_mc_message_actor_enabled_t* msg) const
 {
-  bool res = simgrid::mc::actor_is_enabled(kernel::actor::ActorImpl::by_pid(msg->aid));
+  bool res = mc::actor_is_enabled(kernel::actor::ActorImpl::by_pid(msg->aid));
   s_mc_message_int_t answer{MessageType::ACTOR_ENABLED_REPLY, res};
-  channel_.send(answer);
+  xbt_assert(channel_.send(answer) == 0, "Could not send ACTOR_ENABLED_REPLY");
 }
 
 #define assert_msg_size(_name_, _type_)                                                                                \
@@ -196,7 +195,7 @@ void AppSide::handle_messages() const
         XBT_DEBUG("Finalize (terminate = %d)", (int)terminate_asap);
         if (not terminate_asap) {
           if (XBT_LOG_ISENABLED(mc_client, xbt_log_priority_debug))
-            simix_global->display_all_actor_status();
+            kernel::EngineImpl::get_instance()->display_all_actor_status();
 #if HAVE_SMPI
           XBT_DEBUG("Smpi_enabled: %d", (int)smpi_enabled());
           if (smpi_enabled())
@@ -257,7 +256,7 @@ void AppSide::ignore_heap(void* address, std::size_t size) const
     message.fragment = -1;
     heap->heapinfo[message.block].busy_block.ignore++;
   } else {
-    message.fragment = (ADDR2UINT(address) % BLOCKSIZE) >> heap->heapinfo[message.block].type;
+    message.fragment = address ? (ADDR2UINT(address) % BLOCKSIZE) >> heap->heapinfo[message.block].type : 0;
     heap->heapinfo[message.block].busy_frag.ignore[message.fragment]++;
   }