GenASM: Make sure the stack is 16 byte aligned before calling malloc or free.

The GenASM visitor only uses quad mnemonics so each manipulation to the stack is done in 8 byte chunks. This means our stack is always 8 byte aligned which is fine when only calling KLang code. libc functions like 'malloc' or 'free' require the stack to be 16 byte aligned which isn't automatically guaranteed when being 8 byte aligned. This is why we need to be careful when manipulating the stack (e.g. pushq, popq, subq x, %rsp). By assuming that we are stack aligned at the beginning of execution and by tracking the number of pushq operations we can deduce whether we misaligned the stack and align it again by adding another 8 byte to the stack.

This re-alignment of the stack is done directly before entering a function body or calling malloc. Since there are no stack manipulations involved when generating the code to calling 'free' there is reason to check for alignment there.

src/test/test.k

@@ -555,6 +555,72 @@ function getTestStructRec(a: int, b: testStructRec): testStructRec {
   return create testStructRec(a, b);
 }
 
+struct evenFieldsStruct {
+  a: int;
+  b: int;
+}
+
+struct oddFieldsStruct {
+  a: int;
+  b: int;
+  c: int;
+}
+
+function stackAlignmentTestInternal1(): oddFieldsStruct {
+  // an odd amount of constructor parameters could lead to an unaligned stack
+  // which results in a segmentation fault when calling malloc
+  return create oddFieldsStruct(1, 1, 1);
+}
+
+function stackAlignmentTestInternal2(): evenFieldsStruct {
+  // an odd amount of local variables could lead to an unaligned stack
+  // which results in a segmentation fault when calling malloc
+  let a: evenFieldsStruct = create evenFieldsStruct(1, 1);
+  return a;
+}
+
+function stackAlignmentTestInternal3(a: int): evenFieldsStruct {
+  // an odd amount of function parameters could lead to an unaligned stack
+  // which results in a segmentation fault when calling malloc
+  return create evenFieldsStruct(1, 1);
+}
+
+function stackAlignmentTestInternal4(a: int): evenFieldsStruct {
+  // if (function parameters + local variables + constructor parameters) is odd
+  // then this could lead to an unaligned stack
+  // which results in a segmentation faul when calling malloc
+  let b: int = 0;
+  let c: int = 0;
+  return create evenFieldsStruct(1, 1);
+}
+
+function stackAlignmentTestInternal5(a: int, b: int): evenFieldsStruct {
+  // if (function parameters + local variables + constructor parameters) is odd
+  // then this could lead to an unaligned stack
+  // which results in a segmentation faul when calling malloc
+  let c: int = 0;
+  return create evenFieldsStruct(1, 1);
+}
+
+function stackAlignmentTestInternal6(a: int, b: int): oddFieldsStruct {
+  // if (function parameters + local variables + constructor parameters) is odd
+  // then this could lead to an unaligned stack
+  // which results in a segmentation faul when calling malloc
+  let c: int = 0;
+  let d: int = 0;
+  return create oddFieldsStruct(1, 1, 1);
+}
+
+function isStackAlignedBeforeFunctionCall(): int {
+  let a: oddFieldsStruct = stackAlignmentTestInternal1();
+  let b: evenFieldsStruct = stackAlignmentTestInternal2();
+  let c: evenFieldsStruct = stackAlignmentTestInternal3(1);
+  let d: evenFieldsStruct = stackAlignmentTestInternal4(1);
+  let e: evenFieldsStruct = stackAlignmentTestInternal5(1, 1);
+  let f: oddFieldsStruct = stackAlignmentTestInternal6(1, 1);
+  return 1;
+}
+
 function getStructFieldA(t: testStruct): int {
   return t.a;
 }