[NFC][Opaque pointer][LLVM] Remove code in ifndef INTEL_SYCL_OPAQUEPOINTER_READY

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def

@@ -26,50 +26,29 @@
 #endif
 
 #define __OMP_TYPE(VarName) OMP_TYPE(VarName, Type::get##VarName##Ty(Ctx))
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
 #define __OMP_PTR_TYPE(VarName) OMP_TYPE(VarName, PointerType::get(Ctx, 0))
-#else
-#endif
 
 __OMP_TYPE(Void)
 __OMP_TYPE(Int1)
 __OMP_TYPE(Int8)
 __OMP_TYPE(Int16)
 __OMP_TYPE(Int32)
 __OMP_TYPE(Int64)
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
 __OMP_PTR_TYPE(Int8Ptr)
 __OMP_PTR_TYPE(Int16Ptr)
 __OMP_PTR_TYPE(Int32Ptr)
 __OMP_PTR_TYPE(Int64Ptr)
-#else
-__OMP_TYPE(Int8Ptr)
-__OMP_TYPE(Int16Ptr)
-__OMP_TYPE(Int32Ptr)
-__OMP_TYPE(Int64Ptr)
-#endif
 __OMP_TYPE(Double)
 
 OMP_TYPE(SizeTy, M.getDataLayout().getIntPtrType(Ctx))
 OMP_TYPE(Int63, Type::getIntNTy(Ctx, 63))
 
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
 __OMP_PTR_TYPE(VoidPtr)
 __OMP_PTR_TYPE(VoidPtrPtr)
 __OMP_PTR_TYPE(VoidPtrPtrPtr)
 
 __OMP_PTR_TYPE(Int8PtrPtr)
 __OMP_PTR_TYPE(Int8PtrPtrPtr)
-#else
-#define __OMP_PTR_TYPE(NAME, BASE) OMP_TYPE(NAME, BASE->getPointerTo())
-
-__OMP_PTR_TYPE(VoidPtr, Int8)
-__OMP_PTR_TYPE(VoidPtrPtr, VoidPtr)
-__OMP_PTR_TYPE(VoidPtrPtrPtr, VoidPtrPtr)
-
-__OMP_PTR_TYPE(Int8PtrPtr, Int8Ptr)
-__OMP_PTR_TYPE(Int8PtrPtrPtr, Int8PtrPtr)
-#endif
 
 #undef __OMP_PTR_TYPE
 

llvm/include/llvm/FuzzMutate/OpDescriptor.h

@@ -166,14 +166,7 @@ static inline SourcePred sizedPtrType() {
     if (V->isSwiftError())
       return false;
 
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
     return V->getType()->isPointerTy();
-#else // INTEL_SYCL_OPAQUEPOINTER_READY
-    if (const auto *PtrT = dyn_cast<PointerType>(V->getType()))
-      return PtrT->isOpaque() ||
-             PtrT->getNonOpaquePointerElementType()->isSized();
-    return false;
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
   };
   auto Make = [](ArrayRef<Value *>, ArrayRef<Type *> Ts) {
     std::vector<Constant *> Result;

llvm/include/llvm/FuzzMutate/RandomIRBuilder.h

@@ -96,12 +96,7 @@ struct RandomIRBuilder {
                              Value *V);
   /// Create a user for \c V in \c BB.
   Instruction *newSink(BasicBlock &BB, ArrayRef<Instruction *> Insts, Value *V);
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
   Value *findPointer(BasicBlock &BB, ArrayRef<Instruction *> Insts);
-#else // INTEL_SYCL_OPAQUEPOINTER_READY
-  Value *findPointer(BasicBlock &BB, ArrayRef<Instruction *> Insts,
-                     ArrayRef<Value *> Srcs, fuzzerop::SourcePred Pred);
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
   /// Return a uniformly choosen type from \c AllowedTypes
   Type *randomType();
   Function *createFunctionDeclaration(Module &M, uint64_t ArgNum);

llvm/include/llvm/IR/DerivedTypes.h

@@ -643,9 +643,6 @@ inline ElementCount VectorType::getElementCount() const {
 class PointerType : public Type {
   explicit PointerType(LLVMContext &C, unsigned AddrSpace);
 
-#ifndef INTEL_SYCL_OPAQUEPOINTER_READY
-  explicit PointerType(Type *ElType, unsigned AddrSpace);
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
   Type *PointeeTy;
 
 public:
@@ -676,16 +673,10 @@ class PointerType : public Type {
   /// given address space. This is only useful during the opaque pointer
   /// transition.
   /// TODO: remove after opaque pointer transition is complete.
-  [[deprecated("Use PointerType::get() with LLVMContext argument instead")]]
-  static PointerType *getWithSamePointeeType(PointerType *PT,
-                                             unsigned AddressSpace) {
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
+  [[deprecated("Use PointerType::get() with LLVMContext argument "
+               "instead")]] static PointerType *
+  getWithSamePointeeType(PointerType *PT, unsigned AddressSpace) {
     return get(PT->getContext(), AddressSpace);
-#else // INTEL_SYCL_OPAQUEPOINTER_READY
-    if (PT->isOpaque())
-      return get(PT->getContext(), AddressSpace);
-    return get(PT->PointeeTy, AddressSpace);
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
   }
 
   [[deprecated("Pointer element types are deprecated. You can *temporarily* "
@@ -695,12 +686,7 @@ class PointerType : public Type {
     return PointeeTy;
   }
 
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
-  [[deprecated("Always returns true")]]
-  bool isOpaque() const { return true; }
-#else // INTEL_SYCL_OPAQUEPOINTER_READY
-  bool isOpaque() const { return !PointeeTy; }
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
+  [[deprecated("Always returns true")]] bool isOpaque() const { return true; }
 
   /// Return true if the specified type is valid as a element type.
   static bool isValidElementType(Type *ElemTy);
@@ -715,31 +701,19 @@ class PointerType : public Type {
   /// type matches Ty. Primarily used for checking if an instruction's pointer
   /// operands are valid types. Will be useless after non-opaque pointers are
   /// removed.
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
   [[deprecated("Always returns true")]]
   bool isOpaqueOrPointeeTypeMatches(Type *) {
     return true;
   }
-#else // INTEL_SYCL_OPAQUEPOINTER_READY
-  bool isOpaqueOrPointeeTypeMatches(Type *Ty) {
-    return isOpaque() || PointeeTy == Ty;
-  }
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
 
   /// Return true if both pointer types have the same element type. Two opaque
   /// pointers are considered to have the same element type, while an opaque
   /// and a non-opaque pointer have different element types.
   /// TODO: Remove after opaque pointer transition is complete.
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
   [[deprecated("Always returns true")]]
   bool hasSameElementTypeAs(PointerType *Other) {
     return true;
   }
-#else // INTEL_SYCL_OPAQUEPOINTER_READY
-  bool hasSameElementTypeAs(PointerType *Other) {
-    return PointeeTy == Other->PointeeTy;
-  }
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
 
   /// Implement support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {

llvm/include/llvm/IR/IRBuilder.h

@@ -140,10 +140,6 @@ class IRBuilderBase {
     ClearInsertionPoint();
   }
 
-#ifndef INTEL_SYCL_OPAQUEPOINTER_READY
-    Value *getCastedInt8PtrValue(Value *Ptr);
-#endif
-
   /// Insert and return the specified instruction.
   template<typename InstTy>
   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
@@ -562,11 +558,7 @@ class IRBuilderBase {
 
   /// Fetch the type representing a pointer to an 8-bit integer value.
   PointerType *getInt8PtrTy(unsigned AddrSpace = 0) {
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
     return getPtrTy(AddrSpace);
-#else
-    return Type::getInt8PtrTy(Context, AddrSpace);
-#endif
   }
 
   /// Fetch the type of an integer with size at least as big as that of a

llvm/include/llvm/IR/Instructions.h

@@ -1077,7 +1077,6 @@ class GetElementPtrInst : public Instruction {
 
   /// Returns the pointer type returned by the GEP
   /// instruction, which may be a vector of pointers.
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
   static Type *getGEPReturnType(Value *Ptr, ArrayRef<Value *> IdxList) {
     // Vector GEP
     Type *Ty = Ptr->getType();
@@ -1092,29 +1091,6 @@ class GetElementPtrInst : public Instruction {
     // Scalar GEP
     return Ty;
   }
-#else // INTEL_SYCL_OPAQUEPOINTER_READY
-  static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
-                                ArrayRef<Value *> IdxList) {
-    PointerType *OrigPtrTy = cast<PointerType>(Ptr->getType()->getScalarType());
-    unsigned AddrSpace = OrigPtrTy->getAddressSpace();
-    Type *ResultElemTy = checkGEPType(getIndexedType(ElTy, IdxList));
-    Type *PtrTy = OrigPtrTy->isOpaque()
-      ? PointerType::get(OrigPtrTy->getContext(), AddrSpace)
-      : PointerType::get(ResultElemTy, AddrSpace);
-    // Vector GEP
-    if (auto *PtrVTy = dyn_cast<VectorType>(Ptr->getType())) {
-      ElementCount EltCount = PtrVTy->getElementCount();
-      return VectorType::get(PtrTy, EltCount);
-    }
-    for (Value *Index : IdxList)
-      if (auto *IndexVTy = dyn_cast<VectorType>(Index->getType())) {
-        ElementCount EltCount = IndexVTy->getElementCount();
-        return VectorType::get(PtrTy, EltCount);
-      }
-    // Scalar GEP
-    return PtrTy;
-  }
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
 
   unsigned getNumIndices() const {  // Note: always non-negative
     return getNumOperands() - 1;
@@ -1171,11 +1147,7 @@ GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
                                      ArrayRef<Value *> IdxList, unsigned Values,
                                      const Twine &NameStr,
                                      Instruction *InsertBefore)
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
     : Instruction(getGEPReturnType(Ptr, IdxList), GetElementPtr,
-#else // INTEL_SYCL_OPAQUEPOINTER_READY
-    : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
                   OperandTraits<GetElementPtrInst>::op_end(this) - Values,
                   Values, InsertBefore),
       SourceElementType(PointeeType),
@@ -1187,11 +1159,7 @@ GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
                                      ArrayRef<Value *> IdxList, unsigned Values,
                                      const Twine &NameStr,
                                      BasicBlock *InsertAtEnd)
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
     : Instruction(getGEPReturnType(Ptr, IdxList), GetElementPtr,
-#else // INTEL_SYCL_OPAQUEPOINTER_READY
-    : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
                   OperandTraits<GetElementPtrInst>::op_end(this) - Values,
                   Values, InsertAtEnd),
       SourceElementType(PointeeType),

llvm/include/llvm/IR/Intrinsics.h

@@ -128,20 +128,13 @@ namespace Intrinsic {
       TruncArgument,
       HalfVecArgument,
       SameVecWidthArgument,
-#ifndef INTEL_SYCL_OPAQUEPOINTER_READY
-      PtrToArgument,
-      PtrToElt,
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
       VecOfAnyPtrsToElt,
       VecElementArgument,
       Subdivide2Argument,
       Subdivide4Argument,
       VecOfBitcastsToInt,
       AMX,
       PPCQuad,
-#ifndef INTEL_SYCL_OPAQUEPOINTER_READY
-      AnyPtrToElt,
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
       AArch64Svcount,
     } Kind;
 
@@ -162,58 +155,30 @@ namespace Intrinsic {
     };
 
     unsigned getArgumentNumber() const {
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
       assert(Kind == Argument || Kind == ExtendArgument ||
              Kind == TruncArgument || Kind == HalfVecArgument ||
              Kind == SameVecWidthArgument || Kind == VecElementArgument ||
              Kind == Subdivide2Argument || Kind == Subdivide4Argument ||
              Kind == VecOfBitcastsToInt);
-#else
-      assert(Kind == Argument || Kind == ExtendArgument ||
-             Kind == TruncArgument || Kind == HalfVecArgument ||
-             Kind == SameVecWidthArgument ||
-             Kind == PtrToArgument ||
-             Kind == PtrToElt || Kind == VecElementArgument ||
-             Kind == Subdivide2Argument || Kind == Subdivide4Argument ||
-             Kind == VecOfBitcastsToInt);
-
-#endif // INTEL_SYCL_OPAQUEPOINTER_READY
       return Argument_Info >> 3;
     }
     ArgKind getArgumentKind() const {
-#ifndef INTEL_SYCL_OPAQUEPOINTER_READY
-      assert(Kind == Argument || Kind == ExtendArgument ||
-             Kind == TruncArgument || Kind == HalfVecArgument ||
-             Kind == PtrToArgument ||
-             Kind == SameVecWidthArgument ||
-             Kind == VecElementArgument || Kind == Subdivide2Argument ||
-             Kind == Subdivide4Argument || Kind == VecOfBitcastsToInt);
-#else
       assert(Kind == Argument || Kind == ExtendArgument ||
              Kind == TruncArgument || Kind == HalfVecArgument ||
-             Kind == SameVecWidthArgument ||
-             Kind == VecElementArgument || Kind == Subdivide2Argument ||
-             Kind == Subdivide4Argument || Kind == VecOfBitcastsToInt);
-#endif
+             Kind == SameVecWidthArgument || Kind == VecElementArgument ||
+             Kind == Subdivide2Argument || Kind == Subdivide4Argument ||
+             Kind == VecOfBitcastsToInt);
       return (ArgKind)(Argument_Info & 7);
     }
 
     // VecOfAnyPtrsToElt uses both an overloaded argument (for address space)
     // and a reference argument (for matching vector width and element types)
     unsigned getOverloadArgNumber() const {
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
       assert(Kind == VecOfAnyPtrsToElt);
-#else
-      assert(Kind == VecOfAnyPtrsToElt || Kind == AnyPtrToElt);
-#endif
       return Argument_Info >> 16;
     }
     unsigned getRefArgNumber() const {
-#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
       assert(Kind == VecOfAnyPtrsToElt);
-#else
-      assert(Kind == VecOfAnyPtrsToElt || Kind == AnyPtrToElt);
-#endif
       return Argument_Info & 0xFFFF;
     }