parsefields: fix padding calculation

This was causing issues with aggregate types. A simple reproduction is:

type :type.1 = align 8 { 24 }
type :type.2 = align 8 { w 1, :type.1 1 }

The size of type.2 should be 32, adding only 4 bytes of padding between
the first and second field. Prior to this patch, 20 bytes of padding was
added instead, causing the type to have a size of 48.

Signed-off-by: Drew DeVault <[email protected]>

1 files changed, 21 insertions, 0 deletions

diff --git a/test/abi7.ssa b/test/abi7.ssa
new file mode 100644
index 0000000..bf8ca1f
--- /dev/null
+++ b/test/abi7.ssa
@@ -0,0 +1,21 @@
+# test padding calculation with                                                                     
+# embedded struct                                                                                   
+                                                                                                    
+type :s1 = align 4 { w 3 }                                                                          
+type :s2 = align 4 { b 1, :s1 1 }                                                                   
+                                                                                                    
+export function :s2 $test() {                                                                       
+@start                                                                                              
+        ret $s                                                                                      
+}                                                                                                   
+                                                                                                    
+# >>> driver                                                                                        
+# struct s2 {                                                                                       
+#       char x;                                                                                     
+#       struct { int a[3]; } s1;                                                                    
+# } s = { .x = 123 };                                                                               
+# extern struct s2 test(void);                                                                      
+# int main(void) {                                                                                  
+#       return !(test().x == 123);                                                                  
+# }                                                                                                 
+# <<<