What is so hard about handling C ++ exceptions?

• For each function that can potentially throw exceptions, the compiler creates as a stack variable a structure from a pointer to a previous similar structure, addresses of the handler function, and auxiliary data. The address of this structure is entered in FS: [0], which is the top of the stack of these structures. The FS register in Win32 is used as the Thread Information Block ( TIB ) (GS in Win64). It also creates a handler function (with its own data set) and an epilogue that restores FS: [0] if successful.
• The compiler creates a table of structures - by element for each try-block in the function. Each try-block has a start and end index in this table (a nested block has a nested interval) corresponding to a certain state, and the compiler itself monitors the relevance of this index. In this way, the compiler implements a stack of try blocks.
• For each try-block, a catch-block table is started. For each type of exception, a type_info table is created for all base classes in the hierarchy of this type of exception.
• An unwind table is created for each function, each element of which contains a pointer to a function that frees some resource and the number of the previous element. A table may have several chains, depending on the scope of objects with destructors. At the time of exception, by the index of the current state, which was mentioned above, you can find the necessary chain and call all the necessary destructors.
• For version x64, auxiliary stack structures, if possible, were transferred to .pdata; probably, MS considers the first strategy to be more promising.
• When an exception is thrown, the main work is carried out by the operating system, where control gets through SYSENTER.

• When an exception is thrown, its descriptor is created, which contains a copy of the object, its type_info, a pointer to the destructor
• Rising along the stack of try blocks and clearing all registered stacked objects (the navigation on this stack is different everywhere, but the essence is the same), we look through the lists of catch blocks and look for a suitable one.
• If a suitable catch block is found, the exception object becomes a local variable; we call this block. If the catch block takes an exception by value, rather than a reference, a copy of it will be created.
• If there was no exception re-call, kill the object - exception
• “Mistress to the note”:
  

  some_exception exc("oioi");
  throw exc;

  spawns an extra copy constructor / destructor
  

  throw *new some_exception("oioi");

  gives a memory leak
  

  catch(some_exception exc) ...

  again an extra call to the constructor and destructor
  

  catch(const some_exception *exc) ...

  an exception will fly by unless you drop the pointer
  

  throw some_exception("oioi");
  ...
  catch (const some_exception &exc)....
  

  minimum cost
  

structunw_item_t {unw_item_t ();
    virtual ~unw_item_t ();
    voidunreg();
    unw_item_t  *prev_;  
};

structjmp_buf_splice {    
    jmp_buf_splice ();
    ~jmp_buf_splice ();    
    jmp_buf         buf_;    
    jmp_buf_splice *prev_;    
    unw_item_t      objs_;  
};

externintthrow_slice(constchar *str);

// начало блока#define TRY_BLOCK { \
  jmp_buf_splice __sl; \
  const char *__exc = (const char *)setjmp (__sl.buf_); \
  if (NULL == __exc) {
...
// что-то вроде catch(…) т.к. мы бросаем только const char*#define CATCH_BLOCK_FIN  \
  } else { 
...
// конец блока#define FIN_BLOCK  \
    } \
  }
...
// бросаем исключение #define THROW_IN_BLOCK(exc)  \
  throw_slice (exc); 
...
// перебрасываем исключение наверх, __exc определено в TRY_BLOCK#define RETHROW_IN_BLOCK  \
  throw_slice (__exc); 

static jmp_buf_splice *root_slice_ = NULL;  
jmp_buf_splice::jmp_buf_splice ()
{
  objs_ = NULL;
  prev_ = root_slice_;
  root_slice_ = this;
}
jmp_buf_splice::~jmp_buf_splice ()
{
  root_slice_ = prev_;
}

unw_item_t::unw_item_t ()
{
  if (NULL != root_slice_) 
  {
      prev_ = root_slice_->objs_;
      root_slice_->objs_ = this;
  }
}
unw_item_t::~unw_item_t ()
{
  unreg();
}
unw_item_t::unreg ()
{
  if (NULL != root_slice_ && 
    (prev_ != reinterpret_cast<unw_item_t *>(~0))) 
  {
      root_slice_->objs_ = prev_;
      prev_ = reinterpret_cast<unw_item_t *>(~0);
  }
}

staticintpop_slice(){
  jmp_buf_splice *sl = root_slice_;
  assert (NULL != sl);
  root_slice_ = sl->prev_;
  return0;
}
intthrow_slice(constchar *str, bool popstate){
  if (NULL == str)
    return-1;
  jmp_buf_splice *sl = root_slice_;
  unw_item_t *obj = root_slice_->objs_;
  while (NULL != obj)
    {
      unw_item_t *tmp = obj;
      obj = obj->prev_;
      tmp->~unw_item_t ();
    }
  if (popstate)
    pop_slice ();
  longjmp (sl->buf_, int(str));	
  return0;
}

#define CATCH_BLOCK_TYPED(t)  \
  } elseif (NULL != dynamic_cast<t>(__exc)) {

template<classT>
class __st_wrapper :publicunw_item_t  {
public:
    virtual ~__st_wrapper() 
    {
      unreg();
      ((T*)data_)->T::~T();
    };
private:
   char data_[sizeof(T)];
};