Make enlarge a local function inside reserve

Author: andralex

src/dmd/backend/outbuf.d

@@ -82,46 +82,45 @@ struct Outbuffer
      */
     void reserve(size_t nbytes)
     {
-        // Keep small so it is inlined
-        if (pend - p < nbytes)
-            enlarge(nbytes);
-    }
+        pragma(inline, true);  // inline fast path
 
-    // Reserve nbytes in buffer
-    @trusted
-    private void enlarge(size_t nbytes)
-    {
-        pragma(inline, false);  // do not inline slow path
-
-        debug assert(nbytes > pend - p, "You should call this function from reserve() only.");
-
-        if (buf is null)
-        {
-            // Special-case the overwhelmingly most frequent situation
-            if (nbytes < 64) nbytes = 64;
-            p = buf = cast(ubyte*) malloc(nbytes);
-            pend = buf + nbytes;
-        }
-        else
+        // non-inline function for the heavy/infrequent reallocation case
+        @trusted static void enlarge(ref Outbuffer b, size_t nbytes)
         {
-            const size_t used = p - buf;
-            const size_t oldlen = pend - buf;
-            // Ensure exponential growth, oldlen * 2 for small sizes, oldlen * 1.5 for big sizes
-            const size_t minlen = oldlen + (oldlen >> (oldlen > 1024 * 64));
+            pragma(inline, false);  // do not inline slow path
 
-            size_t len = used + nbytes;
-            if (len < minlen)
-                len = minlen;
-            // Round up to cache line size
-            len = (len + 63) & ~63;
+            if (b.buf is null)
+            {
+                // Special-case the overwhelmingly most frequent situation
+                if (nbytes < 64) nbytes = 64;
+                b.p = b.buf = cast(ubyte*) malloc(nbytes);
+                b.pend = b.buf + nbytes;
+            }
+            else
+            {
+                const size_t used = b.p - b.buf;
+                const size_t oldlen = b.pend - b.buf;
+                // Ensure exponential growth, oldlen * 2 for small sizes, oldlen * 1.5 for big sizes
+                const size_t minlen = oldlen + (oldlen >> (oldlen > 1024 * 64));
+
+                size_t len = used + nbytes;
+                if (len < minlen)
+                    len = minlen;
+                // Round up to cache line size
+                len = (len + 63) & ~63;
 
-            buf = cast(ubyte*) realloc(buf, len);
+                b.buf = cast(ubyte*) realloc(b.buf, len);
 
-            pend = buf + len;
-            p = buf + used;
+                b.pend = b.buf + len;
+                b.p = b.buf + used;
+            }
+            if (!b.buf)
+                err_nomem();
         }
-        if (!buf)
-            err_nomem();
+
+        // Keep small so it is inlined
+        if (pend - p < nbytes)
+            enlarge(this, nbytes);
     }
 
     // Write n zeros; return pointer to start of zeros