void a(void)
{
  integer i,j;

  void b(void)
  {
  }
}

    for(;; ) : mainloop {
        int i = 8;
        do : bitloop {
              while( aaa ) {
                  if( bbb )
                      break mainloop;
              }
              if( ccc )
                   break bitloop;                  
        } while(--i);
    }

typedef struct {
int a;
char b;
char c;
} T_S3;

T_S3 s3func(int i)
{
T_S3 s3;
s3.a = i+1;
s3.b = i+2;
s3.c = i+3;
return s3;
}

int test3(void)
{
int i;
i = s3func(1).a;
return s3func(i).b;
}

\ In section .text, align 4, keep-with-next
1325 T_S3 s3func(int i)
1326 {
\ s3func:
\ 00000000 0200 MOVS R2,R0
\ 00000002 82B0 SUB SP,SP,#+8
1327 T_S3 s3;
1328 s3.a = i+1;
\ 00000004 481C ADDS R0,R1,#+1
\ 00000006 0090 STR R0,[SP, #+0]
1329 s3.b = i+2;
\ 00000008 881C ADDS R0,R1,#+2
\ 0000000A 6B46 MOV R3,SP
\ 0000000C 1871 STRB R0,[R3, #+4]
1330 s3.c = i+3;
\ 0000000E C91C ADDS R1,R1,#+3
\ 00000010 6846 MOV R0,SP
\ 00000012 4171 STRB R1,[R0, #+5]
1331 return s3;
\ 00000014 03C8 LDM R0!,{R0,R1}
\ 00000016 02B0 ADD SP,SP,#+8
\ 00000018 03C2 STM R2!,{R0,R1}
\ 0000001A 7047 BX LR ;; return
1332 }
1333

\ In section .text, align 4, keep-with-next
1334 int test3(void)
1335 {
\ test3:
\ 00000000 00B5 PUSH {LR}
\ 00000002 83B0 SUB SP,SP,#+12
1336 int i;
1337 i = s3func(1).a;
\ 00000004 0121 MOVS R1,#+1
\ 00000006 6846 MOV R0,SP
\ 00000008 ........ BL s3func
\ 0000000C 0099 LDR R1,[SP, #+0]
1338 return s3func(i).b;
\ 0000000E 6846 MOV R0,SP
\ 00000010 ........ BL s3func
\ 00000014 6846 MOV R0,SP
\ 00000016 0079 LDRB R0,[R0, #+4]
\ 00000018 03B0 ADD SP,SP,#+12
\ 0000001A 00BD POP {PC} ;; return
1339 }

---------------------------------------------------------------------------------
Function Prototype    |  Parameters Passed as   |    Return Location
---------------------------------------------------------------------------------
struct s2 {           |          a in R0,       |        in R0 (s.t and s.u)
char t;               |          b in R1,       |        and in R1 (s.v)    
char u;               |          c in R2        |
int v;                |                         |
}                     |                         |
                      |                         |
struct s2 test(int a, |                         |
int b, int c)         |                         |
---------------------------------------------------------------------------------
struct s3 {           |        a in R0,         |     in *P0 (based on value
char t;               |        b in R1,         |     of P0 at the call, not
char u;               |        c in R2          |     necessarily at the    
int v;                |                         |     return)                
int w;                |                         |
}                     |                         |
                      |                         |
struct s3 test(int a, |                         |
int b, int c)         |                         |
---------------------------------------------------------------------------------

volatile int some;
int *someptr = &some;
*someptr += 2;

volatile int *someptr;        // компилятор может запросто оптимизируя удалить присванивание этой переменной

int *volatile someptr;        // а этой компилятор не удалит

class foo {
public:
    state_t get_state() volatile // volatile переехало сюда -- для пользователей класса
    {
        return state; // ну при sizeof(state_t) > sizeof(sig_atomic_t) ещё заворачивать в крит. секцию
    }
private:
    state_t state; // не-volatile для обработчика прерываний
    INLINE void isr(); // обработчик прерываний топчется по state как хочет
};

void foo1(int);
...

void foo2(void);
...


int main()
{
    .....
    if (expr1) goto do_foo2;
    foo1(a);
    if (expr2) {
    do_foo2:
        foo2();
    }
    .....
}

{
    if (expr1 || (foo1(a), expr2)) {
        foo2();
    }
}

if ( ! expr1 )
    foo1();
if ( expr1 || expr2 )
    foo2();