Modify ivar flags.

Add a flag to indicate that instance variables have an extended type
encoding.

Remove the alignment field and replace it with 6 bits from the flags
field.  We only support power of two alignments, so we may as well store
them in log form, which means we can save a field.  Note that this
doesn't actually save us any space except on 32-bit platforms, because
alignment means that we end up with extra padding at the end of the
struct.

Author: davidchisnall

Diff for: ivar.c

@@ -78,14 +78,14 @@ PRIVATE void objc_compute_ivar_offsets(Class class)
 				// We only need to do the realignment for things that are
 				// bigger than a pointer, and we don't need to do it in GC mode
 				// where we don't add any extra padding.
-				if (!isGCEnabled && (ivar->align > __alignof__(void*)))
+				if (!isGCEnabled && (ivarGetAlign(ivar) > __alignof__(void*)))
 				{
 					long offset = ivar_start + *ivar->offset + sizeof(intptr_t);
-					long fudge = ivar->align - (offset % ivar->align);
+					long fudge = ivarGetAlign(ivar) - (offset % ivarGetAlign(ivar));
 					*ivar->offset += fudge;
 					class->instance_size += fudge;
 					cumulative_fudge += fudge;
-					assert((ivar_start + *ivar->offset + sizeof(intptr_t)) % ivar->align == 0);
+					assert((ivar_start + *ivar->offset + sizeof(intptr_t)) % ivarGetAlign(ivar) == 0);
 				}
 				*ivar->offset += ivar_start;
 			}

Diff for: ivar.h

@@ -20,15 +20,11 @@ struct objc_ivar
 	 * the ivars declared by this class.  It is then set by the runtime to the
 	 * offset from the object pointer.
 	 */
-	int         *offset;
-	/**
-	 * Alignment of this ivar.
-	 */
-	int32_t          align;
+	int        *offset;
 	/**
 	 * Flags for this instance variable.
 	 */
-	int32_t          flags;
+	uint32_t    flags;
 };
 
 /**
@@ -56,15 +52,52 @@ typedef enum {
 } ivar_ownership;
 
 /**
- * Mask applied to the flags field to indicate ownership.
- */
-static const int ivar_ownership_mask = 3;
+ * Shift for instance variable alignment. */
+static const int ivar_align_shift = 3;
+
+typedef enum {
+	/**
+	 * Mask applied to the flags field to indicate ownership.
+	 */
+	ivar_ownership_mask = (1<<0) | (1<<1),
+	/**
+	 * Flag indicating that the ivar contains an extended type encoding.
+	 */
+	ivar_extended_type_encoding = (1<<2),
+	/**
+	 * Mask for describing the alignment.  We need 6 bits to represent any
+	 * power of two aligmnent from 0 to 63-bit alignment.  There is probably no
+	 * point supporting more than 32-bit aligment, because various bits of
+	 * offset assume objects are less than 4GB, but there's definitely no point
+	 * in supporting 64-bit alignment because we currently don't support any
+	 * architectures where an address space could contain more than one 2^64
+	 * byte aligned value.
+	 */
+	ivar_align_mask = (((1<<6)-1) << ivar_align_shift)
+} objc_ivar_flags;
+
+
+static inline size_t ivarGetAlign(Ivar ivar)
+{
+	return 1<<((ivar->flags & ivar_align_mask) >> ivar_align_shift);
+}
+
+static inline void ivarSetAlign(Ivar ivar, size_t align)
+{
+	if (align != 0)
+	{
+		align = sizeof(size_t) * 8 - __builtin_clz(align) - 1;
+	}
+	align  <<= ivar_align_shift;
+	ivar->flags = (ivar->flags & ~ivar_align_mask) | align;
+}
 
 static inline void ivarSetOwnership(Ivar ivar, ivar_ownership o)
 {
 	ivar->flags = (ivar->flags & ~ivar_ownership_mask) | o;
 }
 
+
 /**
  * Look up the ownership for a given instance variable.
  */

Diff for: legacy.c

@@ -94,10 +94,10 @@ static struct objc_ivar_list *upgradeIvarList(struct objc_class_gsv1 *cls)
 		{
 			n->ivar_list[i].offset = &l->ivar_list[i].offset;
 		}
-		n->ivar_list[i].align = ((type == NULL) || type[0] == 0) ? __alignof__(void*) : objc_alignof_type(type);
+		ivarSetAlign(&n->ivar_list[i], ((type == NULL) || type[0] == 0) ? __alignof__(void*) : objc_alignof_type(type));
 		if (type[0] == '\0')
 		{
-			n->ivar_list[i].align = size;
+			ivarSetAlign(&n->ivar_list[i], size);
 		}
 		ivarSetOwnership(&n->ivar_list[i], ownershipForIvar(cls, i));
 	}

Diff for: runtime.c

@@ -124,7 +124,7 @@ BOOL class_addIvar(Class cls, const char *name, size_t size, uint8_t alignment,
 	Ivar ivar = ivar_at_index(cls->ivars, cls->ivars->count - 1);
 	ivar->name = strdup(name);
 	ivar->type = strdup(types);
-	ivar->align = alignment;
+	ivarSetAlign(ivar, alignment);
 	// Round up the offset of the ivar so it is correctly aligned.
 	long offset = cls->instance_size;
 	if (alignment != 0)