Change the RewriteRope::Chunks data structure from an std::list into

a nice shiny B+ Tree variant.  This fixes the last of the known algorithmic
issues with the rewriter, allowing a significant speedup.  For example,
-emit-html on Ted's 500K .i file speeds up from 26.8s -> 0.64s in a 
debug build (41x!) and 5.475s -> 0.132s (41x!) in an optimized build.

This code is functional but needs to be cleaned up, ifdefs removed, better
commented, and moved to a .cpp file.  I plan to do this tomorrow.



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

include/clang/Rewrite/RewriteRope.h

@@ -18,11 +18,24 @@
 #include <list>
 #include <cstring>
 
+#include "llvm/Support/Casting.h"
+
+//#define USE_ROPE_VECTOR
+
 namespace clang {
 
 struct RopeRefCountString {
   unsigned RefCount;
   char Data[1];  //  Variable sized.
+  
+  void addRef() {
+    if (this) ++RefCount;
+  }
+  
+  void dropRef() {
+    if (this && --RefCount == 0)
+      delete [] (char*)this;
+  }
 };
   
 struct RopePiece {
@@ -30,18 +43,29 @@ struct RopePiece {
   unsigned StartOffs;
   unsigned EndOffs;
   
+  RopePiece() : StrData(0), StartOffs(0), EndOffs(0) {}
+  
   RopePiece(RopeRefCountString *Str, unsigned Start, unsigned End)
     : StrData(Str), StartOffs(Start), EndOffs(End) {
-    ++StrData->RefCount;
+    StrData->addRef();
   }
   RopePiece(const RopePiece &RP)
     : StrData(RP.StrData), StartOffs(RP.StartOffs), EndOffs(RP.EndOffs) {
-      ++StrData->RefCount;
+    StrData->addRef();
   }
 
   ~RopePiece() {
-    if (--StrData->RefCount == 0)
-      delete [] (char*)StrData;
+    StrData->dropRef();
+  }
+  
+  void operator=(const RopePiece &RHS) {
+    if (StrData != RHS.StrData) {
+      StrData->dropRef();
+      StrData = RHS.StrData;
+      StrData->addRef();
+    }
+    StartOffs = RHS.StartOffs;
+    EndOffs = RHS.EndOffs;
   }
   
   const char &operator[](unsigned Offset) const {
@@ -54,7 +78,667 @@ struct RopePiece {
   unsigned size() const { return EndOffs-StartOffs; }
 };
   
-class RewriteRope;
+  
+  
+#ifndef USE_ROPE_VECTOR
+  using llvm::dyn_cast;
+  using llvm::cast;
+
+/// This is an adapted B+ Tree, ... erases don't keep the tree balanced.
+  
+class RopePieceBTreeNode;
+struct InsertResult {
+  RopePieceBTreeNode *LHS, *RHS;
+};
+  
+class RopePieceBTreeNode {
+protected:
+  /// WidthFactor - This controls the number of K/V slots held in the BTree:
+  /// how wide it is.  Each level of the BTree is guaranteed to have at least
+  /// 'WidthFactor' elements in it (either ropepieces or children), (except the
+  /// root, which may have less) and may have at most 2*WidthFactor elements.
+  enum { WidthFactor = 8 };
+
+  /// Size - This is the number of bytes of file this node (including any
+  /// potential children) covers.
+  unsigned Size;
+  
+  /// IsLeaf - True if this is an instance of RopePieceBTreeLeaf, false if it is
+  /// an instance of RopePieceBTreeInterior.
+  bool IsLeaf;
+  
+  RopePieceBTreeNode(bool isLeaf) : IsLeaf(isLeaf) {}
+  ~RopePieceBTreeNode() {}
+public:
+  
+  bool isLeaf() const { return IsLeaf; }
+  unsigned size() const { return Size; }
+
+  void Destroy();
+
+  /// split - Split the range containing the specified offset so that we are
+  /// guaranteed that there is a place to do an insertion at the specified
+  /// offset.  The offset is relative, so "0" is the start of the node.  This
+  /// returns true if the insertion could not be done in place, and returns
+  /// information in 'Res' about the piece that is percolated up.
+  bool split(unsigned Offset, InsertResult *Res);
+  
+  /// insert - Insert the specified ropepiece into this tree node at the
+  /// specified offset.  The offset is relative, so "0" is the start of the
+  /// node.  This returns true if the insertion could not be done in place, and
+  /// returns information in 'Res' about the piece that is percolated up.
+  bool insert(unsigned Offset, const RopePiece &R, InsertResult *Res);
+
+  /// erase - Remove NumBytes from this node at the specified offset.  We are
+  /// guaranteed that there is a split at Offset.
+  void erase(unsigned Offset, unsigned NumBytes);
+  
+  static inline bool classof(const RopePieceBTreeNode *) { return true; }
+
+};
+  
+  
+
+  
+class RopePieceBTreeLeaf : public RopePieceBTreeNode {
+  /// NumPieces - This holds the number of rope pieces currently active in the
+  /// Pieces array.
+  unsigned char NumPieces;
+  
+  /// Pieces - This tracks the file chunks currently in this leaf.
+  ///
+  RopePiece Pieces[2*WidthFactor];
+  
+  /// NextLeaf - This is a pointer to the next leaf in the tree, allowing
+  /// efficient in-order forward iteration of the tree without traversal.
+  const RopePieceBTreeLeaf *NextLeaf;
+public:
+  RopePieceBTreeLeaf() : RopePieceBTreeNode(true), NextLeaf(0) {}
+ 
+  bool isFull() const { return NumPieces == 2*WidthFactor; }
+
+  /// clear - Remove all rope pieces from this leaf.
+  void clear() {
+    while (NumPieces)
+      Pieces[--NumPieces] = RopePiece();
+    Size = 0;
+  }
+  
+  unsigned getNumPieces() const { return NumPieces; }
+  
+  const RopePiece &getPiece(unsigned i) const {
+    assert(i < getNumPieces() && "Invalid piece ID");
+    return Pieces[i];
+  }
+  
+  const RopePieceBTreeLeaf *getNextLeafInOrder() const { return NextLeaf; }
+  void setNextLeafInOrder(const RopePieceBTreeLeaf *NL) { NextLeaf = NL; }
+  
+  void FullRecomputeSizeLocally() {
+    Size = 0;
+    for (unsigned i = 0, e = getNumPieces(); i != e; ++i)
+      Size += getPiece(i).size();
+  }
+  
+  /// split - Split the range containing the specified offset so that we are
+  /// guaranteed that there is a place to do an insertion at the specified
+  /// offset.  The offset is relative, so "0" is the start of the node.  This
+  /// returns true if the insertion could not be done in place, and returns
+  /// information in 'Res' about the piece that is percolated up.
+  bool split(unsigned Offset, InsertResult *Res);
+  
+  /// insert - Insert the specified ropepiece into this tree node at the
+  /// specified offset.  The offset is relative, so "0" is the start of the
+  /// node.  This returns true if the insertion could not be done in place, and
+  /// returns information in 'Res' about the piece that is percolated up.
+  bool insert(unsigned Offset, const RopePiece &R, InsertResult *Res);
+  
+  
+  /// erase - Remove NumBytes from this node at the specified offset.  We are
+  /// guaranteed that there is a split at Offset.
+  void erase(unsigned Offset, unsigned NumBytes);
+  
+  static inline bool classof(const RopePieceBTreeLeaf *) { return true; }
+  static inline bool classof(const RopePieceBTreeNode *N) {
+    return N->isLeaf();
+  }
+};
+
+/// split - Split the range containing the specified offset so that we are
+/// guaranteed that there is a place to do an insertion at the specified
+/// offset.  The offset is relative, so "0" is the start of the node.  This
+/// returns true if the insertion could not be done in place, and returns
+/// information in 'Res' about the piece that is percolated up.
+inline bool RopePieceBTreeLeaf::split(unsigned Offset, InsertResult *Res) {
+  // Find the insertion point.  We are guaranteed that there is a split at the
+  // specified offset so find it.
+  if (Offset == 0 || Offset == size()) {
+    // Fastpath for a common case.  There is already a splitpoint at the end.
+    return false;
+  }
+  
+  // Find the piece that this offset lands in.
+  unsigned PieceOffs = 0;
+  unsigned i = 0;
+  while (Offset >= PieceOffs+Pieces[i].size()) {
+    PieceOffs += Pieces[i].size();
+    ++i;
+  }
+  
+  // If there is already a split point at the specified offset, just return
+  // success.
+  if (PieceOffs == Offset)
+    return false;
+  
+  // Otherwise, we need to split piece 'i' at Offset-PieceOffs.  Convert Offset
+  // to being Piece relative.
+  unsigned IntraPieceOffset = Offset-PieceOffs;
+  
+  // We do this by shrinking the RopePiece and then doing an insert of the tail.
+  RopePiece Tail(Pieces[i].StrData, Pieces[i].StartOffs+IntraPieceOffset,
+                 Pieces[i].EndOffs);
+  Size -= Pieces[i].size();
+  Pieces[i].EndOffs = Pieces[i].StartOffs+IntraPieceOffset;
+  Size += Pieces[i].size();
+
+  return insert(Offset, Tail, Res);
+}
+  
+  
+/// insert - Insert the specified RopePiece into this tree node at the
+/// specified offset.  The offset is relative, so "0" is the start of the
+/// node.  This returns true if the insertion could not be done in place, and
+/// returns information in 'Res' about the piece that is percolated up.
+inline bool RopePieceBTreeLeaf::insert(unsigned Offset, const RopePiece &R,
+                                       InsertResult *Res) {
+  // If this node is not full, insert the piece.
+  if (!isFull()) {
+    // Find the insertion point.  We are guaranteed that there is a split at the
+    // specified offset so find it.
+    unsigned i = 0, e = getNumPieces();
+    if (Offset == size()) {
+      // Fastpath for a common case.
+      i = e;
+    } else {
+      unsigned SlotOffs = 0;
+      for (; Offset > SlotOffs; ++i)
+        SlotOffs += getPiece(i).size();
+      assert(SlotOffs == Offset && "Split didn't occur before insertion!");
+    }
+    
+    // For an insertion into a non-full leaf node, just insert the value in
+    // its sorted position.  This requires moving later values over.
+    for (; i != e; --e)
+      Pieces[e] = Pieces[e-1];
+    Pieces[i] = R;
+    ++NumPieces;
+    Size += R.size();
+    return false;
+  }
+  
+  // Otherwise, if this is leaf is full, split it in two halves.  Since this
+  // node is full, it contains 2*WidthFactor values.  We move the first
+  // 'WidthFactor' values to the LHS child (which we leave in this node) and
+  // move the last 'WidthFactor' values into the RHS child.
+  
+  // Create the new node.
+  RopePieceBTreeLeaf *NewNode = new RopePieceBTreeLeaf();
+
+  // Move over the last 'WidthFactor' values from here to NewNode.
+  std::copy(&Pieces[WidthFactor], &Pieces[2*WidthFactor],
+            &NewNode->Pieces[0]);
+  // Replace old pieces with null RopePieces to drop refcounts.
+  std::fill(&Pieces[WidthFactor], &Pieces[2*WidthFactor], RopePiece());
+  
+  // Decrease the number of values in the two nodes.
+  NewNode->NumPieces = NumPieces = WidthFactor;
+  
+  // Recompute the two nodes' size.
+  NewNode->FullRecomputeSizeLocally();
+  FullRecomputeSizeLocally();
+  
+  // Update the list of leaves.
+  NewNode->setNextLeafInOrder(this->getNextLeafInOrder());
+  this->setNextLeafInOrder(NewNode);
+  
+  assert(Res && "No result location specified");
+  Res->LHS = this;
+  Res->RHS = NewNode;
+  
+  if (this->size() >= Offset)
+    this->insert(Offset, R, 0 /*can't fail*/);
+  else
+    NewNode->insert(Offset - this->size(), R, 0 /*can't fail*/);
+  return true;
+}
+  
+/// erase - Remove NumBytes from this node at the specified offset.  We are
+/// guaranteed that there is a split at Offset.
+inline void RopePieceBTreeLeaf::erase(unsigned Offset, unsigned NumBytes) {
+  // Since we are guaranteed that there is a split at Offset, we start by
+  // finding the Piece that starts there.
+  unsigned PieceOffs = 0;
+  unsigned i = 0;
+  for (; Offset > PieceOffs; ++i)
+    PieceOffs += getPiece(i).size();
+  assert(PieceOffs == Offset && "Split didn't occur before erase!");
+  
+  unsigned StartPiece = i;
+  
+  // Figure out how many pieces completely cover 'NumBytes'.  We want to remove
+  // all of them.
+  for (; Offset+NumBytes > PieceOffs+getPiece(i).size(); ++i)
+    PieceOffs += getPiece(i).size();
+
+  // If we exactly include the last one, include it in the region to delete.
+  if (Offset+NumBytes == PieceOffs+getPiece(i).size())
+    PieceOffs += getPiece(i).size(), ++i;
+  
+  // If we completely cover some RopePieces, erase them now.
+  if (i != StartPiece) {
+    unsigned NumDeleted = i-StartPiece;
+    for (; i != getNumPieces(); ++i)
+      Pieces[i-NumDeleted] = Pieces[i];
+    
+    // Drop references to dead rope pieces.
+    std::fill(&Pieces[getNumPieces()-NumDeleted], &Pieces[getNumPieces()],
+              RopePiece());
+    NumPieces -= NumDeleted;
+    
+    unsigned CoverBytes = PieceOffs-Offset;
+    NumBytes -= CoverBytes;
+    Size -= CoverBytes;
+  }
+
+  // If we completely removed some stuff, we could be done.
+  if (NumBytes == 0) return;
+  
+  // Okay, now might be erasing part of some Piece.  If this is the case, then
+  // move the start point of the piece.
+  assert(getPiece(StartPiece).size() > NumBytes);
+  Pieces[StartPiece].StartOffs += NumBytes;
+  
+  // The size of this node just shrunk by NumBytes.
+  Size -= NumBytes;
+}
+  
+// Holds up to 2*WidthFactor children.
+class RopePieceBTreeInterior : public RopePieceBTreeNode {
+  /// NumChildren - This holds the number of children currently active in the
+  /// Children array.
+  unsigned char NumChildren;
+  RopePieceBTreeNode *Children[2*WidthFactor];
+public:
+  RopePieceBTreeInterior() : RopePieceBTreeNode(false) {}
+
+  RopePieceBTreeInterior(RopePieceBTreeNode *LHS, RopePieceBTreeNode *RHS)
+    : RopePieceBTreeNode(false) {
+    Children[0] = LHS;
+    Children[1] = RHS;
+    NumChildren = 2;
+    Size = LHS->size() + RHS->size();
+  }
+
+  bool isFull() const { return NumChildren == 2*WidthFactor; }
+
+  unsigned getNumChildren() const { return NumChildren; }
+  const RopePieceBTreeNode *getChild(unsigned i) const {
+    assert(i < NumChildren && "invalid child #");
+    return Children[i];
+  }
+  RopePieceBTreeNode *getChild(unsigned i) {
+    assert(i < NumChildren && "invalid child #");
+    return Children[i];
+  }
+  
+  void FullRecomputeSizeLocally() {
+    Size = 0;
+    for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
+      Size += getChild(i)->size();
+  }
+  
+  
+  /// split - Split the range containing the specified offset so that we are
+  /// guaranteed that there is a place to do an insertion at the specified
+  /// offset.  The offset is relative, so "0" is the start of the node.  This
+  /// returns true if the insertion could not be done in place, and returns
+  /// information in 'Res' about the piece that is percolated up.
+  bool split(unsigned Offset, InsertResult *Res);
+  
+  
+  /// insert - Insert the specified ropepiece into this tree node at the
+  /// specified offset.  The offset is relative, so "0" is the start of the
+  /// node.  This returns true if the insertion could not be done in place, and
+  /// returns information in 'Res' about the piece that is percolated up.
+  bool insert(unsigned Offset, const RopePiece &R, InsertResult *Res);
+  
+  /// HandleChildPiece - A child propagated an insertion result up to us.
+  /// Insert the new child, and/or propagate the result further up the tree.
+  bool HandleChildPiece(unsigned i, InsertResult &Res);
+  
+  /// erase - Remove NumBytes from this node at the specified offset.  We are
+  /// guaranteed that there is a split at Offset.
+  void erase(unsigned Offset, unsigned NumBytes);
+  
+  static inline bool classof(const RopePieceBTreeInterior *) { return true; }
+  static inline bool classof(const RopePieceBTreeNode *N) {
+    return !N->isLeaf(); 
+  }
+};
+  
+/// split - Split the range containing the specified offset so that we are
+/// guaranteed that there is a place to do an insertion at the specified
+/// offset.  The offset is relative, so "0" is the start of the node.  This
+/// returns true if the insertion could not be done in place, and returns
+/// information in 'Res' about the piece that is percolated up.
+inline bool RopePieceBTreeInterior::split(unsigned Offset, InsertResult *Res) {
+  // Figure out which child to split.
+  if (Offset == 0 || Offset == size())
+    return false;  // If we have an exact offset, we're already split.
+
+  unsigned ChildOffset = 0;
+  unsigned i = 0;
+  for (; Offset >= ChildOffset+getChild(i)->size(); ++i)
+    ChildOffset += getChild(i)->size();
+  
+  // If already split there, we're done.
+  if (ChildOffset == Offset)
+    return false;
+  
+  // Otherwise, recursively split the child.
+  if (getChild(i)->split(Offset-ChildOffset, Res)) 
+    return HandleChildPiece(i, *Res);
+  return false;  // Done!
+}
+  
+/// insert - Insert the specified ropepiece into this tree node at the
+/// specified offset.  The offset is relative, so "0" is the start of the
+/// node.  This returns true if the insertion could not be done in place, and
+/// returns information in 'Res' about the piece that is percolated up.
+inline bool RopePieceBTreeInterior::insert(unsigned Offset, const RopePiece &R,
+                                           InsertResult *Res) {
+  // Find the insertion point.  We are guaranteed that there is a split at the
+  // specified offset so find it.
+  unsigned i = 0, e = getNumChildren();
+  
+  unsigned ChildOffs = 0;
+  if (Offset == size()) {
+    // Fastpath for a common case.  Insert at end of last child.
+    i = e-1;
+    ChildOffs = size()-getChild(i)->size();
+  } else {
+    for (; Offset > ChildOffs+getChild(i)->size(); ++i)
+      ChildOffs += getChild(i)->size();
+  }
+  
+  Size += R.size();
+
+  // Insert at the end of this child.
+  if (getChild(i)->insert(Offset-ChildOffs, R, Res))
+    return HandleChildPiece(i, *Res);
+  
+  return false;
+}
+  
+/// HandleChildPiece - A child propagated an insertion result up to us.
+/// Insert the new child, and/or propagate the result further up the tree.
+inline bool RopePieceBTreeInterior::HandleChildPiece(unsigned i, 
+                                                     InsertResult &Res) {
+  // Otherwise the child propagated a subtree up to us as a new child.  See if
+  // we have space for it here.
+  if (!isFull()) {
+    // Replace child 'i' with the two children specified in Res.
+    if (i + 1 != getNumChildren())
+      memmove(&Children[i+2], &Children[i+1],
+              (getNumChildren()-i-1)*sizeof(Children[0]));
+    Children[i] = Res.LHS;
+    Children[i+1] = Res.RHS;
+    ++NumChildren;
+    return false;
+  }
+  
+  // Okay, this node is full.  Split it in half, moving WidthFactor children to
+  // a newly allocated interior node.
+  
+  // Create the new node.
+  RopePieceBTreeInterior *NewNode = new RopePieceBTreeInterior();
+  
+  // Move over the last 'WidthFactor' values from here to NewNode.
+  memcpy(&NewNode->Children[0], &Children[WidthFactor],
+         WidthFactor*sizeof(Children[0]));
+  
+  // Decrease the number of values in the two nodes.
+  NewNode->NumChildren = NumChildren = WidthFactor;
+  
+  // Finally, insert the two new children in the side the can (now) hold them.
+  if (i < WidthFactor)
+    this->HandleChildPiece(i, Res);
+  else
+    NewNode->HandleChildPiece(i-WidthFactor, Res);
+  
+  // Recompute the two nodes' size.
+  NewNode->FullRecomputeSizeLocally();
+  FullRecomputeSizeLocally();
+  
+  Res.LHS = this;
+  Res.RHS = NewNode;
+  return true;
+}
+
+/// erase - Remove NumBytes from this node at the specified offset.  We are
+/// guaranteed that there is a split at Offset.
+inline void RopePieceBTreeInterior::erase(unsigned Offset, unsigned NumBytes) {
+  // This will shrink this node by NumBytes.
+  Size -= NumBytes;
+  
+  // Find the first child that overlaps with Offset.
+  unsigned i = 0;
+  for (; Offset >= getChild(i)->size(); ++i)
+    Offset -= getChild(i)->size();
+  
+  // Propagate the delete request into overlapping children, or completely
+  // delete the children as appropriate.
+  while (NumBytes) {
+    RopePieceBTreeNode *CurChild = getChild(i);
+
+    // If we are deleting something contained entirely in the child, pass on the
+    // request.
+    if (Offset+NumBytes < CurChild->size()) {
+      CurChild->erase(Offset, NumBytes);
+      return;
+    }
+    
+    // If this deletion request starts somewhere in the middle of the child, it
+    // must be deleting to the end of the child.
+    if (Offset) {
+      unsigned BytesFromChild = CurChild->size()-Offset;
+      CurChild->erase(Offset, BytesFromChild);
+      NumBytes -= BytesFromChild;
+      ++i;
+      continue;
+    }
+    
+    // If the deletion request completely covers the child, delete it and move
+    // the rest down.
+    NumBytes -= CurChild->size();
+    CurChild->Destroy();
+    --NumChildren;
+    if (i+1 != getNumChildren())
+      memmove(&Children[i], &Children[i+1],
+              (getNumChildren()-i)*sizeof(Children[0]));
+  }
+}
+  
+inline void RopePieceBTreeNode::Destroy() {
+  if (RopePieceBTreeLeaf *Leaf = dyn_cast<RopePieceBTreeLeaf>(this))
+    delete Leaf;
+  else
+    delete cast<RopePieceBTreeInterior>(this);
+}
+
+/// split - Split the range containing the specified offset so that we are
+/// guaranteed that there is a place to do an insertion at the specified
+/// offset.  The offset is relative, so "0" is the start of the node.  This
+/// returns true if the insertion could not be done in place, and returns
+/// information in 'Res' about the piece that is percolated up.
+inline bool RopePieceBTreeNode::split(unsigned Offset, InsertResult *Res) {
+  assert(Offset <= size() && "Invalid offset to split!");
+  if (RopePieceBTreeLeaf *Leaf = dyn_cast<RopePieceBTreeLeaf>(this))
+    return Leaf->split(Offset, Res);
+  return cast<RopePieceBTreeInterior>(this)->split(Offset, Res);
+}
+  
+/// insert - Insert the specified ropepiece into this tree node at the
+/// specified offset.  The offset is relative, so "0" is the start of the
+/// node.
+inline bool RopePieceBTreeNode::insert(unsigned Offset, const RopePiece &R,
+                                       InsertResult *Res) {
+  assert(Offset <= size() && "Invalid offset to insert!");
+  if (RopePieceBTreeLeaf *Leaf = dyn_cast<RopePieceBTreeLeaf>(this))
+    return Leaf->insert(Offset, R, Res);
+  return cast<RopePieceBTreeInterior>(this)->insert(Offset, R, Res);
+}
+  
+/// erase - Remove NumBytes from this node at the specified offset.  We are
+/// guaranteed that there is a split at Offset.
+inline void RopePieceBTreeNode::erase(unsigned Offset, unsigned NumBytes) {
+  assert(Offset+NumBytes <= size() && "Invalid offset to erase!");
+  if (RopePieceBTreeLeaf *Leaf = dyn_cast<RopePieceBTreeLeaf>(this))
+    return Leaf->erase(Offset, NumBytes);
+  return cast<RopePieceBTreeInterior>(this)->erase(Offset, NumBytes);
+}
+  
+  
+  
+/// RewritePieceBTreeIterator - Provide read-only forward iteration.
+class RewritePieceBTreeIterator :
+    public forward_iterator<const char, ptrdiff_t> {
+  /// CurNode - The current B+Tree node that we are inspecting.
+  const RopePieceBTreeLeaf *CurNode;
+  /// CurPiece - The current RopePiece in the B+Tree node that we're inspecting.
+  const RopePiece *CurPiece;
+  /// CurChar - The current byte in the RopePiece we are pointing to.
+  unsigned CurChar;
+  friend class RewriteRope;
+public:
+  RewritePieceBTreeIterator(const RopePieceBTreeNode *N) {  // begin iterator.
+    // Walk down the left side of the tree until we get to a leaf.
+    while (const RopePieceBTreeInterior *IN = 
+               dyn_cast<RopePieceBTreeInterior>(N))
+      N = IN->getChild(0);
+    
+    // We must have at least one leaf.
+    CurNode = cast<RopePieceBTreeLeaf>(N);
+    
+    // If we found a leaf that happens to be empty, skip over it until we get to
+    // something full.
+    while (CurNode && CurNode->getNumPieces() == 0)
+      CurNode = CurNode->getNextLeafInOrder();
+      
+    if (CurNode != 0)
+      CurPiece = &CurNode->getPiece(0);
+    else  // Empty tree, this is an end() iterator.
+      CurPiece = 0;
+    CurChar = 0;
+  }
+  // end iterator
+  RewritePieceBTreeIterator() : CurNode(0), CurPiece(0), CurChar(0) {}
+  
+  const char operator*() const {
+    return (*CurPiece)[CurChar];
+  }
+  
+  bool operator==(const RewritePieceBTreeIterator &RHS) const {
+    return CurPiece == RHS.CurPiece && CurChar == RHS.CurChar;
+  }
+  bool operator!=(const RewritePieceBTreeIterator &RHS) const {
+    return !operator==(RHS);
+  }
+  
+  inline RewritePieceBTreeIterator& operator++() {   // Preincrement
+    if (CurChar+1 < CurPiece->size())
+      ++CurChar;
+    else if (CurPiece != &CurNode->getPiece(CurNode->getNumPieces()-1)) {
+      CurChar = 0;
+      ++CurPiece;
+    } else {
+      // Find the next non-empty leaf node.
+      do
+        CurNode = CurNode->getNextLeafInOrder();
+      while (CurNode && CurNode->getNumPieces() == 0);
+
+      if (CurNode != 0)
+        CurPiece = &CurNode->getPiece(0);
+      else // Hit end().
+        CurPiece = 0;
+      CurChar = 0;
+    }
+    return *this;
+  }
+  
+  inline RewritePieceBTreeIterator operator++(int) { // Postincrement
+    RewritePieceBTreeIterator tmp = *this; ++*this; return tmp;
+  }
+};
+  
+  
+class RopePieceBTree {
+  RopePieceBTreeNode *Root;
+  void operator=(const RopePieceBTree &); // DO NOT IMPLEMENT
+public:
+  RopePieceBTree() {
+    Root = new RopePieceBTreeLeaf();
+  }
+  RopePieceBTree(const RopePieceBTree &RHS) {
+    assert(RHS.empty() && "Can't copy non-empty tree yet");
+    Root = new RopePieceBTreeLeaf();
+  }
+  ~RopePieceBTree() {
+    Root->Destroy();
+  }
+  
+  typedef RewritePieceBTreeIterator iterator;
+  iterator begin() const { return iterator(Root); }
+  iterator end() const { return iterator(); }
+  unsigned size() const { return Root->size(); }
+  unsigned empty() const { return size() == 0; }
+  
+  void clear() {
+    if (RopePieceBTreeLeaf *Leaf = dyn_cast<RopePieceBTreeLeaf>(Root))
+      Leaf->clear();
+    else {
+      Root->Destroy();
+      Root = new RopePieceBTreeLeaf();
+    }
+  }
+  
+  void insert(unsigned Offset, const RopePiece &R) {
+    InsertResult Result;
+    // #1. Split at Offset.
+    if (Root->split(Offset, &Result))
+      Root = new RopePieceBTreeInterior(Result.LHS, Result.RHS);
+    
+    // #2. Do the insertion.
+    if (Root->insert(Offset, R, &Result))
+      Root = new RopePieceBTreeInterior(Result.LHS, Result.RHS);
+  }
+
+  void erase(unsigned Offset, unsigned NumBytes) {
+    InsertResult Result;
+    // #1. Split at Offset.
+    if (Root->split(Offset, &Result))
+      Root = new RopePieceBTreeInterior(Result.LHS, Result.RHS);
+    
+    // #2. Do the erasing.
+    Root->erase(Offset, NumBytes);
+  }
+};
+
+  
+#endif // ifndef USE_ROPE_VECTOR
+  
+#ifdef USE_ROPE_VECTOR
+  class RewriteRope;
   
 template <typename CharType, typename PieceIterType>
 class RewriteRopeIterator : 
@@ -105,15 +789,19 @@ public:
     RewriteRopeIterator tmp = *this; ++*this; return tmp;
   }
 };
-
+#endif
   
   
 /// RewriteRope - A powerful string class, todo generalize this.
 class RewriteRope {
+#ifdef USE_ROPE_VECTOR
   // FIXME: This could be significantly faster by using a balanced binary tree
   // instead of a list.
   std::list<RopePiece> Chunks;
   unsigned CurSize;
+#else
+  RopePieceBTree Chunks;
+#endif
   
   /// We allocate space for string data out of a buffer of size AllocChunkSize.
   /// This keeps track of how much space is left.
@@ -122,9 +810,24 @@ class RewriteRope {
   enum { AllocChunkSize = 4080 };
   
 public:
-  RewriteRope() : CurSize(0), AllocBuffer(0), AllocOffs(AllocChunkSize) {}
-  ~RewriteRope() { clear(); }
+  RewriteRope() : 
+#ifdef USE_ROPE_VECTOR
+  CurSize(0), 
+#endif
+                   AllocBuffer(0), AllocOffs(AllocChunkSize) {}
+  RewriteRope(const RewriteRope &RHS) : Chunks(RHS.Chunks),
+#ifdef USE_ROPE_VECTOR
+  CurSize(RHS.CurSize), 
+#endif
+    AllocBuffer(0), AllocOffs(AllocChunkSize) {
+  }
 
+  ~RewriteRope() {
+    // If we had an allocation buffer, drop our reference to it.
+    AllocBuffer->dropRef();
+  }
+  
+#ifdef USE_ROPE_VECTOR
   typedef RewriteRopeIterator<char, std::list<RopePiece>::iterator> iterator;
   typedef RewriteRopeIterator<const char, 
                            std::list<RopePiece>::const_iterator> const_iterator;
@@ -135,12 +838,39 @@ public:
   const_iterator end() const { return const_iterator(Chunks.end(), 0); }
   
   unsigned size() const { return CurSize; }
+#else
+  typedef RopePieceBTree::iterator iterator;
+  typedef RopePieceBTree::iterator const_iterator;
+  iterator begin() const { return Chunks.begin(); }
+  iterator end() const  { return Chunks.end(); }
+  unsigned size() const { return Chunks.size(); }
+#endif
   
   void clear() {
     Chunks.clear();
-    CurSize = 0;
+#ifdef USE_ROPE_VECTOR
+   CurSize = 0;
+#endif
   }
   
+#ifndef USE_ROPE_VECTOR
+  void assign(const char *Start, const char *End) {
+    clear();
+    Chunks.insert(0, MakeRopeString(Start, End));
+  }
+  
+  void insert(unsigned Offset, const char *Start, const char *End) {
+    if (Start == End) return;
+    Chunks.insert(Offset, MakeRopeString(Start, End));
+  }
+
+  void erase(unsigned Offset, unsigned NumBytes) {
+    if (NumBytes == 0) return;
+    Chunks.erase(Offset, NumBytes);
+  }
+#endif
+
+#ifdef USE_ROPE_VECTOR
   void assign(const char *Start, const char *End) {
     clear();
     Chunks.push_back(MakeRopeString(Start, End));
@@ -236,6 +966,7 @@ public:
       CurSize -= End.CurChar;
     }
   }
+#endif
 
 private:
   RopePiece MakeRopeString(const char *Start, const char *End) {
@@ -261,14 +992,25 @@ private:
     
     // Otherwise, this was a small request but we just don't have space for it
     // Make a new chunk and share it with later allocations.
+    
+    // If we had an old allocation, drop our reference to it.
+    if (AllocBuffer && --AllocBuffer->RefCount == 0)
+      delete [] (char*)AllocBuffer;
+    
     unsigned AllocSize = sizeof(RopeRefCountString)-1+AllocChunkSize;
     AllocBuffer = reinterpret_cast<RopeRefCountString *>(new char[AllocSize]);
     AllocBuffer->RefCount = 0;
     memcpy(AllocBuffer->Data, Start, Len);
     AllocOffs = Len;
+    
+    // Start out the new allocation with a refcount of 1, since we have an
+    // internal reference to it.
+    AllocBuffer->addRef();
     return RopePiece(AllocBuffer, 0, Len);
   }
   
+#ifdef USE_ROPE_VECTOR
+
   /// SplitAt - If the specified iterator position has a non-zero character
   /// number, split the specified buffer up.  This guarantees that the specified
   /// iterator is at the start of a chunk.  Return the chunk it is at the start
@@ -293,6 +1035,7 @@ private:
     // Return the old chunk, which is the suffix.
     return Chunk;
   }
+#endif
 };
   
 } // end namespace clang

lib/Rewrite/DeltaTree.cpp

@@ -58,10 +58,12 @@ namespace {
 } // end anonymous namespace
 
 
-struct InsertResult {
-  DeltaTreeNode *LHS, *RHS;
-  SourceDelta Split;
-};
+namespace {
+  struct InsertResult {
+    DeltaTreeNode *LHS, *RHS;
+    SourceDelta Split;
+  };
+} // end anonymous namespace
 
 
 namespace {
@@ -72,8 +74,8 @@ namespace {
     
     /// WidthFactor - This controls the number of K/V slots held in the BTree:
     /// how wide it is.  Each level of the BTree is guaranteed to have at least
-    /// WidthFactor-1 K/V pairs (unless the whole tree is less full than that)
-    /// and may have at most 2*WidthFactor-1 K/V pairs.
+    /// WidthFactor-1 K/V pairs (except the root) and may have at most
+    /// 2*WidthFactor-1 K/V pairs.
     enum { WidthFactor = 8 };
     
     /// Values - This tracks the SourceDelta's currently in this node.

lib/Rewrite/Rewriter.cpp

@@ -27,8 +27,12 @@ void RewriteBuffer::RemoveText(unsigned OrigOffset, unsigned Size) {
   assert(RealOffset+Size < Buffer.size() && "Invalid location");
   
   // Remove the dead characters.
+#ifdef USE_ROPE_VECTOR
   RewriteRope::iterator I = Buffer.getAtOffset(RealOffset);
   Buffer.erase(I, I+Size);
+#else
+  Buffer.erase(RealOffset, Size);
+#endif
 
   // Add a delta so that future changes are offset correctly.
   AddDelta(OrigOffset, -Size);
@@ -42,21 +46,27 @@ void RewriteBuffer::InsertText(unsigned OrigOffset,
   if (StrLen == 0) return;
 
   unsigned RealOffset = getMappedOffset(OrigOffset, InsertAfter);
+
+#ifdef USE_ROPE_VECTOR
   assert(RealOffset <= Buffer.size() && "Invalid location");
 
   // Insert the new characters.
   Buffer.insert(Buffer.getAtOffset(RealOffset), StrData, StrData+StrLen);
+#else
+  Buffer.insert(RealOffset, StrData, StrData+StrLen);
+#endif
   
   // Add a delta so that future changes are offset correctly.
   AddDelta(OrigOffset, StrLen);
 }
 
 /// ReplaceText - This method replaces a range of characters in the input
-/// buffer with a new string.  This is effectively a combined "remove/insert"
+/// buffer with a new string.  This is effectively a combined "remove+insert"
 /// operation.
 void RewriteBuffer::ReplaceText(unsigned OrigOffset, unsigned OrigLength,
                                 const char *NewStr, unsigned NewLength) {
   unsigned RealOffset = getMappedOffset(OrigOffset, true);
+#ifdef USE_ROPE_VECTOR
   assert(RealOffset+OrigLength <= Buffer.size() && "Invalid location");
 
   // Overwrite the common piece.
@@ -76,7 +86,12 @@ void RewriteBuffer::ReplaceText(unsigned OrigOffset, unsigned OrigLength,
     RewriteRope::iterator I = Buffer.getAtOffset(RealOffset+NewLength);
     Buffer.erase(I, I+(OrigLength-NewLength));
   }
-  AddDelta(OrigOffset, NewLength-OrigLength);
+#else
+  Buffer.erase(RealOffset, OrigLength);
+  Buffer.insert(RealOffset, NewStr, NewStr+NewLength);
+#endif
+  if (OrigLength != NewLength)
+    AddDelta(OrigOffset, NewLength-OrigLength);
 }