Remove unused typedefs.

[simgrid.git] / src / xbt / exception.cpp

diff --git a/src/xbt/exception.cpp b/src/xbt/exception.cpp
index 6e9cf0c..1455134 100644 (file)
--- a/src/xbt/exception.cpp
+++ b/src/xbt/exception.cpp
@@ -1,14 +1,21 @@
-/* Copyright (c) 2005-2016. The SimGrid Team.
- * All rights reserved. */
+/* Copyright (c) 2005-2018. The SimGrid Team. All rights reserved.          */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
+#include <cstdlib>
+
+#include <atomic>
 #include <exception>
+#include <string>
 #include <typeinfo>
+#include <vector>
 #include <memory>
+#include <mutex>
 
 #include <xbt/backtrace.hpp>
+#include <xbt/config.hpp>
+#include <xbt/ex.hpp>
 #include <xbt/exception.hpp>
 #include <xbt/log.h>
 #include <xbt/log.hpp>
@@ -21,7 +28,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_exception, xbt, "Exceptions");
 namespace simgrid {
 namespace xbt {
 
-WithContextException::~WithContextException() {}
+WithContextException::~WithContextException() = default;
 
 void logException(
   e_xbt_log_priority_t prio,
@@ -30,8 +37,7 @@ void logException(
   try {
     auto name = simgrid::xbt::demangle(typeid(exception).name());
 
-    auto with_context =
-      dynamic_cast<const simgrid::xbt::WithContextException*>(&exception);
+    auto* with_context = dynamic_cast<const simgrid::xbt::WithContextException*>(&exception);
     if (with_context != nullptr)
       XBT_LOG(prio, "%s %s by %s/%d: %s",
         context, name.get(),
@@ -41,7 +47,7 @@ void logException(
       XBT_LOG(prio, "%s %s: %s", context, name.get(), exception.what());
 
     // Do we have a backtrace?
-    if (with_context != nullptr) {
+    if (with_context != nullptr && not xbt_cfg_get_boolean("exception/cutpath")) {
       auto backtrace = simgrid::xbt::resolveBacktrace(
         with_context->backtrace().data(), with_context->backtrace().size());
       for (std::string const& s : backtrace)
@@ -49,7 +55,7 @@ void logException(
     }
 
     // Do we have a nested exception?
-    auto with_nested = dynamic_cast<const std::nested_exception*>(&exception);
+    auto* with_nested = dynamic_cast<const std::nested_exception*>(&exception);
     if (with_nested == nullptr ||  with_nested->nested_ptr() == nullptr)
       return;
     try {
@@ -68,5 +74,65 @@ void logException(
   }
 }
 
+static void showBacktrace(std::vector<xbt_backtrace_location_t>& bt)
+{
+  if (xbt_cfg_get_boolean("exception/cutpath")) {
+    XBT_LOG(xbt_log_priority_critical, "Display of current backtrace disabled by --cfg=exception/cutpath.");
+    return;
+  }
+  std::vector<std::string> res = resolveBacktrace(&bt[0], bt.size());
+  XBT_LOG(xbt_log_priority_critical, "Current backtrace:");
+  for (std::string const& s : res)
+    XBT_LOG(xbt_log_priority_critical, "  -> %s", s.c_str());
+}
+
+static std::terminate_handler previous_terminate_handler = nullptr;
+
+static void handler()
+{
+  // Avoid doing crazy things if we get an uncaught exception inside
+  // an uncaught exception
+  static std::atomic_flag lock = ATOMIC_FLAG_INIT;
+  if (lock.test_and_set()) {
+    XBT_ERROR("Handling an exception raised an exception. Bailing out.");
+    std::abort();
+  }
+
+  // Get the current backtrace and exception
+  auto e = std::current_exception();
+  auto bt = backtrace();
+  try {
+    std::rethrow_exception(e);
+  }
+
+  // We manage C++ exception ourselves
+  catch (std::exception& e) {
+    logException(xbt_log_priority_critical, "Uncaught exception", e);
+    showBacktrace(bt);
+    std::abort();
+  }
+
+  // We don't know how to manage other exceptions
+  catch (...) {
+    // If there was another handler let's delegate to it
+    if (previous_terminate_handler)
+      previous_terminate_handler();
+    else {
+      XBT_ERROR("Unknown uncaught exception");
+      showBacktrace(bt);
+      std::abort();
+    }
+  }
+
+}
+
+void installExceptionHandler()
+{
+  static std::once_flag handler_flag;
+  std::call_once(handler_flag, [] {
+    previous_terminate_handler = std::set_terminate(handler);
+  });
+}
+
 }
 }