Fix System V ABI for arrays of packed structs with misaligned fields (#16314)

Avoid compiler crash with `UInt8[N]` external variable.

Author: HertzDevil

spec/compiler/codegen/abi/x86_64_spec.cr

@@ -200,6 +200,50 @@ class Crystal::ABI
           info.arg_types[0].should eq(ArgType.direct(str, cast: ctx.struct([ctx.int64])))
           info.return_type.should eq(ArgType.direct(str, cast: ctx.struct([ctx.int64])))
         end
+
+        test "does with array of packed struct containing unaligned fields (#16312)" do |abi, ctx|
+          str = ctx.struct([ctx.int8, ctx.int16], packed: true).array(1)
+          arg_types = [str]
+          return_type = str
+
+          info = abi.abi_info(arg_types, return_type, true, ctx)
+          info.arg_types.size.should eq(1)
+
+          info.arg_types[0].should eq(ArgType.indirect(str, LLVM::Attribute::ByVal))
+          info.return_type.should eq(ArgType.indirect(str, LLVM::Attribute::StructRet))
+
+          str = ctx.struct([ctx.int8, ctx.int16], packed: true).array(2)
+          arg_types = [str]
+          return_type = str
+
+          info = abi.abi_info(arg_types, return_type, true, ctx)
+          info.arg_types.size.should eq(1)
+
+          info.arg_types[0].should eq(ArgType.indirect(str, LLVM::Attribute::ByVal))
+          info.return_type.should eq(ArgType.indirect(str, LLVM::Attribute::StructRet))
+
+          str = ctx.struct([ctx.int16, ctx.int8], packed: true).array(2)
+          arg_types = [str]
+          return_type = str
+
+          info = abi.abi_info(arg_types, return_type, true, ctx)
+          info.arg_types.size.should eq(1)
+
+          info.arg_types[0].should eq(ArgType.indirect(str, LLVM::Attribute::ByVal))
+          info.return_type.should eq(ArgType.indirect(str, LLVM::Attribute::StructRet))
+        end
+
+        test "does with array of packed struct not containing unaligned fields (#16312)" do |abi, ctx|
+          str = ctx.struct([ctx.int16, ctx.int8], packed: true).array(1)
+          arg_types = [str]
+          return_type = str
+
+          info = abi.abi_info(arg_types, return_type, true, ctx)
+          info.arg_types.size.should eq(1)
+
+          info.arg_types[0].should eq(ArgType.direct(str, cast: ctx.struct([ctx.int64])))
+          info.return_type.should eq(ArgType.direct(str, cast: ctx.struct([ctx.int64])))
+        end
       end
     {% end %}
   end

src/compiler/crystal/codegen/abi/x86_64.cr

@@ -275,14 +275,36 @@ class Crystal::ABI::X86_64 < Crystal::ABI
     size(type, 8)
   end
 
-  def has_misaligned_fields?(type : LLVM::Type) : Bool
-    return false unless type.packed_struct?
-    offset = 0
-    type.struct_element_types.each do |elem|
-      return true unless offset.divisible_by?(align(elem))
-      offset += size(elem)
+  def has_misaligned_fields?(type : LLVM::Type, offset : Int = 0) : Bool
+    case type.kind
+    when LLVM::Type::Kind::Struct
+      return false unless type.packed_struct?
+      type.struct_element_types.each do |elem|
+        return true unless offset.divisible_by?(align(elem))
+        offset += size(elem)
+      end
+      false
+    when LLVM::Type::Kind::Array
+      # Given:
+      #
+      # ```
+      # @[Packed]
+      # struct Foo
+      #   x : Int16
+      #   y : Int8
+      # end
+      # ```
+      #
+      # the types `Foo` and `Foo[1]` have no misaligned fields, but `Foo[2]`
+      # does, because the field `.[1].x` has offset 3 and a natural alignment of
+      # 2. Checking for the first two elements is sufficient; if both contain no
+      # misaligned fields, then `size(elem) % align(elem) == 0` must be true,
+      # meaning array indices have no effect on element alignment.
+      elem = type.element_type
+      has_misaligned_fields?(elem) || type.array_size > 1 && has_misaligned_fields?(elem, size(elem))
+    else
+      false
     end
-    false
   end
 
   enum RegClass

src/llvm/abi/x86_64.cr

@@ -276,14 +276,36 @@ class LLVM::ABI::X86_64 < LLVM::ABI
     size(type, 8)
   end
 
-  def has_misaligned_fields?(type : Type) : Bool
-    return false unless type.packed_struct?
-    offset = 0
-    type.struct_element_types.each do |elem|
-      return true unless offset.divisible_by?(align(elem))
-      offset += size(elem)
+  def has_misaligned_fields?(type : Type, offset : Int = 0) : Bool
+    case type.kind
+    when Type::Kind::Struct
+      return false unless type.packed_struct?
+      type.struct_element_types.each do |elem|
+        return true unless offset.divisible_by?(align(elem))
+        offset += size(elem)
+      end
+      false
+    when Type::Kind::Array
+      # Given:
+      #
+      # ```
+      # @[Packed]
+      # struct Foo
+      #   x : Int16
+      #   y : Int8
+      # end
+      # ```
+      #
+      # the types `Foo` and `Foo[1]` have no misaligned fields, but `Foo[2]`
+      # does, because the field `.[1].x` has offset 3 and a natural alignment of
+      # 2. Checking for the first two elements is sufficient; if both contain no
+      # misaligned fields, then `size(elem) % align(elem) == 0` must be true,
+      # meaning array indices have no effect on element alignment.
+      elem = type.element_type
+      has_misaligned_fields?(elem) || type.array_size > 1 && has_misaligned_fields?(elem, size(elem))
+    else
+      false
     end
-    false
   end
 
   enum RegClass