commit 6864c0d8bb8547d6f2e00d49bb949e328d67927d
author Daniel Dunbar <daniel@zuster.org> Sat Apr 25 05:08:32 2009 +0000
committer Daniel Dunbar <daniel@zuster.org> Sat Apr 25 05:08:32 2009 +0000
tree b8ef33515f4eacacc28fc17765c1c031dd71c7c9
parent b30a2f32eea7f826f77149e1f7bf28cbc3b77284

Fix pointer addressing and array subscripting of Objective-C interface
types.
 - I broke this in the switch to representing interfaces with opaque
   types.

 - <rdar://problem/6822660> clang crashes on subscript of interface in
   32-bit mode


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

lib/CodeGen/CGExprScalar.cpp

diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
index 308a45e..5e0159e 100644
--- a/lib/CodeGen/CGExprScalar.cpp
+++ b/lib/CodeGen/CGExprScalar.cpp
@@ -968,14 +968,27 @@
       Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext");
   }
 
+  const QualType ElementType = PT->getPointeeType();
+  // Handle interface types, which are not represented with a concrete
+  // type.
+  if (const ObjCInterfaceType *OIT = dyn_cast<ObjCInterfaceType>(ElementType)) {
+    llvm::Value *InterfaceSize = 
+      llvm::ConstantInt::get(Idx->getType(),
+                             CGF.getContext().getTypeSize(OIT) / 8);
+    Idx = Builder.CreateMul(Idx, InterfaceSize);
+    const llvm::Type *i8Ty = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
+    Value *Casted = Builder.CreateBitCast(Ptr, i8Ty);
+    Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr");
+    return Builder.CreateBitCast(Res, Ptr->getType());
+  } 
+
   // Explicitly handle GNU void* and function pointer arithmetic
   // extensions. The GNU void* casts amount to no-ops since our void*
   // type is i8*, but this is future proof.
-  const QualType ElementType = PT->getPointeeType();
   if (ElementType->isVoidType() || ElementType->isFunctionType()) {
     const llvm::Type *i8Ty = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
     Value *Casted = Builder.CreateBitCast(Ptr, i8Ty);
-    Value *Res = Builder.CreateGEP(Casted, Idx, "sub.ptr");
+    Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr");
     return Builder.CreateBitCast(Res, Ptr->getType());
   } 
   
@@ -1015,6 +1028,20 @@
     }
     Idx = Builder.CreateNeg(Idx, "sub.ptr.neg");
 
+    // Handle interface types, which are not represented with a concrete
+    // type.
+    if (const ObjCInterfaceType *OIT = 
+        dyn_cast<ObjCInterfaceType>(LHSElementType)) {
+      llvm::Value *InterfaceSize = 
+        llvm::ConstantInt::get(Idx->getType(),
+                               CGF.getContext().getTypeSize(OIT) / 8);
+      Idx = Builder.CreateMul(Idx, InterfaceSize);
+      const llvm::Type *i8Ty = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
+      Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty);
+      Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr");
+      return Builder.CreateBitCast(Res, Ops.LHS->getType());
+    } 
+
     // Explicitly handle GNU void* and function pointer arithmetic
     // extensions. The GNU void* casts amount to no-ops since our
     // void* type is i8*, but this is future proof.