[NFC] Fix compile time regression seen on some benchmarks after a630ea3003 commit

[yurai007]

Summary

The goal of this change is fixing most of compile time slowdown seen after a630ea3003 commit on lencod and sqlite3 benchmarks.

There are 3 simple improvements included in this patch:

1. In getNumOperands when possible get value directly from SmallNumOps.
2. Inline getLargePtr by moving its definition to header.
3. In TBAAStructTypeNode::getField get all operands once instead taking operands in loop one after one.

[nikic]

LGTM

Compile-time: http://llvm-compile-time-tracker.com/compare.php?from=9b9ff63b03eae1027aa75d9c2b37b98b10a49c66&to=f94121930dade0677f3b566e65812975abd3a39c&stat=instructions

llvm/include/llvm/IR/Metadata.h

1045

Directly use getLarge().size() here?

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

306

Can use Node->operands() here?

[yurai007]

llvm/include/llvm/IR/Metadata.h

1045

Right, it should be slightly better. There is no need to check IsLarge twice in slow path.

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

306

Unfortunately not. I tried this initially, but there is no simple conversion from iterator_range<const llvm::MDOperand *> to MutableArrayRef/ArrayRef<llvm::MDOperand>. Also making Operands iterator_range complicates things with indexing and getting size so ended up with passing iterators directly to ArrayRef.

[dexonsmith]

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

306

As a prep / follow-up, it might be reasonable to update operands() to return ArrayRef.

[yurai007]

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

306

As a prep / follow-up, it might be reasonable to update operands() to return ArrayRef.

Ok. I can prepare such change as follow-up.

llvm/include/llvm/IR/Metadata.h

struct alignas(alignof(size_t)) Header {
     size_t getAllocSize() const {
       return getOpSize(SmallSize) + sizeof(Header);
     }
     void *getAllocation() {
       return reinterpret_cast<char *>(this + 1) -
              alignTo(getAllocSize(), alignof(uint64_t));
     }
 
-    void *getLargePtr() const;
+    void *getLargePtr() const {
+      static_assert(alignof(LargeStorageVector) <= alignof(Header),
+                    "LargeStorageVector too strongly aligned");
+      return reinterpret_cast<char *>(const_cast<Header *>(this)) -
+             sizeof(LargeStorageVector);
+    }
+
     void *getSmallPtr();
 
     LargeStorageVector &getLarge() {
       assert(IsLarge);
       return *reinterpret_cast<LargeStorageVector *>(getLargePtr());
     }
 
     const LargeStorageVector &getLarge() const {
struct alignas(alignof(size_t)) Header {
     }
 
     ArrayRef<MDOperand> operands() const {
       if (IsLarge)
         return getLarge();
       return makeArrayRef(reinterpret_cast<const MDOperand *>(this) - SmallSize,
                           SmallNumOps);
     }
+
+    unsigned getNumOperands() const {
+      if (!IsLarge)
+        return SmallNumOps;
+      return getLarge().size();
+    }
   };
 
   Header &getHeader() { return *(reinterpret_cast<Header *>(this) - 1); }
 
   const Header &getHeader() const {
     return *(reinterpret_cast<const Header *>(this) - 1);
   }
 
public:
   op_range operands() const { return op_range(op_begin(), op_end()); }
 
   const MDOperand &getOperand(unsigned I) const {
     assert(I < getNumOperands() && "Out of range");
     return getHeader().operands()[I];
   }
 
   /// Return number of MDNode operands.
-  unsigned getNumOperands() const { return getHeader().operands().size(); }
+  unsigned getNumOperands() const { return getHeader().getNumOperands(); }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Metadata *MD) {
     switch (MD->getMetadataID()) {
     default:
       return false;
 #define HANDLE_MDNODE_LEAF(CLASS)                                              \
   case CLASS##Kind:                                                            \

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

TBAAStructTypeNode getFieldType(unsigned FieldIndex) const {
     auto *TypeNode = cast<MDNode>(getNode()->getOperand(OpIndex));
     return TBAAStructTypeNode(TypeNode);
   }
 
   /// Get this TBAAStructTypeNode's field in the type DAG with
   /// given offset. Update the offset to be relative to the field type.
   TBAAStructTypeNode getField(uint64_t &Offset) const {
     bool NewFormat = isNewFormat();
+    const ArrayRef<MDOperand> Operands(Node->op_begin(), Node->op_end());
+    const unsigned NumOperands = Operands.size();
+
     if (NewFormat) {
       // New-format root and scalar type nodes have no fields.
-      if (Node->getNumOperands() < 6)
+      if (NumOperands < 6)
         return TBAAStructTypeNode();
     } else {
       // Parent can be omitted for the root node.
-      if (Node->getNumOperands() < 2)
+      if (NumOperands < 2)
         return TBAAStructTypeNode();
 
       // Fast path for a scalar type node and a struct type node with a single
       // field.
-      if (Node->getNumOperands() <= 3) {
-        uint64_t Cur = Node->getNumOperands() == 2
-                           ? 0
-                           : mdconst::extract<ConstantInt>(Node->getOperand(2))
-                                 ->getZExtValue();
+      if (NumOperands <= 3) {
+        uint64_t Cur =
+            NumOperands == 2
+                : mdconst::extract<ConstantInt>(Operands[2])->getZExtValue();
         Offset -= Cur;
-        MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1));
+        MDNode *P = dyn_cast_or_null<MDNode>(Operands[1]);
         if (!P)
           return TBAAStructTypeNode();
         return TBAAStructTypeNode(P);
       }
     }
 
     // Assume the offsets are in order. We return the previous field if
     // the current offset is bigger than the given offset.
     unsigned FirstFieldOpNo = NewFormat ? 3 : 1;
     unsigned NumOpsPerField = NewFormat ? 3 : 2;
     unsigned TheIdx = 0;
-    for (unsigned Idx = FirstFieldOpNo; Idx < Node->getNumOperands();
+
+    for (unsigned Idx = FirstFieldOpNo; Idx < NumOperands;
          Idx += NumOpsPerField) {
-      uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(Idx + 1))
-                         ->getZExtValue();
+      uint64_t Cur =
+          mdconst::extract<ConstantInt>(Operands[Idx + 1])->getZExtValue();
       if (Cur > Offset) {
         assert(Idx >= FirstFieldOpNo + NumOpsPerField &&
                "TBAAStructTypeNode::getField should have an offset match!");
         TheIdx = Idx - NumOpsPerField;
         break;
       }
     }
     // Move along the last field.
     if (TheIdx == 0)
-      TheIdx = Node->getNumOperands() - NumOpsPerField;
-    uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(TheIdx + 1))
-                       ->getZExtValue();
+      TheIdx = NumOperands - NumOpsPerField;
+    uint64_t Cur =
+        mdconst::extract<ConstantInt>(Operands[TheIdx + 1])->getZExtValue();
     Offset -= Cur;
-    MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(TheIdx));
+    MDNode *P = dyn_cast_or_null<MDNode>(Operands[TheIdx]);
     if (!P)
       return TBAAStructTypeNode();
     return TBAAStructTypeNode(P);
   }
 };
 
 } // end anonymous namespace
 

llvm/lib/IR/Metadata.cpp

if (IsLarge) {
     getLarge().~LargeStorageVector();
     return;
   }
   MDOperand *O = reinterpret_cast<MDOperand *>(this);
   for (MDOperand *E = O - SmallSize; O != E; --O)
     (void)(O - 1)->~MDOperand();
 }
 
-void *MDNode::Header::getLargePtr() const {
-  static_assert(alignof(LargeStorageVector) <= alignof(Header),
-                "LargeStorageVector too strongly aligned");
-  return reinterpret_cast<char *>(const_cast<Header *>(this)) -
-         sizeof(LargeStorageVector);
-}
-
 void *MDNode::Header::getSmallPtr() {
   static_assert(alignof(MDOperand) <= alignof(Header),
                 "MDOperand too strongly aligned");
   return reinterpret_cast<char *>(const_cast<Header *>(this)) -
          sizeof(MDOperand) * SmallSize;
 }
 
 void MDNode::Header::resize(size_t NumOps) {