From: Daniel Dunbar Date: Fri, 1 Apr 2011 00:49:43 +0000 (+0000) Subject: IRgen: Reapply r128691 with a fix to ensure we don't increase alignment past X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=d553408ff15b38710a1ba0947efbf4c5637018ab;p=clang IRgen: Reapply r128691 with a fix to ensure we don't increase alignment past that of the array element type. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@128698 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp index ab88a38bab..92e6a19c25 100644 --- a/lib/CodeGen/CGExpr.cpp +++ b/lib/CodeGen/CGExpr.cpp @@ -1424,6 +1424,7 @@ LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { // We know that the pointer points to a type of the correct size, unless the // size is a VLA or Objective-C interface. llvm::Value *Address = 0; + unsigned ArrayAlignment = 0; if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(E->getType())) { llvm::Value *VLASize = GetVLASize(VAT); @@ -1459,10 +1460,14 @@ LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { // "gep x, i" here. Emit one "gep A, 0, i". assert(Array->getType()->isArrayType() && "Array to pointer decay must have array source type!"); - llvm::Value *ArrayPtr = EmitLValue(Array).getAddress(); + LValue ArrayLV = EmitLValue(Array); + llvm::Value *ArrayPtr = ArrayLV.getAddress(); llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0); llvm::Value *Args[] = { Zero, Idx }; + // Propagate the alignment from the array itself to the result. + ArrayAlignment = ArrayLV.getAlignment(); + if (getContext().getLangOptions().isSignedOverflowDefined()) Address = Builder.CreateGEP(ArrayPtr, Args, Args+2, "arrayidx"); else @@ -1480,7 +1485,13 @@ LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { assert(!T.isNull() && "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type"); - LValue LV = MakeAddrLValue(Address, T); + // Limit the alignment to that of the result type. + if (ArrayAlignment) { + unsigned Align = getContext().getTypeAlignInChars(T).getQuantity(); + ArrayAlignment = std::min(Align, ArrayAlignment); + } + + LValue LV = MakeAddrLValue(Address, T, ArrayAlignment); LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace()); if (getContext().getLangOptions().ObjC1 && diff --git a/test/CodeGen/packed-arrays.c b/test/CodeGen/packed-arrays.c new file mode 100644 index 0000000000..785db4d2dd --- /dev/null +++ b/test/CodeGen/packed-arrays.c @@ -0,0 +1,157 @@ +// RUN: %clang_cc1 -triple x86_64-unk-unk -emit-llvm -Os -o %t %s +// RUN: FileCheck < %t %s + +struct s0 { + unsigned int x[2] __attribute__((packed)); +}; + +struct s1 { + unsigned int x[2] __attribute__((packed)); + unsigned int y; + unsigned int z __attribute__((packed)); +}; + +struct s2 { + unsigned int x[2] __attribute__((packed)); + unsigned int y __attribute__((packed)); + unsigned int z __attribute__((packed)); +}; + +struct __attribute__((packed)) s3 { + unsigned int x[2]; + unsigned int y; + unsigned int z; +}; + +// CHECK: @align0 = global i32 1 +int align0 = __alignof(struct s0); +// CHECK: @align1 = global i32 4 +int align1 = __alignof(struct s1); +// CHECK: @align2 = global i32 1 +int align2 = __alignof(struct s2); +// CHECK: @align3 = global i32 1 +int align3 = __alignof(struct s3); + +// CHECK: @align0_x = global i32 1 +int align0_x = __alignof(((struct s0*) 0)->x); +// We are currently incompatible with GCC here. +// +// CHECK-XFAIL: @align1_x = global i32 1 +// CHECK: @align1_x = global i32 4 +int align1_x = __alignof(((struct s1*) 0)->x); +// CHECK: @align2_x = global i32 1 +int align2_x = __alignof(((struct s2*) 0)->x); +// CHECK: @align3_x = global i32 1 +int align3_x = __alignof(((struct s3*) 0)->x); + +// CHECK: @align0_x0 = global i32 4 +int align0_x0 = __alignof(((struct s0*) 0)->x[0]); +// CHECK: @align1_x0 = global i32 4 +int align1_x0 = __alignof(((struct s1*) 0)->x[0]); +// CHECK: @align2_x0 = global i32 4 +int align2_x0 = __alignof(((struct s2*) 0)->x[0]); +// CHECK: @align3_x0 = global i32 4 +int align3_x0 = __alignof(((struct s3*) 0)->x[0]); + +// CHECK: define i32 @f0_a +// CHECK: load i32* %{{.*}}, align 1 +// CHECK: } +// CHECK: define i32 @f0_b +// CHECK: load i32* %{{.*}}, align 4 +// CHECK: } +int f0_a(struct s0 *a) { + return a->x[1]; +} +int f0_b(struct s0 *a) { + return *(a->x + 1); +} + +// CHECK: define i32 @f1_a +// CHECK: load i32* %{{.*}}, align 4 +// CHECK: } +// CHECK: define i32 @f1_b +// CHECK: load i32* %{{.*}}, align 4 +// CHECK: } + +// Note that we are incompatible with GCC on these two examples. +// +// CHECK: define i32 @f1_c +// CHECK-XFAIL: load i32* %{{.*}}, align 1 +// CHECK: load i32* %{{.*}}, align 4 +// CHECK: } +// CHECK: define i32 @f1_d +// CHECK-XFAIL: load i32* %{{.*}}, align 1 +// CHECK: load i32* %{{.*}}, align 4 +// CHECK: } +int f1_a(struct s1 *a) { + return a->x[1]; +} +int f1_b(struct s1 *a) { + return *(a->x + 1); +} +int f1_c(struct s1 *a) { + return a->y; +} +int f1_d(struct s1 *a) { + return a->z; +} + +// CHECK: define i32 @f2_a +// CHECK: load i32* %{{.*}}, align 1 +// CHECK: } +// CHECK: define i32 @f2_b +// CHECK: load i32* %{{.*}}, align 4 +// CHECK: } +// CHECK: define i32 @f2_c +// CHECK: load i32* %{{.*}}, align 1 +// CHECK: } +// CHECK: define i32 @f2_d +// CHECK: load i32* %{{.*}}, align 1 +// CHECK: } +int f2_a(struct s2 *a) { + return a->x[1]; +} +int f2_b(struct s2 *a) { + return *(a->x + 1); +} +int f2_c(struct s2 *a) { + return a->y; +} +int f2_d(struct s2 *a) { + return a->z; +} + +// CHECK: define i32 @f3_a +// CHECK: load i32* %{{.*}}, align 1 +// CHECK: } +// CHECK: define i32 @f3_b +// CHECK: load i32* %{{.*}}, align 4 +// CHECK: } +// CHECK: define i32 @f3_c +// CHECK: load i32* %{{.*}}, align 1 +// CHECK: } +// CHECK: define i32 @f3_d +// CHECK: load i32* %{{.*}}, align 1 +// CHECK: } +int f3_a(struct s3 *a) { + return a->x[1]; +} +int f3_b(struct s3 *a) { + return *(a->x + 1); +} +int f3_c(struct s3 *a) { + return a->y; +} +int f3_d(struct s3 *a) { + return a->z; +} + +// Verify we don't claim things are overaligned. +// +// CHECK: define double @f4 +// CHECK: load double* {{.*}}, align 8 +// CHECK: } +extern double g4[5] __attribute__((aligned(16))); +double f4() { + return g4[1]; +}