Handling signals and operating system exceptions in DLLs is no different than handling signals in executable files, provided that all your DLLs and the executable files that use them are created using IBM C and C++ Compilers, and only one IBM C and C++ Compilers library environment exists for your executable module and all DLLs.
Signal Handlers in DLLs
If your signal handler resides in a DLL, ensure that you change
the signal handler when you unload the DLL. You see no warnings
or error messages if you unload the DLL without changing the
handler, but your program will probably terminate the next time
the handler is called. If another DLL has been loaded in the same
address range, your program may continue but with undefined
results.
Exception Handlers in DLLs
Using
exception handlers is especially advantageous in system DLLs,
because you can run process termination routines even if your DLL
has global initialization and termination.
When a process terminates, functions are called in the following order:
Handlers in Multiple Library Environments
When you have multiple library environments, you must treat
signal and exception handlers in a slightly different manner. If
you have registered signal handlers in a DLL's run-time
environment, you need to register an exception handler for every
entry point in the DLL, in order to ensure that exceptions (and
thus, signals) are always handled by the exception handler (or
signal handler) for the environment where the exception occurred.
For example, if you have an executable module and a DLL, each with its own library environment, the _Exception handler is automatically registered for the executable module when it starts. When the executable module calls a function in the DLL, the thread of execution passes to the DLL. If an exception then occurs in the code in the DLL, it is actually handled by the exception handler in the executable module's library environment. Any signal handling set up in the DLL is ignored.
Include #pragma handler statements in your DLL for every function in the DLL that can be called from another module. This directive ensures the exception handler for the DLL's library environment is correctly registered when the function is called, and deregistered when the function returns to the calling module. Also, include a #pragma handler statement in every function in your executable module that can be called from a DLL.
![]()
Signals and Exceptions
Signal and Exception Handling
Run-Time Library Environments
Dynamic Link
Libraries