[OpaquePtr] Support opaque constant expression GEP

[nikic]

Summary

Adjust assertions to use isOpaqueOrPointeeTypeMatches() and make it return an opaque pointer result for opaque base pointer. We also need to enumerate the element type, as it is no longer implicitly enumerated through the pointer type.

[aeubanks]

lgtm, thanks!

llvm/lib/AsmParser/LLParser.cpp

case lltok::kw_select: {
 
     if (Opc == Instruction::GetElementPtr) {
       if (Elts.size() == 0 ||
           !Elts[0]->getType()->isPtrOrPtrVectorTy())
         return error(ID.Loc, "base of getelementptr must be a pointer");
 
       Type *BaseType = Elts[0]->getType();
       auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
-      if (Ty != BasePointerType->getElementType()) {
+      if (!BasePointerType->isOpaqueOrPointeeTypeMatches(Ty)) {
         return error(
             ExplicitTypeLoc,
             typeComparisonErrorMessage(
                 "explicit pointee type doesn't match operand's pointee type",
                 Ty, BasePointerType->getElementType()));
       }
 
       unsigned GEPWidth =

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX: { // [ty, flags, n x
         if (!ElTy)
           return error("Invalid record");
         Elts.push_back(ValueList.getConstantFwdRef(Record[OpNum++], ElTy));
       }
 
       if (Elts.size() < 1)
         return error("Invalid gep with no operands");
 
-      Type *ImplicitPointeeType =
-          cast<PointerType>(Elt0FullTy->getScalarType())->getElementType();
+      PointerType *OrigPtrTy = cast<PointerType>(Elt0FullTy->getScalarType());
       if (!PointeeType)
-        PointeeType = ImplicitPointeeType;
-      else if (PointeeType != ImplicitPointeeType)
+        PointeeType = OrigPtrTy->getElementType();
+      else if (!OrigPtrTy->isOpaqueOrPointeeTypeMatches(PointeeType))
         return error("Explicit gep operator type does not match pointee type "
                      "of pointer operand");
 
       ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
       V = ConstantExpr::getGetElementPtr(PointeeType, Elts[0], Indices,
                                          InBounds, InRangeIndex);
       break;
     }

llvm/lib/Bitcode/Writer/ValueEnumerator.cpp

 #include "llvm/IR/GlobalIFunc.h"
 #include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Use.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
void ValueEnumerator::EnumerateOperandType(const Value *V) {
   for (const Value *Op : C->operands()) {
     // Don't enumerate basic blocks here, this happens as operands to
     // blockaddress.
     if (isa<BasicBlock>(Op))
       continue;
 
     EnumerateOperandType(Op);
   }
-  if (auto *CE = dyn_cast<ConstantExpr>(C))
+  if (auto *CE = dyn_cast<ConstantExpr>(C)) {
     if (CE->getOpcode() == Instruction::ShuffleVector)
       EnumerateOperandType(CE->getShuffleMaskForBitcode());
+    if (CE->getOpcode() == Instruction::GetElementPtr)
+      EnumerateType(cast<GEPOperator>(CE)->getSourceElementType());
+  }
 }
 
 void ValueEnumerator::EnumerateAttributes(AttributeList PAL) {
   if (PAL.isEmpty()) return;  // null is always 0.
 
   // Do a lookup.
   unsigned &Entry = AttributeListMap[PAL];
   if (Entry == 0) {

llvm/lib/IR/Constants.cpp

Constant *ConstantExpr::getSelect(Constant *C, Constant *V1, Constant *V2,
   LLVMContextImpl *pImpl = C->getContext().pImpl;
   return pImpl->ExprConstants.getOrCreate(V1->getType(), Key);
 }
 
 Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C,
                                          ArrayRef<Value *> Idxs, bool InBounds,
                                          Optional<unsigned> InRangeIndex,
                                          Type *OnlyIfReducedTy) {
+  PointerType *OrigPtrTy = cast<PointerType>(C->getType()->getScalarType());
   if (!Ty)
-    Ty = cast<PointerType>(C->getType()->getScalarType())->getElementType();
+    Ty = OrigPtrTy->getElementType();
   else
-    assert(Ty ==
-           cast<PointerType>(C->getType()->getScalarType())->getElementType());
+    assert(OrigPtrTy->isOpaqueOrPointeeTypeMatches(Ty));
 
   if (Constant *FC =
           ConstantFoldGetElementPtr(Ty, C, InBounds, InRangeIndex, Idxs))
     return FC;          // Fold a few common cases.
 
   // Get the result type of the getelementptr!
   Type *DestTy = GetElementPtrInst::getIndexedType(Ty, Idxs);
   assert(DestTy && "GEP indices invalid!");
-  unsigned AS = C->getType()->getPointerAddressSpace();
-  Type *ReqTy = DestTy->getPointerTo(AS);
+  unsigned AS = OrigPtrTy->getAddressSpace();
+  Type *ReqTy = OrigPtrTy->isOpaque()
+      ? PointerType::get(OrigPtrTy->getContext(), AS)
+      : DestTy->getPointerTo(AS);
 
   auto EltCount = ElementCount::getFixed(0);
   if (VectorType *VecTy = dyn_cast<VectorType>(C->getType()))
     EltCount = VecTy->getElementCount();
   else
     for (auto Idx : Idxs)
       if (VectorType *VecTy = dyn_cast<VectorType>(Idx->getType()))
         EltCount = VecTy->getElementCount();

llvm/test/Assembler/opaque-ptr.ll

 ; CHECK: define <2 x ptr> @gep_vec2(<2 x ptr> %a)
 ; CHECK:     %res = getelementptr i8, <2 x ptr> %a, i32 2
 ; CHECK:     ret <2 x ptr> %res
 define <2 x ptr> @gep_vec2(<2 x ptr> %a) {
   %res = getelementptr i8, <2 x ptr> %a, i32 2
   ret <2 x ptr> %res
 }
 
+; CHECK: define ptr @gep_constexpr(ptr %a)
+; CHECK:     ret ptr getelementptr (i16, ptr null, i32 3)
+define ptr @gep_constexpr(ptr %a) {
+  ret ptr getelementptr (i16, ptr null, i32 3)
+}
+
+; CHECK: define <2 x ptr> @gep_constexpr_vec1(ptr %a)
+; CHECK:     ret <2 x ptr> getelementptr (i16, ptr null, <2 x i32> <i32 3, i32 4>)
+define <2 x ptr> @gep_constexpr_vec1(ptr %a) {
+  ret <2 x ptr> getelementptr (i16, ptr null, <2 x i32> <i32 3, i32 4>)
+}
+
+; CHECK: define <2 x ptr> @gep_constexpr_vec2(<2 x ptr> %a)
+; CHECK:     ret <2 x ptr> getelementptr (i16, <2 x ptr> zeroinitializer, <2 x i32> <i32 3, i32 3>)
+define <2 x ptr> @gep_constexpr_vec2(<2 x ptr> %a) {
+  ret <2 x ptr> getelementptr (i16, <2 x ptr> zeroinitializer, i32 3)
+}
+
 ; CHECK: define void @cmpxchg(ptr %p, i32 %a, i32 %b)
 ; CHECK:     %val_success = cmpxchg ptr %p, i32 %a, i32 %b acq_rel monotonic
 ; CHECK:     ret void
 define void @cmpxchg(ptr %p, i32 %a, i32 %b) {
     %val_success = cmpxchg ptr %p, i32 %a, i32 %b acq_rel monotonic
     ret void
 }
 
 ; CHECK: define void @atomicrmw(ptr %a, i32 %i)
 ; CHECK:     %b = atomicrmw add ptr %a, i32 %i acquire
 ; CHECK:     ret void
 define void @atomicrmw(ptr %a, i32 %i) {
     %b = atomicrmw add ptr %a, i32 %i acquire
     ret void
 }