#include <stddef.h>
#include <stdint.h>
struct item;
size_t item_size(void);
void id_setid(struct item * it, int32_t id);
int item_getid(struct item * it);

#include "opaque.h"
struct item { int32_t id; };
size_t item_size(void) { return sizeof(struct item); }
void id_setid(struct item * it, int32_t id) { it->id = id; }
int item_getid(struct item * it) { return it->id; }

#include <assert.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void memset_16aligned(void * ptr, char byte, size_t size_bytes, uint16_t alignment) {
    assert((size_bytes & (alignment-1)) == 0); // Size aligned
    assert(((uintptr_t)ptr & (alignment-1)) == 0); // Pointer aligned
    memset(ptr, byte, size_bytes);
}
// 1. Careful with segmented address spaces: lookup uintptr_t semantics
// 2. Careful with long standing existing optimization compiler bugs pointer to
// integer and back optimizations in for example clang and gcc
// 3. Careful with LTO potentially creating problem 2.
// 4. Consider C11 aligned_alloc or posix_memalign
void ptrtointtoptr() {
  const uint16_t alignment = 16;
  const uint16_t align_min_1 = alignment - 1;
  void * mem = malloc(1024+align_min_1);
  // C89: void *ptr = (void *)(((INT_WITH_PTR_SIZE)mem+align_min_1) & ~(INT_WITH_PTR_SIZE)align_min_1);
  // ie void *ptr = (void *)(((uint64_t)mem+align_min_1) & ~(uint64_t)align_min_1);
  // offset ptr to next alignment byte boundary
  void * ptr = (void *)(((uintptr_t)mem+align_min_1) & ~(uintptr_t)align_min_1);
  printf("0x%08" PRIXPTR ", 0x%08" PRIXPTR "\n", (uintptr_t)mem, (uintptr_t)ptr);
  memset_16aligned(ptr, 0, 1024, alignment);
  free(mem);
}

#include <immintrin.h>
void memcpy_avx(__m256i * __restrict src, __m256i * __restrict dest, size_t n);

#include "extern.h"
/// requires 32 byte aligned src, dest; src and dest must not overlap
void memcpy_avx(__m256i * __restrict src, __m256i * __restrict dest, size_t n);
  size_t n_vec = n / sizeof(__m256i);
  for(size_t i=0; i<n_vec; i+=1) {
    const __m256i temp = _mm256_load_si256(src);
    _mm256_store_si256(dest, temp);
    src += 1;
    dest += 1;
  }
}

#include <stdio.h>
#include <stdint.h>
#include "extern.h"
int main(void) {
  uint8_t mem_src[1024] = { 0 };
  uint8_t mem_dest[1024] = { 0 };
  const uint16_t alignment = 32;
  const uint16_t align_min_1 = alignment - 1;
  __m256i * p_src = (void *)(((uintptr_t)mem_src+align_min_1) & ~(uintptr_t)align_min_1);
  __m256i * p_dest = (void *)(((uintptr_t)mem_dest+align_min_1) & ~(uintptr_t)align_min_1);
  memcpy_avx(p_src, p_dest, 4);
  fprintf(stdout, "p_src: %p, p_dest: %p\n", (void*)p_src, (void*)p_dest);
  return 0;
}
// clang -Weverything -O3 -march=native memcpy_avx.c extern.c && ./a.out
// Output (contains C++ warnings):
// extern.c:8:5: warning: unsafe pointer arithmetic [-Wunsafe-buffer-usage]
//     8 |     src += 1;
//       |     ^~~
// extern.c:9:5: warning: unsafe pointer arithmetic [-Wunsafe-buffer-usage]
//     9 |     dest += 1;
//       |     ^~~~
// 2 warnings generated.
// p_src: 0x7ffceb985a60, p_dest: 0x7ffceb985660

# Install opam with ocaml
git clone https://github.com/rems-project/cerberus
opam install --deps-only ./cerberus-lib.opam ./cerberus.opam
make
make install DESTDIR=$HOME/.local/cerberus
echo 'PATH=${PATH}:"$HOME/.local/cerberus/bin"' >> ~/.bashrc
eval (opam env)
cerberus --help

#include <stddef.h>
extern size_t x;

#include "extern.h"
size_t x = 0;

#include <stddef.h>
#include <stdio.h>
#include "extern.h"
// Removing restrict makes the miscompilation go away
size_t f(size_t * restrict ptr_to_x);
size_t f(size_t * restrict ptr_to_x) {
  size_t * p = ptr_to_x;
  *p = 1;
  if (p == &x) {
      // Expected branch, taken only in Debug mode
      *p = 2;
  }
  return *p;
}
int main(void) {
  if (f(&x) == 1) fprintf(stderr, "panic : p != &x\n");
}
// clang -O0 -Weverything ptr_provenance_miscompilation.c extern.c && ./a.out
// output:
// clang -O1 -Weverything ptr_provenance_miscompilation.c extern.c && ./a.out
// output: panic : p != &x
// cerberus ptr_provenance_miscompilation.c extern.c
// output:
// merging everything into ptr_provenance_miscompilation.c
// cerberus ptr_provenance_miscompilation.c
// output: