Implement rdar://7530813 - collapse multiple GEP instructions in IRgen

This avoids generating two gep's for common array operations.  Before
we would generate something like:

  %tmp = load i32* %X.addr                        ; <i32> [#uses=1]
  %arraydecay = getelementptr inbounds [100 x i32]* %A, i32 0, i32 0 ; <i32*> [#uses=1]
  %arrayidx = getelementptr inbounds i32* %arraydecay, i32 %tmp ; <i32*> [#uses=1]
  %tmp1 = load i32* %arrayidx                     ; <i32> [#uses=1]

Now we generate:

  %tmp = load i32* %X.addr                        ; <i32> [#uses=1]
  %arrayidx = getelementptr inbounds [100 x i32]* %A, i32 0, i32 %tmp ; <i32*> [#uses=1]
  %tmp1 = load i32* %arrayidx                     ; <i32> [#uses=1]

Less IR is better at -O0.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@106966 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index 706bf09a7fd32349273efc6064d84c7486e101bb..c41a99796db07290d0b1e1cfeba4223078f3b709 100644 (file)
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -1317,6 +1317,22 @@ llvm::BasicBlock *CodeGenFunction::getTrapBB() {
   return TrapBB;
 }
 
+/// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an
+/// array to pointer, return the array subexpression.
+static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
+  // If this isn't just an array->pointer decay, bail out.
+  const CastExpr *CE = dyn_cast<CastExpr>(E);
+  if (CE == 0 || CE->getCastKind() != CastExpr::CK_ArrayToPointerDecay)
+    return 0;
+  
+  // If this is a decay from variable width array, bail out.
+  const Expr *SubExpr = CE->getSubExpr();
+  if (SubExpr->getType()->isVariableArrayType())
+    return 0;
+  
+  return SubExpr;
+}
+
 LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
   // The index must always be an integer, which is not an aggregate.  Emit it.
   llvm::Value *Idx = EmitScalarExpr(E->getIdx());
@@ -1360,9 +1376,6 @@ LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
     }
   }
 
-  // The base must be a pointer, which is not an aggregate.  Emit it.
-  llvm::Value *Base = EmitScalarExpr(E->getBase());
-  
   // 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;
@@ -1378,9 +1391,13 @@ LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
     Idx = Builder.CreateUDiv(Idx,
                              llvm::ConstantInt::get(Idx->getType(),
                                  BaseTypeSize.getQuantity()));
+    
+    // The base must be a pointer, which is not an aggregate.  Emit it.
+    llvm::Value *Base = EmitScalarExpr(E->getBase());
+    
     Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
-  } else if (const ObjCObjectType *OIT =
-               E->getType()->getAs<ObjCObjectType>()) {
+  } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){
+    // Indexing over an interface, as in "NSString *P; P[4];"
     llvm::Value *InterfaceSize =
       llvm::ConstantInt::get(Idx->getType(),
           getContext().getTypeSizeInChars(OIT).getQuantity());
@@ -1388,10 +1405,28 @@ LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
     Idx = Builder.CreateMul(Idx, InterfaceSize);
 
     const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
+    
+    // The base must be a pointer, which is not an aggregate.  Emit it.
+    llvm::Value *Base = EmitScalarExpr(E->getBase());
     Address = Builder.CreateGEP(Builder.CreateBitCast(Base, i8PTy),
                                 Idx, "arrayidx");
     Address = Builder.CreateBitCast(Address, Base->getType());
+  } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
+    // If this is A[i] where A is an array, the frontend will have decayed the
+    // base to be a ArrayToPointerDecay implicit cast.  While correct, it is
+    // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a
+    // "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();
+    const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
+    llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0);
+    llvm::Value *Args[] = { Zero, Idx };
+    
+    Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, Args+2, "arrayidx");
   } else {
+    // The base must be a pointer, which is not an aggregate.  Emit it.
+    llvm::Value *Base = EmitScalarExpr(E->getBase());
     Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
   }
 

diff --git a/test/CodeGen/address-space-field2.c b/test/CodeGen/address-space-field2.c
index 198fd22a3a74daa047cde9f25ebddd4a0b6b323d..9c21cab3a566a86d2cd80fd6f61e42f33ea64dc2 100644 (file)
--- a/test/CodeGen/address-space-field2.c
+++ b/test/CodeGen/address-space-field2.c
@@ -16,10 +16,6 @@
 // CHECK: addrspace(1)
 // CHECK: addrspace(1)
 // CHECK: addrspace(1)
-// CHECK: addrspace(1)
-// CHECK: addrspace(1)
-// CHECK: addrspace(2)
-// CHECK: addrspace(2)
 // CHECK: addrspace(2)
 // CHECK: addrspace(2)
 // CHECK: addrspace(2)

diff --git a/test/CodeGen/address-space-field3.c b/test/CodeGen/address-space-field3.c
index 090f4a104b05246627be48f29946a4a4ae47a0c3..c17085cdf48beed8e707cdfedf86cfcf33841720 100644 (file)
--- a/test/CodeGen/address-space-field3.c
+++ b/test/CodeGen/address-space-field3.c
@@ -16,10 +16,6 @@
 // CHECK: addrspace(2)
 // CHECK: addrspace(2)
 // CHECK: addrspace(2)
-// CHECK: addrspace(2)
-// CHECK: addrspace(2)
-// CHECK: addrspace(1)
-// CHECK: addrspace(1)
 // CHECK: addrspace(1)
 // CHECK: addrspace(1)
 // CHECK: addrspace(1)

diff --git a/test/CodeGen/address-space-field4.c b/test/CodeGen/address-space-field4.c
index a1906c0c00597fcd036cc294c98403e026681c13..a896ab652d98d1df08d8aef24a3ad4ca335b9f4f 100644 (file)
--- a/test/CodeGen/address-space-field4.c
+++ b/test/CodeGen/address-space-field4.c
@@ -23,9 +23,6 @@
 // CHECK: addrspace(3)
 // CHECK: addrspace(3)
 // CHECK: addrspace(1)
-// CHECK: addrspace(3)
-// CHECK: addrspace(3)
-// CHECK: addrspace(1)
 // CHECK: addrspace(1)
 // CHECK: addrspace(1)
 // CHECK: addrspace(1)
@@ -35,9 +32,6 @@
 // CHECK: addrspace(1)
 // CHECK: addrspace(1)
 // CHECK: addrspace(2)
-// CHECK: addrspace(1)
-// CHECK: addrspace(2)
-// CHECK: addrspace(2)
 // CHECK: addrspace(2)
 
 // Check the load and store are using the correct address space to access

diff --git a/test/CodeGen/exprs.c b/test/CodeGen/exprs.c
index d182ce81cab7eed6040081388f25e52e0f3c4c15..010e6e3cf515daaef9ae067c0854e9738f499bfe 100644 (file)
--- a/test/CodeGen/exprs.c
+++ b/test/CodeGen/exprs.c
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 %s -emit-llvm -o - 
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
 
 // PR1895
 // sizeof function
@@ -119,3 +119,15 @@ void f9(struct S *x) {
 void f10() {
   __builtin_sin(0);
 }
+
+// rdar://7530813
+// CHECK: define i32 @f11
+int f11(long X) {
+  int A[100];
+  return A[X];
+
+// CHECK: load {{.*}}* %X.addr
+// CHECK-NEXT: getelementptr inbounds [100 x i32]* %A, i32 0, 
+// CHECK-NEXT: load i32*
+}
+