Side Effects in ISRs and Signal Handlers Confuse Optimizer

MS-DOS                 | OS/2       | WINDOWS

The information in this article applies to:

• The Microsoft C/C++ Compiler (CL.EXE) included with:

      - Microsoft C for MS-DOS, versions 6.0, 6.0a, and 6.0ax
      - Microsoft C for OS/2, versions 6.0 and 6.0a
      - Microsoft C/C++ for MS-DOS, versions 7.0
      - Microsoft Visual C++ for Windows, versions 1.0 and 1.5
  

SUMMARY

It can be dangerous to allow the Microsoft C compiler to perform loop optimization on code that contains global variables that may be modified in interrupt service routines (ISR) or signal handlers. For example, consider the following code

   int TimerCount = 1000;

   while( TimerCount );
   printf( "Timer expired." );

   void interrupt far ISR()
   {
       TimerCount--;
   }

MORE INFORMATION

This is acceptable code and performs a simple task--it waits for a global timer variable to reach 0, indicating that the ISR has been executed a specified number of times. However, the loop optimization optionally performed by the compiler results in the while() loop being completely removed from the executable code. Because the compiler does not know that the ISR is simultaneously accessing TimerCount, it sees no reason to keep an expression that obviously evaluates to true and does nothing but waste time. This is NOT a problem with the compiler. Section 2.1.2.3 of the 7 December 1988 ANSI C draft standard states the following:

   An actual implementation need not evaluate part of an expression
   if it can deduce that its value is not used and that no needed
   side effects are produced (including any caused by calling a
   function or accessing a volatile object).

When writing code for ISRs or signal handlers that expect conditions that the compiler cannot predict, care should be used in the choice of optimizations; if needed, an assembly code listing should be generated with the /Fc or /Fs /Fa switches and examined for the optimization's effect. Disabling optimization with /Od may result in slower executable programs but will prevent optimizer side effects.