[AIX] Lint on structs that have a different alignment in AIX's C ABI

Author: amy-kwan

compiler/rustc_lint/messages.ftl

@@ -970,6 +970,8 @@ lint_unused_result = unused result of type `{$ty}`
 
 lint_use_let_underscore_ignore_suggestion = use `let _ = ...` to ignore the expression or result
 
+lint_uses_power_alignment = repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+
 lint_variant_size_differences =
  enum variant is more than three times larger ({$largest} bytes) than the next largest
 

compiler/rustc_lint/src/lints.rs

@@ -1692,6 +1692,10 @@ pub(crate) struct OverflowingLiteral<'a> {
 publit:String,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(lint_uses_power_alignment)]
+pub(crate)structUsesPowerAlignment;
+
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_comparisons)]
 pub(crate)structUnusedComparisons;

compiler/rustc_lint/src/types.rs

@@ -1,14 +1,15 @@
 use std::iter;
 use std::ops::ControlFlow;
 
-use rustc_abi::{BackendRepr,ExternAbi,TagEncoding,Variants,WrappingRange};
+use rustc_abi::{BackendRepr,ExternAbi,TagEncoding,VariantIdx,Variants,WrappingRange};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::DiagMessage;
 use rustc_hir::{Expr,ExprKind,LangItem};
 use rustc_middle::bug;
 use rustc_middle::ty::layout::{LayoutOf,SizeSkeleton};
 use rustc_middle::ty::{
-self,AdtKind,GenericArgsRef,Ty,TyCtxt,TypeSuperVisitable,TypeVisitable,TypeVisitableExt,
+self,Adt,AdtKind,GenericArgsRef,Ty,TyCtxt,TypeSuperVisitable,TypeVisitable,
+TypeVisitableExt,
 };
 use rustc_session::{declare_lint, declare_lint_pass, impl_lint_pass};
 use rustc_span::def_id::LocalDefId;
@@ -23,7 +24,7 @@ use crate::lints::{
 AmbiguousWidePointerComparisonsAddrSuggestion,AtomicOrderingFence,AtomicOrderingLoad,
 AtomicOrderingStore,ImproperCTypes,InvalidAtomicOrderingDiag,InvalidNanComparisons,
 InvalidNanComparisonsSuggestion,UnpredictableFunctionPointerComparisons,
-UnpredictableFunctionPointerComparisonsSuggestion,UnusedComparisons,
+UnpredictableFunctionPointerComparisonsSuggestion,UnusedComparisons,UsesPowerAlignment,
 VariantSizeDifferencesDiag,
 };
 usecrate::{LateContext,LateLintPass,LintContext, fluent_generated as fluent};
@@ -727,7 +728,60 @@ declare_lint! {
 "proper use of libc types in foreign item definitions"
 }
 
-declare_lint_pass!(ImproperCTypesDefinitions => [IMPROPER_CTYPES_DEFINITIONS]);
+declare_lint!{
+/// The `uses_power_alignment` lint detects specific `repr(C)`
+/// aggregates on AIX.
+/// In its platform C ABI, AIX uses the "power" (as in PowerPC) alignment
+/// rule (detailed in https://www.ibm.com/docs/en/xl-c-and-cpp-aix/16.1?topic=data-using-alignment-modes#alignment),
+/// which can also be set for XLC by `#pragma align(power)` or
+/// `-qalign=power`. Aggregates with a floating-point type as the
+/// recursively first field (as in "at offset 0") modify the layout of
+/// *subsequent* fields of the associated structs to use an alignment value
+/// where the floating-point type is aligned on a 4-byte boundary.
+///
+/// The power alignment rule for structs needed for C compatibility is
+/// unimplementable within `repr(C)` in the compiler without building in
+/// handling of references to packed fields and infectious nested layouts,
+/// so a warning is produced in these situations.
+///
+/// ### Example
+///
+/// ```rust,ignore (fails on non-powerpc64-ibm-aix)
+/// #[repr(C)]
+/// pub struct Floats {
+/// a: f64,
+/// b: u8,
+/// c: f64,
+/// }
+/// ```
+///
+/// This will produce:
+///
+/// ```text
+/// warning: repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+/// --> <source>:5:3
+/// |
+/// 5 | c: f64,
+/// | ^^^^^^
+/// |
+/// = note: `#[warn(uses_power_alignment)]` on by default
+/// ```
+///
+/// ### Explanation
+///
+/// The power alignment rule specifies that the above struct has the
+/// following alignment:
+/// - offset_of!(Floats, a) == 0
+/// - offset_of!(Floats, b) == 8
+/// - offset_of!(Floats, c) == 12
+/// However, rust currently aligns `c` at offset_of!(Floats, c) == 16.
+/// Thus, a warning should be produced for the above struct in this case.
+USES_POWER_ALIGNMENT,
+Warn,
+"Structs do not follow the power alignment rule under repr(C)"
+}
+
+declare_lint_pass!(ImproperCTypesDefinitions => [IMPROPER_CTYPES_DEFINITIONS,USES_POWER_ALIGNMENT]);
 
 #[derive(Clone,Copy)]
 pub(crate)enumCItemKind{
@@ -1539,6 +1593,71 @@ impl ImproperCTypesDefinitions {
  vis.check_type_for_ffi_and_report_errors(span, fn_ptr_ty,true,false);
 }
 }
+
+fncheck_arg_for_power_alignment<'tcx>(
+&mutself,
+cx:&LateContext<'tcx>,
+ty:Ty<'tcx>,
+) -> bool{
+// Structs (under repr(C)) follow the power alignment rule if:
+// - the first field of the struct is a floating-point type that
+// is greater than 4-bytes, or
+// - the first field of the struct is an aggregate whose
+// recursively first field is a floating-point type greater than
+// 4 bytes.
+if cx.tcx.sess.target.os != "aix"{
+returnfalse;
+}
+if ty.is_floating_point() && ty.primitive_size(cx.tcx).bytes() > 4{
+returntrue;
+}elseifletAdt(adt_def, _) = ty.kind()
+ && adt_def.is_struct()
+{
+let struct_variant = adt_def.variant(VariantIdx::ZERO);
+// Within a nested struct, all fields are examined to correctly
+// report if any fields after the nested struct within the
+// original struct are misaligned.
+for struct_field in&struct_variant.fields{
+let field_ty = cx.tcx.type_of(struct_field.did).instantiate_identity();
+ifself.check_arg_for_power_alignment(cx, field_ty){
+returntrue;
+}
+}
+}
+returnfalse;
+}
+
+fncheck_struct_for_power_alignment<'tcx>(
+&mutself,
+cx:&LateContext<'tcx>,
+item:&'tcx hir::Item<'tcx>,
+){
+let adt_def = cx.tcx.adt_def(item.owner_id.to_def_id());
+if adt_def.repr().c()
+ && !adt_def.repr().packed()
+ && cx.tcx.sess.target.os == "aix"
+ && !adt_def.all_fields().next().is_none()
+{
+let struct_variant_data = item.expect_struct().0;
+for(index, ..)in struct_variant_data.fields().iter().enumerate(){
+// Struct fields (after the first field) are checked for the
+// power alignment rule, as fields after the first are likely
+// to be the fields that are misaligned.
+if index != 0{
+let first_field_def = struct_variant_data.fields()[index];
+let def_id = first_field_def.def_id;
+let ty = cx.tcx.type_of(def_id).instantiate_identity();
+ifself.check_arg_for_power_alignment(cx, ty){
+ cx.emit_span_lint(
+USES_POWER_ALIGNMENT,
+ first_field_def.span,
+UsesPowerAlignment,
+);
+}
+}
+}
+}
+}
 }
 
 /// `ImproperCTypesDefinitions` checks items outside of foreign items (e.g. stuff that isn't in
@@ -1562,8 +1681,13 @@ impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDefinitions {
 }
 // See `check_fn`..
  hir::ItemKind::Fn{ .. } => {}
+// Structs are checked based on if they follow the power alignment
+// rule (under repr(C)).
+ hir::ItemKind::Struct(..) => {
+self.check_struct_for_power_alignment(cx, item);
+}
 // See `check_field_def`..
- hir::ItemKind::Union(..) | hir::ItemKind::Struct(..) | hir::ItemKind::Enum(..) => {}
+ hir::ItemKind::Union(..) | hir::ItemKind::Enum(..) => {}
 // Doesn't define something that can contain a external type to be checked.
  hir::ItemKind::Impl(..)
  | hir::ItemKind::TraitAlias(..)

tests/ui/layout/reprc-power-alignment.rs

@@ -0,0 +1,152 @@
+//@ check-pass
+//@ compile-flags: --target powerpc64-ibm-aix
+//@ needs-llvm-components: powerpc
+//@ add-core-stubs
+#![feature(no_core)]
+#![no_core]
+#![no_std]
+
+externcrate minicore;
+use minicore::*;
+
+#[warn(uses_power_alignment)]
+
+#[repr(C)]
+pubstructFloats{
+a:f64,
+b:u8,
+c:f64,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+d:f32,
+}
+
+pubstructFloats2{
+a:f64,
+b:u32,
+c:f64,
+}
+
+#[repr(C)]
+pubstructFloats3{
+a:f32,
+b:f32,
+c:i64,
+}
+
+#[repr(C)]
+pubstructFloats4{
+a:u64,
+b:u32,
+c:f32,
+}
+
+#[repr(C)]
+pubstructFloats5{
+a:f32,
+b:f64,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+c:f32,
+}
+
+#[repr(C)]
+pubstructFloatAgg1{
+x:Floats,
+y:f64,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+}
+
+#[repr(C)]
+pubstructFloatAgg2{
+x:i64,
+y:Floats,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+}
+
+#[repr(C)]
+pubstructFloatAgg3{
+x:FloatAgg1,
+// NOTE: the "power" alignment rule is infectious to nested struct fields.
+y:FloatAgg2,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+z:FloatAgg2,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+}
+
+#[repr(C)]
+pubstructFloatAgg4{
+x:FloatAgg1,
+y:FloatAgg2,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+}
+
+#[repr(C)]
+pubstructFloatAgg5{
+x:FloatAgg1,
+y:FloatAgg2,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+z:FloatAgg3,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+}
+
+#[repr(C)]
+pubstructFloatAgg6{
+x:i64,
+y:Floats,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+z:u8,
+}
+
+#[repr(C)]
+pubstructFloatAgg7{
+x:i64,
+y:Floats,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+z:u8,
+zz:f32,
+}
+
+#[repr(C)]
+pubstructA{
+d:f64,
+}
+#[repr(C)]
+pubstructB{
+a:A,
+f:f32,
+d:f64,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+}
+#[repr(C)]
+pubstructC{
+c:u8,
+b:B,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+}
+#[repr(C)]
+pubstructD{
+x:f64,
+}
+#[repr(C)]
+pubstructE{
+x:i32,
+d:D,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+}
+#[repr(C)]
+pubstructF{
+a:u8,
+b:f64,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+}
+#[repr(C)]
+pubstructG{
+a:u8,
+b:u8,
+c:f64,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+d:f32,
+e:f64,//~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+}
+// Should not warn on #[repr(packed)].
+#[repr(packed)]
+pubstructH{
+a:u8,
+b:u8,
+c:f64,
+d:f32,
+e:f64,
+}
+#[repr(C, packed)]
+pubstructI{
+a:u8,
+b:u8,
+c:f64,
+d:f32,
+e:f64,
+}
+
+fnmain(){}