[DirectX] Remove uses of isOpaquePointerTy(). NFC

[bogner]

Summary

isOpaquePointerTy now returns true for all pointers, so we can replace these with isPointerTy().

[beanz]

LGTM.

[bogner]

Fix incorrect assignment of "CODE" in DXILBitcodeWriter

[bogner]

Forgot to put the "Differential Revision" tag in the commit message. Committed here: https://github.com/llvm/llvm-project/commit/245073ac80b3a2ab942ac3c81126c14037501945

llvm/lib/Target/DirectX/DXILPrepare.cpp

for (auto &F : M.functions()) {
           if (I.getOpcode() == Instruction::FNeg) {
             Builder.SetInsertPoint(&I);
             Value *In = I.getOperand(0);
             Value *Zero = ConstantFP::get(In->getType(), -0.0);
             I.replaceAllUsesWith(Builder.CreateFSub(Zero, In));
             I.eraseFromParent();
             continue;
           }
-          // Only insert bitcasts if the IR is using opaque pointers.
-          if (M.getContext().supportsTypedPointers())
-            continue;
 
           // Emtting NoOp bitcast instructions allows the ValueEnumerator to be
           // unmodified as it reserves instruction IDs during contruction.
           if (auto LI = dyn_cast<LoadInst>(&I)) {
             if (Value *NoOpBitcast = maybeGenerateBitcast(
                     Builder, PointerTypes, I, LI->getPointerOperand(),
                     LI->getType())) {
               LI->replaceAllUsesWith(

llvm/lib/Target/DirectX/DXILWriter/DXILBitcodeWriter.cpp

unsigned DXILBitcodeWriter::getEncodedBinaryOpcode(unsigned Opcode) {
   case Instruction::Or:
     return bitc::BINOP_OR;
   case Instruction::Xor:
     return bitc::BINOP_XOR;
   }
 }
 
 unsigned DXILBitcodeWriter::getTypeID(Type *T, const Value *V) {
-  if (!T->isOpaquePointerTy() &&
+  if (!T->isPointerTy() &&
       // For Constant, always check PointerMap to make sure OpaquePointer in
       // things like constant struct/array works.
       (!V || !isa<Constant>(V)))
     return VE.getTypeID(T);
   auto It = PointerMap.find(V);
   if (It != PointerMap.end())
     return VE.getTypeID(It->second);
   // For Constant, return T when cannot find in PointerMap.
case Type::TypedPointerTyID: {
       TypeVals.push_back(getTypeID(PTy->getElementType()));
       unsigned AddressSpace = PTy->getAddressSpace();
       TypeVals.push_back(AddressSpace);
       if (AddressSpace == 0)
         AbbrevToUse = PtrAbbrev;
       break;
     }
     case Type::PointerTyID: {
-      PointerType *PTy = cast<PointerType>(T);
       // POINTER: [pointee type, address space]
-      Code = bitc::TYPE_CODE_POINTER;
-      // Emitting an empty struct type for the opaque pointer's type allows
-      // this to be order-independent. Non-struct types must be emitted in
-      // bitcode before they can be referenced.
-      if (PTy->isOpaquePointerTy()) {
-        TypeVals.push_back(false);
-        Code = bitc::TYPE_CODE_OPAQUE;
-        writeStringRecord(Stream, bitc::TYPE_CODE_STRUCT_NAME,
-                          "dxilOpaquePtrReservedName", StructNameAbbrev);
-      } else {
-        TypeVals.push_back(getTypeID(PTy->getNonOpaquePointerElementType()));
-        unsigned AddressSpace = PTy->getAddressSpace();
-        TypeVals.push_back(AddressSpace);
-        if (AddressSpace == 0)
-          AbbrevToUse = PtrAbbrev;
-      }
+      // Emitting an empty struct type for the pointer's type allows this to be
+      // order-independent. Non-struct types must be emitted in bitcode before
+      // they can be referenced.
       break;
     }
     case Type::FunctionTyID: {
       FunctionType *FT = cast<FunctionType>(T);
       // FUNCTION: [isvararg, retty, paramty x N]
       Code = bitc::TYPE_CODE_FUNCTION;
       TypeVals.push_back(FT->isVarArg());
       TypeVals.push_back(getTypeID(FT->getReturnType()));

llvm/lib/Target/DirectX/DirectXIRPasses/PointerTypeAnalysis.cpp

 using namespace llvm;
 using namespace llvm::dxil;
 
 namespace {
 
 // Classifies the type of the value passed in by walking the value's users to
 // find a typed instruction to materialize a type from.
 Type *classifyPointerType(const Value *V, PointerTypeMap &Map) {
-  assert(V->getType()->isOpaquePointerTy() &&
-         "classifyPointerType called with non-opaque pointer");
+  assert(V->getType()->isPointerTy() &&
+         "classifyPointerType called with non-pointer");
   auto It = Map.find(V);
   if (It != Map.end())
     return It->second;
 
   Type *PointeeTy = nullptr;
   if (auto *Inst = dyn_cast<GetElementPtrInst>(V)) {
-    if (!Inst->getResultElementType()->isOpaquePointerTy())
+    if (!Inst->getResultElementType()->isPointerTy())
       PointeeTy = Inst->getResultElementType();
   } else if (auto *Inst = dyn_cast<AllocaInst>(V)) {
     PointeeTy = Inst->getAllocatedType();
   } else if (auto *GV = dyn_cast<GlobalVariable>(V)) {
     PointeeTy = GV->getValueType();
   }
 
   for (const auto *User : V->users()) {
     Type *NewPointeeTy = nullptr;
     if (const auto *Inst = dyn_cast<LoadInst>(User)) {
       NewPointeeTy = Inst->getType();
     } else if (const auto *Inst = dyn_cast<StoreInst>(User)) {
       NewPointeeTy = Inst->getValueOperand()->getType();
       // When store value is ptr type, cannot get more type info.
-      if (NewPointeeTy->isOpaquePointerTy())
+      if (NewPointeeTy->isPointerTy())
         continue;
     } else if (const auto *Inst = dyn_cast<GetElementPtrInst>(User)) {
       NewPointeeTy = Inst->getSourceElementType();
     }
     if (NewPointeeTy) {
       // HLSL doesn't support pointers, so it is unlikely to get more than one
       // or two levels of indirection in the IR. Because of this, recursion is
       // pretty safe.
-      if (NewPointeeTy->isOpaquePointerTy()) {
+      if (NewPointeeTy->isPointerTy()) {
         PointeeTy = classifyPointerType(User, Map);
         break;
       }
       if (!PointeeTy)
         PointeeTy = NewPointeeTy;
       else if (PointeeTy != NewPointeeTy)
         PointeeTy = Type::getInt8Ty(V->getContext());
     }

 Type *classifyFunctionType(const Function &F, PointerTypeMap &Map) {
   auto It = Map.find(&F);
   if (It != Map.end())
     return It->second;
 
   SmallVector<Type *, 8> NewArgs;
   Type *RetTy = F.getReturnType();
   LLVMContext &Ctx = F.getContext();
-  if (RetTy->isOpaquePointerTy()) {
+  if (RetTy->isPointerTy()) {
     RetTy = nullptr;
     for (const auto &B : F) {
       const auto *RetInst = dyn_cast_or_null<ReturnInst>(B.getTerminator());
       if (!RetInst)
         continue;
 
       Type *NewRetTy = classifyPointerType(RetInst->getReturnValue(), Map);
       if (!RetTy)
         RetTy = NewRetTy;
       else if (RetTy != NewRetTy)
         RetTy = TypedPointerType::get(
             Type::getInt8Ty(Ctx), F.getReturnType()->getPointerAddressSpace());
     }
     // For function decl.
     if (!RetTy)
       RetTy = TypedPointerType::get(
           Type::getInt8Ty(Ctx), F.getReturnType()->getPointerAddressSpace());
   }
   for (auto &A : F.args()) {
     Type *ArgTy = A.getType();
-    if (ArgTy->isOpaquePointerTy())
+    if (ArgTy->isPointerTy())
       ArgTy = classifyPointerType(&A, Map);
     NewArgs.push_back(ArgTy);
   }
   auto *TypedPtrTy =
       TypedPointerType::get(FunctionType::get(RetTy, NewArgs, false), 0);
   Map[&F] = TypedPtrTy;
   return TypedPtrTy;
 }
static void classifyGlobalCtorPointerType(const GlobalVariable &GV,
   // Map the global type.
   Map[&GV] = TypedPointerType::get(CtorArrayTy,
                                    GV.getType()->getPointerAddressSpace());
 }
 
 PointerTypeMap PointerTypeAnalysis::run(const Module &M) {
   PointerTypeMap Map;
   for (auto &G : M.globals()) {
-    if (G.getType()->isOpaquePointerTy())
+    if (G.getType()->isPointerTy())
       classifyPointerType(&G, Map);
     if (G.getName() == "llvm.global_ctors")
       classifyGlobalCtorPointerType(G, Map);
   }
 
   for (auto &F : M) {
     classifyFunctionType(F, Map);
 
     for (const auto &B : F) {
       for (const auto &I : B) {
-        if (I.getType()->isOpaquePointerTy())
+        if (I.getType()->isPointerTy())
           classifyPointerType(&I, Map);
       }
     }
   }
   return Map;
 }