Add repr_c_implicit_padding lint (off by default)

The `repr_c_implicit_padding` lint checks structures marked
a u8 followed by a u64, which would require 7 bytes of padding
to get the u64 aligned correctly.

The reason for this is that in the BSD socket code, there is
some shifty casting between structs which results in data being
stored in padding bytes. Since the LLVM Load instruction does
not copy padding, this can result in data loss. (This is also a
problem in C, but since structs are rarely copied by value,
instead using pointers and memcpy(), it is not as serious a
problem.) We therefore need explicit padding for the socket
structures, and this lint will make sure we get it.

This is necessary because the recent pull

  rust-lang#16081

which is a fix for rust-lang#15763, changes the return value semantics
to involve a Load. Without padding fixes, this breaks the Tcp
code.

Author: apoelstra

src/libnative/io/addrinfo.rs

@@ -40,7 +40,8 @@ impl GetAddrInfoRequest {
                 ai_addrlen: 0,
                 ai_canonname: mut_null(),
                 ai_addr: mut_null(),
-                ai_next: mut_null()
+                ai_next: mut_null(),
+                __padding: [0, ..4]
             }
         });
 

src/librustc/lint/builtin.rs

@@ -1536,6 +1536,9 @@ declare_lint!(pub UNKNOWN_CRATE_TYPE, Deny,
 declare_lint!(pub VARIANT_SIZE_DIFFERENCE, Allow,
               "detects enums with widely varying variant sizes")
 
+declare_lint!(pub REPR_C_IMPLICIT_PADDING, Allow,
+              "detects implicit padding, which cannot be memset reliably, in C structures")
+
 /// Does nothing as a lint pass, but registers some `Lint`s
 /// which are used by other parts of the compiler.
 pub struct HardwiredLints;
@@ -1554,7 +1557,8 @@ impl LintPass for HardwiredLints {
             WARNINGS,
             UNKNOWN_FEATURES,
             UNKNOWN_CRATE_TYPE,
-            VARIANT_SIZE_DIFFERENCE
+            VARIANT_SIZE_DIFFERENCE,
+            REPR_C_IMPLICIT_PADDING
         )
     }
 }

src/librustc/lint/context.rs

@@ -638,6 +638,16 @@ impl LintPass for GatherNodeLevels {
                     _ => { }
                 }
             },
+            ast::ItemStruct(..) => {
+                let lint_id = LintId::of(builtin::REPR_C_IMPLICIT_PADDING);
+                match cx.lints.get_level_source(lint_id) {
+                    lvlsrc @ (lvl, _) if lvl != Allow => {
+                        cx.node_levels.borrow_mut()
+                            .insert((it.id, lint_id), lvlsrc);
+                    },
+                    _ => { }
+                }
+            }
             _ => { }
         }
     }

src/librustc/middle/trans/base.rs

@@ -1908,6 +1908,29 @@ fn enum_variant_size_lint(ccx: &CrateContext, enum_def: &ast::EnumDef, sp: Span,
     }
 }
 
+fn struct_repr_padding_lint(ccx: &CrateContext, struct_def: &ast::StructDef, id: ast::NodeId) {
+    let levels = ccx.tcx.node_lint_levels.borrow();
+    let lint_id = lint::LintId::of(lint::builtin::REPR_C_IMPLICIT_PADDING);
+    let lvlsrc = match levels.find(&(id, lint_id)) {
+        None | Some(&(lint::Allow, _)) => return,
+        Some(&lvlsrc) => lvlsrc,
+    };
+
+    let mut total_size = 0;
+    for field in struct_def.fields.iter() {
+        let align = llalign_of_min(ccx, sizing_type_of(ccx,
+                                            ty::node_id_to_type(&ccx.tcx, field.node.id)));
+        if total_size % align != 0 {
+            lint::raw_emit_lint(&ccx.tcx().sess, lint::builtin::REPR_C_IMPLICIT_PADDING,
+                              lvlsrc, Some(field.span),
+                              format!("field expects alignment of {} bytes, but is being \
+                                       inserted after {}", align, total_size).as_slice());
+        }
+        total_size += llsize_of_real(ccx, sizing_type_of(ccx,
+                                            ty::node_id_to_type(&ccx.tcx, field.node.id)));
+    }
+}
+
 pub struct TransItemVisitor<'a> {
     pub ccx: &'a CrateContext,
 }
@@ -1977,6 +2000,14 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
       ast::ItemForeignMod(ref foreign_mod) => {
         foreign::trans_foreign_mod(ccx, foreign_mod);
       }
+      ast::ItemStruct(ref struct_definition, _) => {
+          // Only run the struct padding lint if we have #[repr(C)]
+          if item.attrs.iter().fold(attr::ReprAny, |acc, attr| {
+              attr::find_repr_attr(ccx.tcx.sess.diagnostic(), attr, acc)
+          }) == attr::ReprExtern {
+              struct_repr_padding_lint(ccx, &**struct_definition, item.id);
+          }
+      }
       ast::ItemTrait(..) => {
         // Inside of this trait definition, we won't be actually translating any
         // functions, but the trait still needs to be walked. Otherwise default

src/librustuv/addrinfo.rs

@@ -65,6 +65,7 @@ impl GetAddrInfoRequest {
                 ai_canonname: mut_null(),
                 ai_addr: mut_null(),
                 ai_next: mut_null(),
+                __padding: [0, ..4]
             }
         });
         let hint_ptr = hint.as_ref().map_or(null(), |x| {