intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-26 21:53:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

IRgen: Reapply r128691 with a fix to ensure we don't increase alignment past

Browse Source 
that of the array element type.

llvm-svn: 128698
This commit is contained in:
Daniel Dunbar
2011-04-01 00:49:43 +00:00
parent 7d90b1f883
commit 826342774e
2 changed files with 170 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
clang/lib/CodeGen/CGExpr.cpp
View File

@@ -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 &&

157
clang/test/CodeGen/packed-arrays.c Normal file
View File

@@ -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. <rdar://problem/9217290>
//
// 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];
}