MS>    uint16_t  hi = sp[0];

MS>static char mem_pool[max_size];
MS>. . .
MS>int* allocate_int()
MS>{
MS>   . . .
MS>   return (int*)(&mem_pool[index_aligned_to_int]);  // To UB or not to UB? 
MS>}

struct header;

header* ptr;

assert((uint64)ptr == (uint64)(uint32)ptr);

.globl swap_words
    .type    swap_words, @function
swap_words:
    pushl    %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movzwl    2(%eax), %ecx
    movzwl    (%eax), %edx
    movw    %dx, 2(%eax)
    movw    %cx, (%eax)
    popl    %ebp
    ret
    .size

    .p2align 4,,15
.globl swap_words
    .type    swap_words, @function
swap_words:
    pushl    %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movzwl    2(%eax), %ecx
    movzwl    (%eax), %edx
    movw    %cx, (%eax)
    movw    %dx, 2(%eax)
    popl    %ebp
    ret

    .file    "a.c"
    .text
.globl swap_words
    .type    swap_words, @function
swap_words:
    pushl    %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movzwl    2(%eax), %ecx
    movzwl    (%eax), %edx
    movw    %dx, 2(%eax)
    movw    %cx, (%eax)
    popl    %ebp
    ret
    .size    swap_words, .-swap_words
    .section    .rodata.str1.1,"aMS",@progbits,1
.LC0:
    .string    "%08X %08X\n"
    .text
.globl main
    .type    main, @function
main:
    leal    4(%esp), %ecx
    andl    $-16, %esp
    pushl    -4(%ecx)
    pushl    %ebp
    movl    %esp, %ebp
    pushl    %ecx
    subl    $36, %esp
    movl    $-65536, -8(%ebp)
    leal    -8(%ebp), %eax
    movl    %eax, (%esp)
    call    swap_words
    movl    -8(%ebp), %eax
    movl    %eax, 8(%esp)
    movl    $-65536, 4(%esp)
    movl    $.LC0, (%esp)
    call    printf
    movl    $0, %eax
    addl    $36, %esp
    popl    %ecx
    popl    %ebp
    leal    -4(%ecx), %esp
    ret
    .size    main, .-main
    .ident    "GCC: (GNU) 4.1.2 20061115 (prerelease) (SUSE Linux)"
    .section    .note.GNU-stack,"",@progbits

    .file    "a.c"
    .text
    .p2align 4,,15
.globl swap_words
    .type    swap_words, @function
swap_words:
    pushl    %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movzwl    2(%eax), %ecx
    movzwl    (%eax), %edx
    movw    %cx, (%eax)
    movw    %dx, 2(%eax)
    popl    %ebp
    ret
    .size    swap_words, .-swap_words
    .section    .rodata.str1.1,"aMS",@progbits,1
.LC0:
    .string    "%08X %08X\n"
    .text
    .p2align 4,,15
.globl main
    .type    main, @function
main:
    leal    4(%esp), %ecx
    andl    $-16, %esp
    pushl    -4(%ecx)
    pushl    %ebp
    movl    %esp, %ebp
    pushl    %ecx
    subl    $36, %esp
    movzwl    -6(%ebp), %edx
    movzwl    -8(%ebp), %eax
    movl    $-65536, -8(%ebp)
    movw    %dx, -8(%ebp)
    movw    %ax, -6(%ebp)
    movl    $-65536, 8(%esp)
    movl    $-65536, 4(%esp)
    movl    $.LC0, (%esp)
    call    printf
    addl    $36, %esp
    xorl    %eax, %eax
    popl    %ecx
    popl    %ebp
    leal    -4(%ecx), %esp
    ret
    .size    main, .-main
    .ident    "GCC: (GNU) 4.1.2 20061115 (prerelease) (SUSE Linux)"
    .section    .note.GNU-stack,"",@progbits

/* main.cpp */ 

#include <stdio.h>

// assume unsigned is 32 bit

unsigned SwapHalf(unsigned val)
 {
  return (val<<16)|(val>>16);
 }
 
void SwapHalf(unsigned *var)
 {
  *var=SwapHalf(*var);
 }
 
/* main() */   

int main()
 {
  unsigned val=0xABBABEDA;
  
  SwapHalf(&val);
  
  printf("%.8X\n",val);
 
  return 0;
 }

?SwapHalf@@YAXPAI@Z PROC                ; SwapHalf, COMDAT

; 14   :   *var=SwapHalf(*var);

    mov    eax, DWORD PTR _var$[esp-4]
    mov    ecx, DWORD PTR [eax]
    rol    ecx, 16                    ; 00000010H
    mov    DWORD PTR [eax], ecx

; 15   :  }

    ret    0
?SwapHalf@@YAXPAI@Z ENDP                ; SwapHalf

B>void swap_words(uint32_t* arg)
B>{
B>    union { uint32_t v; uint16_t sp[2]; } u = {*arg};
B>    std::swap(u.sp[0], u.sp[1]);
B>    *arg = u.v;
B>}
B>

Pay special attention to code like this:

union a_union {
int i;
double d;
};

int f() {
a_union t;
t.d = 3.0;
return t.i;
}

The practice of reading from a different union member than the one
most recently written to (called “type-punning”) is common. Even with
‘-fstrict-aliasing’, type-punning is allowed, provided the memory is
accessed through the union type. So, the code above will work as expected.
However, this code might not:

int f() {
a_union t;
int* ip;
t.d = 3.0;
ip = &t.i;
return *ip;
}

If a program attempts to access the stored value of an object through an lvalue of other than one of the following
types the behavior is undefined (48):
— the dynamic type of the object,
— a cv-qualified version of the dynamic type of the object,
— a type that is the signed or unsigned type corresponding to the dynamic type of the object,
— a type that is the signed or unsigned type corresponding to a cv-qualified version of the dynamic type of
the object,
— an aggregate or union type that includes one of the aforementioned types among its members (including,
recursively, a member of a subaggregate or contained union),
— a type that is a (possibly cv-qualified) base class type of the dynamic type of the object,
— a char or unsigned char type.
__________________
(48) The intent of this list is to specify those circumstances in which an object may or may not be aliased