The C Memory Quiz (DRAFT, Version 0.2)

#include <string.h> 
#include <stdint.h>
int  y = 2, x=1;
int main() {
  // assume for this question that the line below
  // legitimately calculates an offset from x to y,
  // or that an offset is known from some other source
  intptr_t offset = (intptr_t)&y - (intptr_t)&x;
  // now consider:
  int *p = (int *)((intptr_t)&x + offset);
  int *q = &y;
  if (memcmp(&p, &q, sizeof(p)) == 0) {
    *p = 11; // is this free of undefined behaviour?
  }
}

#include <stdint.h>
int  y = 2, x=1;
int main() {
  // assume for this question that the line below
  // legitimately calculates an offset from x to y,
  // or that an offset is known from some other source
  intptr_t offset = (intptr_t)&y - (intptr_t)&x;
  // now consider:
  int *p = (int *)((intptr_t)&x + offset);
  int *q = &y;
  if (p==q) {
    *p = 11; // is this free of undefined behaviour?
  }
}

#include <stdint.h>
int  y = 2, x=1;
int main() {
  // assume for this question that the line below
  // legitimately calculates an offset from x to y,
  // or that an offset is known from some other source
  intptr_t offset = (intptr_t)&y - (intptr_t)&x;
  // now consider:
  int *p = (int *)((intptr_t)&x + offset);
  int *q = &y;
  *p = 11;   
  // in an implementation in which p and q 
  // happen to hold the same address, is the line
  // above free of undefined behaviour?
}

#include <stdio.h>
#include <string.h>
int  x=1;
int main() {
  int *p = &x;
  int *q;
  memcpy (&q, &p, sizeof p); 
  *q = 11; // is this free of undefined behaviour?
  printf("*p=%d  *q=%d\n",*p,*q);  
}

#include <stdio.h>
#include <string.h>
int  x=1;
void user_memcpy2(unsigned char* dest, unsigned char *src, 
                 size_t n) {
  while (n > 0)  {		
    *dest = ((*src) ^ 1) ^ 1;
    src += 1;
    dest += 1;
    n -= 1;
  }
}
int main() {
  int *p = &x;
  int *q;
  user_memcpy2((unsigned char*)&q, (unsigned char*)&p, 
              sizeof(p));
  *q = 11; // is this free of undefined behaviour?
  printf("*p=%d  *q=%d\n",*p,*q);
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int main() {
  int *p, *q;
  p = malloc (sizeof (int)); assert (p != NULL);
  free(p);
  q = malloc (sizeof (int)); assert (q != NULL);
  if (memcmp (&p, &q, sizeof p) == 0) {
    printf("memcmp==0\n");
    *p = 42;  // is this free of undefined behaviour?
  }
}

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
  int *pj = (int *)(malloc(sizeof(int))); 
  *pj=1;
  char c1 = *((char *)&pj);
  free(pj);
  char c2 = *((char *)&pj);
  int b = (c1 == c2); // is this free of undef. beh.?
  // and always true?
  printf("c1=%i  c2=%i  b=%s\n",
	 (int)c1,(int)c2,b?"true":"false");
}

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
  int *pj = (int *)(malloc(sizeof(int))); 
  *pj=1;
  free(pj);
  // can the representation bytes of pj 
  // be assumed not to be undefined values?  E.g.:
  char c1 = *((char *)&pj);
  char c2 = *((char *)&pj);
  int b = (c1 == c2);  // is this always true?
  printf("c1=%i  c2=%i  b=%s\n",
	 (int)c1,(int)c2,b?"true":"false");
}

#include <stdio.h>
int  y = 2, x=1;
int main() {
  int *p = &x, *q = &y;
  _Bool b = (p < q); // does this have defined behaviour?
  printf("p=%p  q=%p\n",(void*)p,(void*)q);
  printf("(p<q) = %s\n", b?"true":"false");
}

#include <string.h> 
int  y = 2, x=1;
int main() {
  int *p = &x+1, *q = &y;
  if (memcmp(&p, &q, sizeof(p)) == 0) {
    int b = (p < q); // is this free of undef. beh.?
  }
}

#include <stdio.h>
#include <stdlib.h>
int main() {
  int i=0;
  int *pj = (int *)(malloc(sizeof(int))); 
  *pj=1;
  printf("(&i==pj)=%s\n",(&i==pj)?"true":"false");
  free(pj);
  printf("(&i==pj)=%s\n",(&i==pj)?"true":"false");
  return 0;
}

#include <assert.h>
#include <stdio.h>
int x=1;
int main() {
  assert(sizeof(unsigned long)==sizeof(int*)); 
  int *p = &x;
  unsigned long i = (unsigned long) p;
  int *q = (int *)i;
  // are p and q now equivalent?  For example:
  int y = *q;     // - is this not undefined behaviour?
  int b = (q==p); // - does this compare true?
  *q=2; 
  int z = *p;     // - does this give 2? 
  printf("y=%i (q==p)=%s z=%i\n",y,b?"true":"false",z);
}

#include <assert.h>
#include <stdio.h>
int x=1;
int main() {
  assert(sizeof(unsigned long)==sizeof(int*));
  int *p = &x;
  unsigned long i = (unsigned long) p;
  int w=0;  
  unsigned long j = (unsigned long) &w;
  i = (i ^ j) ^ j;// some computation on the integer
  int *q = (int *)i;
  // are p and q now equivalent?  For example:
  int y = *q;     // - is this not undefined behaviour?
  int b = (q==p); // - does this compare true?
  *q=2; 
  int z = *p;     // - does this give 2? 
  printf("y=%i (q==p)=%s z=%i\n",y,b?"true":"false",z);
}

#include <assert.h>
#include <stdio.h>
#include <limits.h>
int x=1;
int main() {
  assert(sizeof(unsigned long)==sizeof(int*));
  int *p = &x;
  unsigned long i = (unsigned long) p;
  int *q;
  assert(_Alignof(int) >= 4);
  assert((i & 3u) == 0u);
  i = i | 1u;               
  q = (int *) i; // is this free of undefined behaviour?
  i = i & (ULONG_MAX - 3u);  
  q = (int *) i; 
  // are p and q now equivalent?  For example:
  int y = *q;     // - is this not undefined behaviour?
  int b = (q==p); // - does this compare true?
  *q=2; 
  int z = *p;     // - does this give 2? 
  printf("y=%i (q==p)=%s z=%i\n",y,b?"true":"false",z);
}

#include <stdio.h>
int x=1;
int main() {
  int *p = &x;
  float *q1 = (float *) p;
  char **q2 = (char **) q1;
  int *q3 = (int *) q2;    
  // are p and q3 now equivalent?  For example:
  int y = *q3;     // - is this not undefined behaviour?
  int b = (q3==p); // - does this compare true?
  *q3=2; 
  int z = *p;      // - does this give 2? 
  printf("y=%i (q3==p)=%s z=%i\n",y,b?"true":"false",z);
}

#include <stdio.h>
typedef struct { int  i; float f; } st;
int main() {
  st s = {.i = 1, .f = 1.0};
  int *pi = &(s.i);
  st* p = (st*) pi; // is this free of undefined behaviour?
  p->f = 2.0;       // and this?
  printf("s.f=%f  p->f=%f\n",s.f,p->f);
}

#include <stdio.h>
typedef union { int  i; float f; } un;
int main() {
  un u = {.i = 1};
  int *pi = &(u.i);
  un* p = (un*) pi; // is this free of undefined behaviour?
  p->f = 2.0;       // and this?
  printf("u.f=%f  p->f=%f\n",u.f,p->f);
}

int main(void) {
  int a[2] = {0, 1};
  //int *p = &(a[0]);
  int (*q)[2] = (int(*)[2]) a;
  *q[1] = 11; // is this free of undefined behaviour ?
  return 0;
}

#include <stdio.h>
#include <stddef.h>
typedef struct { int  i; float f; } st;
int main() {
  st s = {.i = 1, .f = 1.0};
  float *pf = &(s.f);
  int *pi = (int *)  (((char *)pf - offsetof(st,f)) 
                      + offsetof(st,i));
  *pi = 2.0; // is this free of undefined behaviour?
  printf("s.i=%i  *pi=%i\n",s.i,*pi);
}

#include <stdio.h>
typedef union { int  i; float f; } un;
int main() {
  un u = {.i = 1};
  int *pi = &(u.i);
  float* pf = (float*) pi; // is this not undef. beh.?
  *pf = 2.0;               // and this?
  printf("u.f=%f  *pf=%f\n",u.f,*pf);
}

#include <stdio.h>
typedef struct { int  i1; float f1; char c1; } st1;
typedef struct { int  i2; float f2; double d2; } st2;
int main() {
  st1 s1 = {.i1 = 1, .f1 = 1.0, .c1 = 'a'};
  st2 *p2 = (st2 *) (&s1);// is this free of undef.beh.?
  p2->f2=2.0;             // and this?
  printf("s1.f1=%f  p2->f2=%f\n",s1.f1,p2->f2);
}

#include <stdio.h>
#include <string.h>
typedef struct { int  i1; float f1; } st1;
typedef struct { int  i2; st1 st1_2;  } st2;
int main() {
  st1 s1 = {.i1 = 1, .f1 = 1.0 };
  st2 s2 = {.i2 = 2, .st1_2 = { .i1 = 2, .f1 = 2.0 } };
  memcpy(&(s2.st1_2), &s1, sizeof(st1)); 
  int i = s2.st1_2.i1; // is this free of undef.beh.?
  printf("i=%i\n",i);
}

#include <stdio.h>
#include <string.h>
typedef struct { int  i; float f; } st;
int main() {
  st s1 = {.i = 1, .f = 1.0 };
  st s2;
  memcpy(&(s1.i), &(s2.i), sizeof(int)); 
  memcpy(&(s1.f), &(s2.f), sizeof(float)); 
  // is s2 now a copy of s1?
}

#include <stdlib.h>
#include <assert.h>
#define max(a, b) ((a) > (b) ? (a) : (b))
int main() {
  // manual layout for a char and float pair
  size_t i_offset = 0;
  assert(sizeof(char) <= _Alignof(float));
  size_t f_offset = _Alignof(float);
  size_t size = f_offset + sizeof(float);
  // storing a char and a float in an allocated region
  char *p = malloc(size); assert (p != NULL);
  *((char *)(p+i_offset)) = 'a';
  *((float *)(p+f_offset)) = 1.0;
  // is this free of undefined behaviour?
}

#include <stdlib.h>
#include <assert.h>
#define max(a, b) ((a) > (b) ? (a) : (b))
int main() {
  // manual layout for a char and float sum
  size_t size = max(sizeof(char), sizeof(float));
  char *p = malloc(size); assert (p != NULL);
  *((char *)p) = 'a';
  // a type-changing update from char to float
  //  in an allocated region
  *((float *)p) = 1.0;
  // is this free of undefined behaviour?
}

#include <stdlib.h>
#include <assert.h>
typedef struct { char c; float f; } st;
int main() {
  char *p = malloc(sizeof(st)); assert (p != NULL);
  ((st *)p)->c = 'a';
  ((st *)p)->f = 1.0;
  // is this free of undefined behaviour?
}

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <assert.h>
typedef struct { char c1; float f1; } st1;
typedef struct { char c2; float f2; } st2;
int f(st1 s1) {
  return ( (int)s1.c1 + (int)s1.f1);
}
int main() {
  assert(sizeof(st1)==sizeof(st2));
  assert(offsetof(st1,c1)==offsetof(st2,c2));
  assert(offsetof(st1,f1)==offsetof(st2,f2));
  char *p = malloc(sizeof(st1)); assert (p != NULL);
  ((st1 *)p)->c1 = 'A';
  ((st2 *)p)->f2 = 1.0;
  // is this free of undefined behaviour?
  // if so, what effective type does each region of 
  //  memory have after each assignment?
  int i = f( *((st1 *)p));
  // is the body of f also free of undefined behaviour?
  printf("i=%i\n",i);
}
// Given (i), the assignment to ((st2 *)p)->f2 would 
// be undefined behaviour, while (ii) and (iii) would be 
// permitted. 
// The dereference of s1.f1 (in the body of f) would be 
// undefined behaviour for (ii) but permitted for (iii). 

#include <stdio.h>
#include <assert.h>
int main() {
  assert(sizeof(int)==sizeof(float));
  float f = 1.0;
  int i = *((int*) (&f)); // is this not undef. beh.?
  printf("f=%f  i=%i\n",f,i);
}

#include <stdio.h>
#include <assert.h>
typedef union { int  i; float f; } un;
int main() {
  assert(sizeof(int)==sizeof(float));
  un u = {.f = 1.0};
  float *pf = &(u.f);
  int* pi = (int*) pf; // is this not undef. beh.?
  int j = *pi;         // and this?
  printf("u.f=%f  j=%i\n",u.f,j);
}

#include <stdio.h>
int main() {
  char c; 
  int b = (c==c);  // is this always true?
  printf("(c==c)=%s\n",b?"true":"false"); 
}

#include <stdio.h>
int main() {
  unsigned char c; 
  unsigned char c2 = (c % 2);
  // can reading c2 give something other than 0 or 1?
  printf("c=%i  c2=%i\n",(int)c,(int)c2);
}

#include <stdio.h>
int main() {
  int i;
  char c = * ((char*)(&i)); 
  // does c now hold an unspecified value?
  printf("i=0x%x  c=%i\n",i,(int)c);
  printf("i=0x%x  c=%i\n",i,(int)c);
}

#include <stdio.h>
#include <stddef.h>
#include <assert.h>
typedef struct { char c; float f; } st;
int main() {
  // check there is a padding byte between c and f
  size_t offset_padding = offsetof(st,c)+sizeof(char);
  assert(offsetof(st,f)>offset_padding);
  st s = {.c = 'A', .f = 1.0};
  char *padding = (char*)(&s + offset_padding);
  *padding = 0; 
  s.f = 2.0;
  // does *padding now hold an unspecified value?
  printf("s.c=%c  s.f=%f  *padding=%i\n",
	 s.c,s.f,(int)*padding);
}

#include <stdio.h>
int main() {
  // assume int has multiple representations of value v
  int v=1;
  int  i=v;
  char c1 = *((unsigned char *) &i);
  char c2 = *((unsigned char *) &i);
  // do c1 and c2 not hold unspecified values?
  int b = (c1==c2); // and is this guaranteed to be true?
  printf("c1=%i  c2=%i  b=%s\n",
	 (int)c1,(int)c2,b?"true":"false");
}

#include <stdio.h>
#include <assert.h>
int main() {
  assert(sizeof(int)==4);
  // assume int has multiple representations of value v
  int v=1;
  int  i=v, j=0;
  unsigned char *pi = (unsigned char *) &i;
  unsigned char *pj = (unsigned char *) &j;
  *(pj+0) = *(pi+0);
  *(pj+1) = *(pi+1);
  *(pj+2) = *(pi+2);
  *(pj+3) = *(pi+3);
  // is j guaranteed not to be a trap representation?
  int b = (j==i); // is this guaranteed to be true?
  printf("i=%i  j=%i  b=%s\n",i,j,b?"true":"false");
}

#include <stdio.h>
#include <assert.h>
int main() {
  assert(sizeof(int)==4);
  // assume int has multiple representations of value v
  int v=1;
  int  i=v, j=0;
  unsigned char *pi = (unsigned char *) &i;
  unsigned char *pj = (unsigned char *) &j;
  *(pj+0) = *(pi+0);
  *(pj+1) = *(pi+1);
  i=v;
  *(pj+2) = *(pi+2);
  *(pj+3) = *(pi+3);
  // is j guaranteed not to be a trap representation?
  int b = (j==i); // is this guaranteed to be true?
  printf("i=%i  j=%i  b=%s\n",i,j,b?"true":"false");
}