[PM/AA] Run clang-format over TBAA code to normalize the formatting
authorChandler Carruth <chandlerc@gmail.com>
Fri, 14 Aug 2015 03:26:15 +0000 (03:26 +0000)
committerChandler Carruth <chandlerc@gmail.com>
Fri, 14 Aug 2015 03:26:15 +0000 (03:26 +0000)
before making substantial changes.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@245017 91177308-0d34-0410-b5e6-96231b3b80d8

lib/Analysis/TypeBasedAliasAnalysis.cpp

index c86856d..427f090 100644 (file)
@@ -138,180 +138,178 @@ using namespace llvm;
 static cl::opt<bool> EnableTBAA("enable-tbaa", cl::init(true));
 
 namespace {
 static cl::opt<bool> EnableTBAA("enable-tbaa", cl::init(true));
 
 namespace {
-  /// TBAANode - This is a simple wrapper around an MDNode which provides a
-  /// higher-level interface by hiding the details of how alias analysis
-  /// information is encoded in its operands.
-  class TBAANode {
-    const MDNode *Node;
-
-  public:
-    TBAANode() : Node(nullptr) {}
-    explicit TBAANode(const MDNode *N) : Node(N) {}
-
-    /// getNode - Get the MDNode for this TBAANode.
-    const MDNode *getNode() const { return Node; }
-
-    /// getParent - Get this TBAANode's Alias tree parent.
-    TBAANode getParent() const {
-      if (Node->getNumOperands() < 2)
-        return TBAANode();
-      MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1));
-      if (!P)
-        return TBAANode();
-      // Ok, this node has a valid parent. Return it.
-      return TBAANode(P);
-    }
+/// TBAANode - This is a simple wrapper around an MDNode which provides a
+/// higher-level interface by hiding the details of how alias analysis
+/// information is encoded in its operands.
+class TBAANode {
+  const MDNode *Node;
+
+public:
+  TBAANode() : Node(nullptr) {}
+  explicit TBAANode(const MDNode *N) : Node(N) {}
+
+  /// getNode - Get the MDNode for this TBAANode.
+  const MDNode *getNode() const { return Node; }
+
+  /// getParent - Get this TBAANode's Alias tree parent.
+  TBAANode getParent() const {
+    if (Node->getNumOperands() < 2)
+      return TBAANode();
+    MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1));
+    if (!P)
+      return TBAANode();
+    // Ok, this node has a valid parent. Return it.
+    return TBAANode(P);
+  }
 
 
-    /// TypeIsImmutable - Test if this TBAANode represents a type for objects
-    /// which are not modified (by any means) in the context where this
-    /// AliasAnalysis is relevant.
-    bool TypeIsImmutable() const {
-      if (Node->getNumOperands() < 3)
-        return false;
-      ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(2));
-      if (!CI)
-        return false;
-      return CI->getValue()[0];
-    }
-  };
+  /// TypeIsImmutable - Test if this TBAANode represents a type for objects
+  /// which are not modified (by any means) in the context where this
+  /// AliasAnalysis is relevant.
+  bool TypeIsImmutable() const {
+    if (Node->getNumOperands() < 3)
+      return false;
+    ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(2));
+    if (!CI)
+      return false;
+    return CI->getValue()[0];
+  }
+};
 
 
-  /// This is a simple wrapper around an MDNode which provides a
-  /// higher-level interface by hiding the details of how alias analysis
-  /// information is encoded in its operands.
-  class TBAAStructTagNode {
-    /// This node should be created with createTBAAStructTagNode.
-    const MDNode *Node;
+/// This is a simple wrapper around an MDNode which provides a
+/// higher-level interface by hiding the details of how alias analysis
+/// information is encoded in its operands.
+class TBAAStructTagNode {
+  /// This node should be created with createTBAAStructTagNode.
+  const MDNode *Node;
 
 
-  public:
-    explicit TBAAStructTagNode(const MDNode *N) : Node(N) {}
+public:
+  explicit TBAAStructTagNode(const MDNode *N) : Node(N) {}
 
 
-    /// Get the MDNode for this TBAAStructTagNode.
-    const MDNode *getNode() const { return Node; }
+  /// Get the MDNode for this TBAAStructTagNode.
+  const MDNode *getNode() const { return Node; }
 
 
-    const MDNode *getBaseType() const {
-      return dyn_cast_or_null<MDNode>(Node->getOperand(0));
-    }
-    const MDNode *getAccessType() const {
-      return dyn_cast_or_null<MDNode>(Node->getOperand(1));
-    }
-    uint64_t getOffset() const {
-      return mdconst::extract<ConstantInt>(Node->getOperand(2))->getZExtValue();
-    }
-    /// TypeIsImmutable - Test if this TBAAStructTagNode represents a type for
-    /// objects which are not modified (by any means) in the context where this
-    /// AliasAnalysis is relevant.
-    bool TypeIsImmutable() const {
-      if (Node->getNumOperands() < 4)
-        return false;
-      ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(3));
-      if (!CI)
-        return false;
-      return CI->getValue()[0];
-    }
-  };
-
-  /// This is a simple wrapper around an MDNode which provides a
-  /// higher-level interface by hiding the details of how alias analysis
-  /// information is encoded in its operands.
-  class TBAAStructTypeNode {
-    /// This node should be created with createTBAAStructTypeNode.
-    const MDNode *Node;
-
-  public:
-    TBAAStructTypeNode() : Node(nullptr) {}
-    explicit TBAAStructTypeNode(const MDNode *N) : Node(N) {}
-
-    /// Get the MDNode for this TBAAStructTypeNode.
-    const MDNode *getNode() const { return Node; }
-
-    /// Get this TBAAStructTypeNode's field in the type DAG with
-    /// given offset. Update the offset to be relative to the field type.
-    TBAAStructTypeNode getParent(uint64_t &Offset) const {
-      // Parent can be omitted for the root node.
-      if (Node->getNumOperands() < 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();
-        Offset -= Cur;
-        MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(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 TheIdx = 0;
-      for (unsigned Idx = 1; Idx < Node->getNumOperands(); Idx += 2) {
-        uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(Idx + 1))
-                           ->getZExtValue();
-        if (Cur > Offset) {
-          assert(Idx >= 3 &&
-                 "TBAAStructTypeNode::getParent should have an offset match!");
-          TheIdx = Idx - 2;
-          break;
-        }
-      }
-      // Move along the last field.
-      if (TheIdx == 0)
-        TheIdx = Node->getNumOperands() - 2;
-      uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(TheIdx + 1))
-                         ->getZExtValue();
+  const MDNode *getBaseType() const {
+    return dyn_cast_or_null<MDNode>(Node->getOperand(0));
+  }
+  const MDNode *getAccessType() const {
+    return dyn_cast_or_null<MDNode>(Node->getOperand(1));
+  }
+  uint64_t getOffset() const {
+    return mdconst::extract<ConstantInt>(Node->getOperand(2))->getZExtValue();
+  }
+  /// TypeIsImmutable - Test if this TBAAStructTagNode represents a type for
+  /// objects which are not modified (by any means) in the context where this
+  /// AliasAnalysis is relevant.
+  bool TypeIsImmutable() const {
+    if (Node->getNumOperands() < 4)
+      return false;
+    ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(3));
+    if (!CI)
+      return false;
+    return CI->getValue()[0];
+  }
+};
+
+/// This is a simple wrapper around an MDNode which provides a
+/// higher-level interface by hiding the details of how alias analysis
+/// information is encoded in its operands.
+class TBAAStructTypeNode {
+  /// This node should be created with createTBAAStructTypeNode.
+  const MDNode *Node;
+
+public:
+  TBAAStructTypeNode() : Node(nullptr) {}
+  explicit TBAAStructTypeNode(const MDNode *N) : Node(N) {}
+
+  /// Get the MDNode for this TBAAStructTypeNode.
+  const MDNode *getNode() const { return Node; }
+
+  /// Get this TBAAStructTypeNode's field in the type DAG with
+  /// given offset. Update the offset to be relative to the field type.
+  TBAAStructTypeNode getParent(uint64_t &Offset) const {
+    // Parent can be omitted for the root node.
+    if (Node->getNumOperands() < 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();
       Offset -= Cur;
       Offset -= Cur;
-      MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(TheIdx));
+      MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1));
       if (!P)
         return TBAAStructTypeNode();
       return TBAAStructTypeNode(P);
     }
       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 TheIdx = 0;
+    for (unsigned Idx = 1; Idx < Node->getNumOperands(); Idx += 2) {
+      uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(Idx + 1))
+                         ->getZExtValue();
+      if (Cur > Offset) {
+        assert(Idx >= 3 &&
+               "TBAAStructTypeNode::getParent should have an offset match!");
+        TheIdx = Idx - 2;
+        break;
+      }
+    }
+    // Move along the last field.
+    if (TheIdx == 0)
+      TheIdx = Node->getNumOperands() - 2;
+    uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(TheIdx + 1))
+                       ->getZExtValue();
+    Offset -= Cur;
+    MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(TheIdx));
+    if (!P)
+      return TBAAStructTypeNode();
+    return TBAAStructTypeNode(P);
+  }
+};
 }
 
 namespace {
 }
 
 namespace {
-  /// TypeBasedAliasAnalysis - This is a simple alias analysis
-  /// implementation that uses TypeBased to answer queries.
-  class TypeBasedAliasAnalysis : public ImmutablePass,
-                                 public AliasAnalysis {
-  public:
-    static char ID; // Class identification, replacement for typeinfo
-    TypeBasedAliasAnalysis() : ImmutablePass(ID) {
-      initializeTypeBasedAliasAnalysisPass(*PassRegistry::getPassRegistry());
-    }
+/// TypeBasedAliasAnalysis - This is a simple alias analysis
+/// implementation that uses TypeBased to answer queries.
+class TypeBasedAliasAnalysis : public ImmutablePass, public AliasAnalysis {
+public:
+  static char ID; // Class identification, replacement for typeinfo
+  TypeBasedAliasAnalysis() : ImmutablePass(ID) {
+    initializeTypeBasedAliasAnalysisPass(*PassRegistry::getPassRegistry());
+  }
 
 
-    bool doInitialization(Module &M) override;
+  bool doInitialization(Module &M) override;
 
 
-    /// getAdjustedAnalysisPointer - This method is used when a pass implements
-    /// an analysis interface through multiple inheritance.  If needed, it
-    /// should override this to adjust the this pointer as needed for the
-    /// specified pass info.
-    void *getAdjustedAnalysisPointer(const void *PI) override {
-      if (PI == &AliasAnalysis::ID)
-        return (AliasAnalysis*)this;
-      return this;
-    }
+  /// getAdjustedAnalysisPointer - This method is used when a pass implements
+  /// an analysis interface through multiple inheritance.  If needed, it
+  /// should override this to adjust the this pointer as needed for the
+  /// specified pass info.
+  void *getAdjustedAnalysisPointer(const void *PI) override {
+    if (PI == &AliasAnalysis::ID)
+      return (AliasAnalysis *)this;
+    return this;
+  }
 
 
-    bool Aliases(const MDNode *A, const MDNode *B) const;
-    bool PathAliases(const MDNode *A, const MDNode *B) const;
-
-  private:
-    void getAnalysisUsage(AnalysisUsage &AU) const override;
-    AliasResult alias(const MemoryLocation &LocA,
-                      const MemoryLocation &LocB) override;
-    bool pointsToConstantMemory(const MemoryLocation &Loc,
-                                bool OrLocal) override;
-    FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) override;
-    FunctionModRefBehavior getModRefBehavior(const Function *F) override;
-    ModRefInfo getModRefInfo(ImmutableCallSite CS,
-                             const MemoryLocation &Loc) override;
-    ModRefInfo getModRefInfo(ImmutableCallSite CS1,
-                             ImmutableCallSite CS2) override;
-  };
-}  // End of anonymous namespace
+  bool Aliases(const MDNode *A, const MDNode *B) const;
+  bool PathAliases(const MDNode *A, const MDNode *B) const;
+
+private:
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  AliasResult alias(const MemoryLocation &LocA,
+                    const MemoryLocation &LocB) override;
+  bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) override;
+  FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) override;
+  FunctionModRefBehavior getModRefBehavior(const Function *F) override;
+  ModRefInfo getModRefInfo(ImmutableCallSite CS,
+                           const MemoryLocation &Loc) override;
+  ModRefInfo getModRefInfo(ImmutableCallSite CS1,
+                           ImmutableCallSite CS2) override;
+};
+} // End of anonymous namespace
 
 // Register this pass...
 char TypeBasedAliasAnalysis::ID = 0;
 
 // Register this pass...
 char TypeBasedAliasAnalysis::ID = 0;
@@ -327,8 +325,7 @@ bool TypeBasedAliasAnalysis::doInitialization(Module &M) {
   return true;
 }
 
   return true;
 }
 
-void
-TypeBasedAliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
+void TypeBasedAliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AliasAnalysis::getAnalysisUsage(AU);
 }
   AU.setPreservesAll();
   AliasAnalysis::getAnalysisUsage(AU);
 }
@@ -344,9 +341,7 @@ static bool isStructPathTBAA(const MDNode *MD) {
 
 /// Aliases - Test whether the type represented by A may alias the
 /// type represented by B.
 
 /// Aliases - Test whether the type represented by A may alias the
 /// type represented by B.
-bool
-TypeBasedAliasAnalysis::Aliases(const MDNode *A,
-                                const MDNode *B) const {
+bool TypeBasedAliasAnalysis::Aliases(const MDNode *A, const MDNode *B) const {
   // Make sure that both MDNodes are struct-path aware.
   if (isStructPathTBAA(A) && isStructPathTBAA(B))
     return PathAliases(A, B);
   // Make sure that both MDNodes are struct-path aware.
   if (isStructPathTBAA(A) && isStructPathTBAA(B))
     return PathAliases(A, B);
@@ -355,7 +350,7 @@ TypeBasedAliasAnalysis::Aliases(const MDNode *A,
   TBAANode RootA, RootB;
 
   // Climb the tree from A to see if we reach B.
   TBAANode RootA, RootB;
 
   // Climb the tree from A to see if we reach B.
-  for (TBAANode T(A); ; ) {
+  for (TBAANode T(A);;) {
     if (T.getNode() == B)
       // B is an ancestor of A.
       return true;
     if (T.getNode() == B)
       // B is an ancestor of A.
       return true;
@@ -367,7 +362,7 @@ TypeBasedAliasAnalysis::Aliases(const MDNode *A,
   }
 
   // Climb the tree from B to see if we reach A.
   }
 
   // Climb the tree from B to see if we reach A.
-  for (TBAANode T(B); ; ) {
+  for (TBAANode T(B);;) {
     if (T.getNode() == A)
       // A is an ancestor of B.
       return true;
     if (T.getNode() == A)
       // A is an ancestor of B.
       return true;
@@ -379,7 +374,7 @@ TypeBasedAliasAnalysis::Aliases(const MDNode *A,
   }
 
   // Neither node is an ancestor of the other.
   }
 
   // Neither node is an ancestor of the other.
-  
+
   // If they have different roots, they're part of different potentially
   // unrelated type systems, so we must be conservative.
   if (RootA.getNode() != RootB.getNode())
   // If they have different roots, they're part of different potentially
   // unrelated type systems, so we must be conservative.
   if (RootA.getNode() != RootB.getNode())
@@ -391,9 +386,8 @@ TypeBasedAliasAnalysis::Aliases(const MDNode *A,
 
 /// Test whether the struct-path tag represented by A may alias the
 /// struct-path tag represented by B.
 
 /// Test whether the struct-path tag represented by A may alias the
 /// struct-path tag represented by B.
-bool
-TypeBasedAliasAnalysis::PathAliases(const MDNode *A,
-                                    const MDNode *B) const {
+bool TypeBasedAliasAnalysis::PathAliases(const MDNode *A,
+                                         const MDNode *B) const {
   // Verify that both input nodes are struct-path aware.
   assert(isStructPathTBAA(A) && "MDNode A is not struct-path aware.");
   assert(isStructPathTBAA(B) && "MDNode B is not struct-path aware.");
   // Verify that both input nodes are struct-path aware.
   assert(isStructPathTBAA(A) && "MDNode A is not struct-path aware.");
   assert(isStructPathTBAA(B) && "MDNode B is not struct-path aware.");
@@ -414,7 +408,7 @@ TypeBasedAliasAnalysis::PathAliases(const MDNode *A,
   const MDNode *BaseA = TagA.getBaseType();
   const MDNode *BaseB = TagB.getBaseType();
   uint64_t OffsetA = TagA.getOffset(), OffsetB = TagB.getOffset();
   const MDNode *BaseA = TagA.getBaseType();
   const MDNode *BaseB = TagB.getBaseType();
   uint64_t OffsetA = TagA.getOffset(), OffsetB = TagB.getOffset();
-  for (TBAAStructTypeNode T(BaseA); ; ) {
+  for (TBAAStructTypeNode T(BaseA);;) {
     if (T.getNode() == BaseB)
       // Base type of A encloses base type of B, check if the offsets match.
       return OffsetA == OffsetB;
     if (T.getNode() == BaseB)
       // Base type of A encloses base type of B, check if the offsets match.
       return OffsetA == OffsetB;
@@ -430,7 +424,7 @@ TypeBasedAliasAnalysis::PathAliases(const MDNode *A,
   // Reset OffsetA and climb the type DAG from base type of B to see if we reach
   // base type of A.
   OffsetA = TagA.getOffset();
   // Reset OffsetA and climb the type DAG from base type of B to see if we reach
   // base type of A.
   OffsetA = TagA.getOffset();
-  for (TBAAStructTypeNode T(BaseB); ; ) {
+  for (TBAAStructTypeNode T(BaseB);;) {
     if (T.getNode() == BaseA)
       // Base type of B encloses base type of A, check if the offsets match.
       return OffsetA == OffsetB;
     if (T.getNode() == BaseA)
       // Base type of B encloses base type of A, check if the offsets match.
       return OffsetA == OffsetB;
@@ -462,9 +456,11 @@ AliasResult TypeBasedAliasAnalysis::alias(const MemoryLocation &LocA,
   // Get the attached MDNodes. If either value lacks a tbaa MDNode, we must
   // be conservative.
   const MDNode *AM = LocA.AATags.TBAA;
   // Get the attached MDNodes. If either value lacks a tbaa MDNode, we must
   // be conservative.
   const MDNode *AM = LocA.AATags.TBAA;
-  if (!AM) return AliasAnalysis::alias(LocA, LocB);
+  if (!AM)
+    return AliasAnalysis::alias(LocA, LocB);
   const MDNode *BM = LocB.AATags.TBAA;
   const MDNode *BM = LocB.AATags.TBAA;
-  if (!BM) return AliasAnalysis::alias(LocA, LocB);
+  if (!BM)
+    return AliasAnalysis::alias(LocA, LocB);
 
   // If they may alias, chain to the next AliasAnalysis.
   if (Aliases(AM, BM))
 
   // If they may alias, chain to the next AliasAnalysis.
   if (Aliases(AM, BM))
@@ -480,7 +476,8 @@ bool TypeBasedAliasAnalysis::pointsToConstantMemory(const MemoryLocation &Loc,
     return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal);
 
   const MDNode *M = Loc.AATags.TBAA;
     return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal);
 
   const MDNode *M = Loc.AATags.TBAA;
-  if (!M) return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal);
+  if (!M)
+    return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal);
 
   // If this is an "immutable" type, we can assume the pointer is pointing
   // to constant memory.
 
   // If this is an "immutable" type, we can assume the pointer is pointing
   // to constant memory.
@@ -545,21 +542,26 @@ ModRefInfo TypeBasedAliasAnalysis::getModRefInfo(ImmutableCallSite CS1,
 
 bool MDNode::isTBAAVtableAccess() const {
   if (!isStructPathTBAA(this)) {
 
 bool MDNode::isTBAAVtableAccess() const {
   if (!isStructPathTBAA(this)) {
-    if (getNumOperands() < 1) return false;
+    if (getNumOperands() < 1)
+      return false;
     if (MDString *Tag1 = dyn_cast<MDString>(getOperand(0))) {
     if (MDString *Tag1 = dyn_cast<MDString>(getOperand(0))) {
-      if (Tag1->getString() == "vtable pointer") return true;
+      if (Tag1->getString() == "vtable pointer")
+        return true;
     }
     return false;
   }
 
   // For struct-path aware TBAA, we use the access type of the tag.
     }
     return false;
   }
 
   // For struct-path aware TBAA, we use the access type of the tag.
-  if (getNumOperands() < 2) return false;
+  if (getNumOperands() < 2)
+    return false;
   MDNode *Tag = cast_or_null<MDNode>(getOperand(1));
   MDNode *Tag = cast_or_null<MDNode>(getOperand(1));
-  if (!Tag) return false;
+  if (!Tag)
+    return false;
   if (MDString *Tag1 = dyn_cast<MDString>(Tag->getOperand(0))) {
   if (MDString *Tag1 = dyn_cast<MDString>(Tag->getOperand(0))) {
-    if (Tag1->getString() == "vtable pointer") return true;
+    if (Tag1->getString() == "vtable pointer")
+      return true;
   }
   }
-  return false;  
+  return false;
 }
 
 MDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) {
 }
 
 MDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) {
@@ -573,9 +575,11 @@ MDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) {
   bool StructPath = isStructPathTBAA(A) && isStructPathTBAA(B);
   if (StructPath) {
     A = cast_or_null<MDNode>(A->getOperand(1));
   bool StructPath = isStructPathTBAA(A) && isStructPathTBAA(B);
   if (StructPath) {
     A = cast_or_null<MDNode>(A->getOperand(1));
-    if (!A) return nullptr;
+    if (!A)
+      return nullptr;
     B = cast_or_null<MDNode>(B->getOperand(1));
     B = cast_or_null<MDNode>(B->getOperand(1));
-    if (!B) return nullptr;
+    if (!B)
+      return nullptr;
   }
 
   SmallSetVector<MDNode *, 4> PathA;
   }
 
   SmallSetVector<MDNode *, 4> PathA;
@@ -602,7 +606,7 @@ MDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) {
   int IB = PathB.size() - 1;
 
   MDNode *Ret = nullptr;
   int IB = PathB.size() - 1;
 
   MDNode *Ret = nullptr;
-  while (IA >= 0 && IB >=0) {
+  while (IA >= 0 && IB >= 0) {
     if (PathA[IA] == PathB[IB])
       Ret = PathA[IA];
     else
     if (PathA[IA] == PathB[IB])
       Ret = PathA[IA];
     else