Hexagon/opaque-ptr: avoid getPointerElementType() in HexagonCommonGEP. NFCI.

[t.p.northover]

Summary

This refactors the code in HexagonCommonGEP to avoid calling getPointerElementType.

I did this by making GepNode always contain the element type, which meant we needed a new flag to distinguish between the an initial (outer array) index and the subsequent destructuring ones.

There shouldn't be any change in behaviour so no tests.

llvm/lib/Target/Hexagon/HexagonCommonGEP.cpp

 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 INITIALIZE_PASS_END(HexagonCommonGEP, "hcommgep", "Hexagon Common GEP",
       false, false)
 
 namespace {
 
   struct GepNode {
     enum {
       None      = 0,
       Root      = 0x01,
       Internal  = 0x02,
       Used      = 0x04,
-      InBounds  = 0x08
+      InBounds  = 0x08,
+      FirstGEPIndex = 0x10,
     };
 
     uint32_t Flags = 0;
     union {
       GepNode *Parent;
       Value *BaseVal;
     };
     Value *Idx = nullptr;
-    Type *PTy = nullptr;  // Type of the pointer operand.
+    Type *ElTy = nullptr; // Element type being GEPed here
 
     GepNode() : Parent(nullptr) {}
-    GepNode(const GepNode *N) : Flags(N->Flags), Idx(N->Idx), PTy(N->PTy) {
+    GepNode(const GepNode *N)
+        : Flags(N->Flags), Idx(N->Idx), ElTy(N->ElTy) {
       if (Flags & Root)
         BaseVal = N->BaseVal;
       else
         Parent = N->Parent;
     }
 
     friend raw_ostream &operator<< (raw_ostream &OS, const GepNode &GN);
   };
 
-  Type *next_type(Type *Ty, Value *Idx) {
-    if (auto *PTy = dyn_cast<PointerType>(Ty))
-      return PTy->getElementType();
-    return GetElementPtrInst::getTypeAtIndex(Ty, Idx);
-  }
-
   raw_ostream &operator<< (raw_ostream &OS, const GepNode &GN) {
     OS << "{ {";
     bool Comma = false;
     if (GN.Flags & GepNode::Root) {
       OS << "root";
       Comma = true;
     }
     if (GN.Flags & GepNode::Internal) {
       if (Comma)
         OS << ',';
       OS << "internal";
       Comma = true;
     }
     if (GN.Flags & GepNode::Used) {
       if (Comma)
         OS << ',';
       OS << "used";
     }
     if (GN.Flags & GepNode::InBounds) {
       if (Comma)
         OS << ',';
       OS << "inbounds";
     }
+    if (GN.Flags & GepNode::FirstGEPIndex) {
+      if (Comma)
+        OS << ',';
+      OS << "firstindex";
+    }
     OS << "} ";
     if (GN.Flags & GepNode::Root)
       OS << "BaseVal:" << GN.BaseVal->getName() << '(' << GN.BaseVal << ')';
     else
       OS << "Parent:" << GN.Parent;
 
     OS << " Idx:";
     if (ConstantInt *CI = dyn_cast<ConstantInt>(GN.Idx))
       OS << CI->getValue().getSExtValue();
     else if (GN.Idx->hasName())
       OS << GN.Idx->getName();
     else
       OS << "<anon> =" << *GN.Idx;
 
-    OS << " PTy:";
-    if (GN.PTy->isStructTy()) {
-      StructType *STy = cast<StructType>(GN.PTy);
+    OS << " ElTy:";
+    if (GN.ElTy->isStructTy()) {
+      StructType *STy = cast<StructType>(GN.ElTy);
       if (!STy->isLiteral())
-        OS << GN.PTy->getStructName();
+        OS << GN.ElTy->getStructName();
       else
         OS << "<anon-struct>:" << *STy;
     }
     else
-      OS << *GN.PTy;
+      OS << *GN.ElTy;
     OS << " }";
     return OS;
   }
 
   template <typename NodeContainer>
   void dump_node_container(raw_ostream &OS, const NodeContainer &S) {
     using const_iterator = typename NodeContainer::const_iterator;
 
if (F == NM.end()) {
     N->BaseVal = PtrOp;
     N->Flags |= GepNode::Root | InBounds;
   } else {
     // If PtrOp was a GEP instruction, it must have already been processed.
     // The ValueToNodeMap entry for it is the last gep node in the generated
     // chain. Link to it here.
     N->Parent = F->second;
   }
-  N->PTy = PtrOp->getType();
+  N->Flags |= GepNode::FirstGEPIndex;
+  N->ElTy = GepI->getSourceElementType();
   N->Idx = *GepI->idx_begin();
 
   // Collect the list of users of this GEP instruction. Will add it to the
   // last node created for it.
   UseSet Us;
   for (Value::user_iterator UI = GepI->user_begin(), UE = GepI->user_end();
        UI != UE; ++UI) {
     // Check if this gep is used by anything other than other geps that
     // we will process.
     if (isa<GetElementPtrInst>(*UI)) {
       GetElementPtrInst *UserG = cast<GetElementPtrInst>(*UI);
       if (isHandledGepForm(UserG))
         continue;
     }
     Us.insert(&UI.getUse());
   }
   Nodes.push_back(N);
   NodeOrder.insert(N);
 
   // Skip the first index operand, since we only handle 0. This dereferences
   // the pointer operand.
   GepNode *PN = N;
-  Type *PtrTy = cast<PointerType>(PtrOp->getType())->getElementType();
+  Type *ElTy = GepI->getSourceElementType();
   for (User::op_iterator OI = GepI->idx_begin()+1, OE = GepI->idx_end();
        OI != OE; ++OI) {
     Value *Op = *OI;
     GepNode *Nx = new (*Mem) GepNode;
     Nx->Parent = PN;  // Link Nx to the previous node.
     Nx->Flags |= GepNode::Internal | InBounds;
-    Nx->PTy = PtrTy;
+    Nx->ElTy = ElTy;
     Nx->Idx = Op;
     Nodes.push_back(Nx);
     NodeOrder.insert(Nx);
     PN = Nx;
 
-    PtrTy = next_type(PtrTy, Op);
+    ElTy = GetElementPtrInst::getTypeAtIndex(ElTy, Op);
   }
 
   // After last node has been created, update the use information.
   if (!Us.empty()) {
     PN->Flags |= GepNode::Used;
     Uses[PN].insert(Us.begin(), Us.end());
   }
 
if (P1 <= P2)
       return std::make_pair(N1, N2);
     return std::make_pair(N2, N1);
 }
 
 static unsigned node_hash(GepNode *N) {
     // Include everything except flags and parent.
     FoldingSetNodeID ID;
     ID.AddPointer(N->Idx);
-    ID.AddPointer(N->PTy);
+    ID.AddPointer(N->ElTy);
     return ID.ComputeHash();
 }
 
 static bool node_eq(GepNode *N1, GepNode *N2, NodePairSet &Eq,
                     NodePairSet &Ne) {
     // Don't cache the result for nodes with different hashes. The hash
     // comparison is fast enough.
     if (node_hash(N1) != node_hash(N2))
LLVM_DEBUG(dbgs() << "Fabricating GEP in " << LocB->getName()
                     << " for nodes:\n"
                     << NA);
   unsigned Num = NA.size();
   GepNode *RN = NA[0];
   assert((RN->Flags & GepNode::Root) && "Creating GEP for non-root");
 
   GetElementPtrInst *NewInst = nullptr;
   Value *Input = RN->BaseVal;
+  Type *ElTy = RN->ElTy;
   Value **IdxList = new Value*[Num+1];
   unsigned nax = 0;
   do {
     unsigned IdxC = 0;
-    // If the type of the input of the first node is not a pointer,
-    // we need to add an artificial i32 0 to the indices (because the
-    // actual input in the IR will be a pointer).
-    if (!NA[nax]->PTy->isPointerTy()) {
+    // If we're starting a new GEP but the first index is supposed to
+    // destructure, we need to add an artificial 0 index to skip the array
+    // dereference part.
+    if (!(NA[nax]->Flags & GepNode::FirstGEPIndex)) {
       Type *Int32Ty = Type::getInt32Ty(*Ctx);
       IdxList[IdxC++] = ConstantInt::get(Int32Ty, 0);
     }
 
     // Keep adding indices from NA until we have to stop and generate
     // an "intermediate" GEP.
     while (++nax <= Num) {
       GepNode *N = NA[nax-1];
       IdxList[IdxC++] = N->Idx;
       if (nax < Num) {
-        // We have to stop, if the expected type of the output of this node
-        // is not the same as the input type of the next node.
-        Type *NextTy = next_type(N->PTy, N->Idx);
-        if (NextTy != NA[nax]->PTy)
+        // We have to stop, if the next node was the start of a new GEP because
+        // that's an outer array access.
+        if (NA[nax]->Flags & GepNode::FirstGEPIndex)
           break;
       }
     }
     ArrayRef<Value*> A(IdxList, IdxC);
-    Type *InpTy = Input->getType();
-    Type *ElTy = cast<PointerType>(InpTy->getScalarType())->getElementType();
     NewInst = GetElementPtrInst::Create(ElTy, Input, A, "cgep", &*At);
     NewInst->setIsInBounds(RN->Flags & GepNode::InBounds);
     LLVM_DEBUG(dbgs() << "new GEP: " << *NewInst << '\n');
     Input = NewInst;
+    ElTy = NewInst->getResultElementType();
   } while (nax <= Num);
 
   delete[] IdxList;
   return NewInst;
 }
 
 void HexagonCommonGEP::getAllUsersForNode(GepNode *Node, ValueVect &Values,
       NodeChildrenMap &NCM) {