Makesdna: Fix detecting 32 bit padding issues.

Makesdna fails to detect issues in 32 bit code that can
only be resolved by adding a padding pointer.

We never noticed since we ourselves no longer build for
32 bit, but debian's 32 bit builds got bitten by this

A rather extensive explanation on why this is alignment
requirement is there can be found in this comment:

https://developer.blender.org/D9389#233034

Differential Revision: https://developer.blender.org/D12188

Reviewed by: sergey, campbellbarton

1 files changed, 58 insertions, 11 deletions

diff --git a/source/blender/makesdna/intern/makesdna.c b/source/blender/makesdna/intern/makesdna.c
index 85bcc94c335..2ee410efab4 100644
--- a/source/blender/makesdna/intern/makesdna.c
+++ b/source/blender/makesdna/intern/makesdna.c
@@ -164,6 +164,10 @@ static char **names;
 static char **types;
 /** At `types_size[a]` is the size of type `a` on this systems bitness (32 or 64). */
 static short *types_size_native;
+/** Contains align requirements for a struct on 32 bit systems. */
+static short *types_align_32;
+/** Contains align requirements for a struct on 64 bit systems. */
+static short *types_align_64;
 /** Contains sizes as they are calculated on 32 bit systems. */
 static short *types_size_32;
 /** Contains sizes as they are calculated on 64 bit systems. */
@@ -374,6 +378,8 @@ static int add_type(const char *str, int size)
         types_size_native[index] = size;
         types_size_32[index] = size;
         types_size_64[index] = size;
+        types_align_32[index] = size;
+        types_align_64[index] = size;
       }
       return index;
     }
@@ -387,7 +393,8 @@ static int add_type(const char *str, int size)
   types_size_native[types_len] = size;
   types_size_32[types_len] = size;
   types_size_64[types_len] = size;
-
+  types_align_32[types_len] = size;
+  types_align_64[types_len] = size;
   if (types_len >= max_array_len) {
     printf("too many types\n");
     return types_len - 1;
@@ -926,7 +933,9 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
         int size_native = 0;
         int size_32 = 0;
         int size_64 = 0;
-        bool has_pointer = false;
+        /* Sizes of the largest field in a struct. */
+        int max_align_32 = 0;
+        int max_align_64 = 0;
 
         /* check all elements in struct */
         for (int b = 0; b < structpoin[1]; b++, sp += 2) {
@@ -955,7 +964,6 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
 
           /* is it a pointer or function pointer? */
           if (cp[0] == '*' || cp[1] == '*') {
-            has_pointer = 1;
             /* has the name an extra length? (array) */
             int mul = 1;
             if (cp[namelen - 1] == ']') {
@@ -1002,6 +1010,8 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
             size_native += sizeof(void *) * mul;
             size_32 += 4 * mul;
             size_64 += 8 * mul;
+            max_align_32 = MAX2(max_align_32, 4);
+            max_align_64 = MAX2(max_align_64, 8);
           }
           else if (cp[0] == '[') {
             /* parsing can cause names "var" and "[3]"
@@ -1047,6 +1057,8 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
             size_native += mul * types_size_native[type];
             size_32 += mul * types_size_32[type];
             size_64 += mul * types_size_64[type];
+            max_align_32 = MAX2(max_align_32, types_align_32[type]);
+            max_align_64 = MAX2(max_align_64, types_align_64[type]);
           }
           else {
             size_native = 0;
@@ -1063,16 +1075,42 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
           types_size_native[structtype] = size_native;
           types_size_32[structtype] = size_32;
           types_size_64[structtype] = size_64;
-          /* Two ways to detect if a struct contains a pointer:
-           * has_pointer is set or size_native doesn't match any of 32/64bit lengths. */
-          if (has_pointer || size_64 != size_native || size_32 != size_native) {
-            if (size_64 % 8) {
+          types_align_32[structtype] = max_align_32;
+          types_align_64[structtype] = max_align_64;
+
+          /* Santiy check 1: alignment should never be 0. */
+          BLI_assert(max_align_32);
+          BLI_assert(max_align_64);
+
+          /* Santiy check 2: alignment should always be equal or smaller than the maximum
+           * size of a build in type which is 8 bytes (ie int64_t or double). */
+          BLI_assert(max_align_32 <= 8);
+          BLI_assert(max_align_64 <= 8);
+
+          if (size_32 % max_align_32) {
+            /* There is an one odd case where only the 32 bit struct has alignment issues
+             * and the 64 bit does not, that can only be fixed by adding a padding pointer
+             * to the struct to resolve the problem. */
+            if ((size_64 % max_align_64 == 0) && (size_32 % max_align_32 == 4)) {
               fprintf(stderr,
-                      "Sizeerror 8 in struct: %s (add %d bytes)\n",
+                      "Sizeerror in 32 bit struct: %s (add paddding pointer)\n",
+                      types[structtype]);
+            }
+            else {
+              fprintf(stderr,
+                      "Sizeerror in 32 bit struct: %s (add %d bytes)\n",
                       types[structtype],
-                      size_64 % 8);
-              dna_error = 1;
+                      max_align_32 - (size_32 % max_align_32));
             }
+            dna_error = 1;
+          }
+
+          if (size_64 % max_align_64) {
+            fprintf(stderr,
+                    "Sizeerror in 64 bit struct: %s (add %d bytes)\n",
+                    types[structtype],
+                    max_align_64 - (size_64 % max_align_64));
+            dna_error = 1;
           }
 
           if (size_native % 4 && !ELEM(size_native, 1, 2)) {
@@ -1189,6 +1227,9 @@ static int make_structDNA(const char *base_directory,
   types_size_native = MEM_callocN(sizeof(short) * max_array_len, "types_size_native");
   types_size_32 = MEM_callocN(sizeof(short) * max_array_len, "types_size_32");
   types_size_64 = MEM_callocN(sizeof(short) * max_array_len, "types_size_64");
+  types_align_32 = MEM_callocN(sizeof(short) * max_array_len, "types_size_32");
+  types_align_64 = MEM_callocN(sizeof(short) * max_array_len, "types_size_64");
+
   structs = MEM_callocN(sizeof(short *) * max_array_len, "structs");
 
   /* Build versioning data */
@@ -1277,7 +1318,11 @@ static int make_structDNA(const char *base_directory,
       sp += 2;
       /* ? num_types was elem? */
       for (b = 0; b < num_types; b++, sp += 2) {
-        printf("   %s %s\n", types[sp[0]], names[sp[1]]);
+        printf("   %s %s allign32:%d, allign64:%d\n",
+               types[sp[0]],
+               names[sp[1]],
+               types_align_32[sp[0]],
+               types_align_64[sp[0]]);
       }
     }
   }
@@ -1399,6 +1444,8 @@ static int make_structDNA(const char *base_directory,
   MEM_freeN(types_size_native);
   MEM_freeN(types_size_32);
   MEM_freeN(types_size_64);
+  MEM_freeN(types_align_32);
+  MEM_freeN(types_align_64);
   MEM_freeN(structs);
 
   BLI_memarena_free(mem_arena);