diff -r de982d8b7b15 Lib/copyreg.py
--- a/Lib/copyreg.py	Tue Oct 13 21:26:35 2015 +0300
+++ b/Lib/copyreg.py	Wed Oct 14 13:06:22 2015 +0300
@@ -82,6 +82,18 @@ def _reduce_ex(self, proto):
     else:
         return _reconstructor, args
 
+# Helpers for pickling large str and bytes objects with protocols <4.
+
+def _chunks(data, size):
+    for i in range(0, len(data), size):
+        yield data[i: i + size]
+
+def _reduce_large_str(data):
+    return ''.join, (list(_chunks(data, 0x7fffffff//4)),)
+
+def _reduce_large_bytes(data):
+    return b''.join, (list(_chunks(data, 0xffffffff)),)
+
 # Helper for __reduce_ex__ protocol 2
 
 def __newobj__(cls, *args):
diff -r de982d8b7b15 Lib/pickle.py
--- a/Lib/pickle.py	Tue Oct 13 21:26:35 2015 +0300
+++ b/Lib/pickle.py	Wed Oct 14 13:06:22 2015 +0300
@@ -25,7 +25,8 @@ Misc variables:
 
 from types import FunctionType
 from copyreg import dispatch_table
-from copyreg import _extension_registry, _inverted_registry, _extension_cache
+from copyreg import (_extension_registry, _inverted_registry, _extension_cache,
+                     _reduce_large_str, _reduce_large_bytes)
 from itertools import islice
 from functools import partial
 import sys
@@ -691,10 +692,13 @@ class _Pickler:
         n = len(obj)
         if n <= 0xff:
             self.write(SHORT_BINBYTES + pack("<B", n) + obj)
-        elif n > 0xffffffff and self.proto >= 4:
+        elif n <= 0xffffffff:
+            self.write(BINBYTES + pack("<I", n) + obj)
+        elif self.proto >= 4:
             self.write(BINBYTES8 + pack("<Q", n) + obj)
         else:
-            self.write(BINBYTES + pack("<I", n) + obj)
+            self.save_reduce(*_reduce_large_bytes(obj), obj=obj)
+            return
         self.memoize(obj)
     dispatch[bytes] = save_bytes
 
@@ -704,10 +708,13 @@ class _Pickler:
             n = len(encoded)
             if n <= 0xff and self.proto >= 4:
                 self.write(SHORT_BINUNICODE + pack("<B", n) + encoded)
-            elif n > 0xffffffff and self.proto >= 4:
+            elif n <= 0x7fffffff or self.proto >= 3 and n <= 0xffffffff:
+                self.write(BINUNICODE + pack("<I", n) + encoded)
+            elif self.proto >= 4:
                 self.write(BINUNICODE8 + pack("<Q", n) + encoded)
             else:
-                self.write(BINUNICODE + pack("<I", n) + encoded)
+                self.save_reduce(*_reduce_large_str(obj), obj=obj)
+                return
         else:
             obj = obj.replace("\\", "\\u005c")
             obj = obj.replace("\n", "\\u000a")
diff -r de982d8b7b15 Lib/test/pickletester.py
--- a/Lib/test/pickletester.py	Tue Oct 13 21:26:35 2015 +0300
+++ b/Lib/test/pickletester.py	Wed Oct 14 13:06:22 2015 +0300
@@ -2001,6 +2001,20 @@ class AbstractPickleTests(unittest.TestC
 
 class BigmemPickleTests(unittest.TestCase):
 
+    def index(self, string, needle, start=None, end=None):
+        try:
+            return string.index(needle, start, end)
+        except ValueError:
+            self.fail('Substring %r not found in %r' %
+                      (needle, string[start: end]))
+
+    def rindex(self, string, needle, start=None, end=None):
+        try:
+            return string.rindex(needle, start, end)
+        except ValueError:
+            self.fail('Substring %r not found in %r' %
+                      (needle, string[start: end]))
+
     # Binary protocols can serialize longs of up to 2GB-1
 
     @bigmemtest(size=_2G, memuse=3.6, dry_run=False)
@@ -2030,12 +2044,13 @@ class BigmemPickleTests(unittest.TestCas
                 with self.subTest(proto=proto):
                     try:
                         pickled = self.dumps(data, protocol=proto)
-                        header = (pickle.BINBYTES +
-                                  struct.pack("<I", len(data)))
-                        data_start = pickled.index(data)
+                        data_start = self.index(pickled, b'abcd', 0, 100)
+                        data_end = (self.rindex(pickled, b'abcd', -100) +
+                                    len(b'abcd'))
                         self.assertEqual(
-                            header,
-                            pickled[data_start-len(header):data_start])
+                            pickled[data_start-5: data_start],
+                            pickle.BINBYTES + struct.pack("<I", len(data)))
+                        self.assertEqual(data_end - data_start, len(data))
                     finally:
                         pickled = None
         finally:
@@ -2043,26 +2058,31 @@ class BigmemPickleTests(unittest.TestCas
 
     @bigmemtest(size=_4G, memuse=2.5, dry_run=False)
     def test_huge_bytes_64b(self, size):
-        data = b"acbd" * (size // 4)
+        data = b"abcd" * (size // 4)
         try:
             for proto in protocols:
                 if proto < 3:
                     continue
                 with self.subTest(proto=proto):
-                    if proto == 3:
-                        # Protocol 3 does not support large bytes objects.
-                        # Verify that we do not crash when processing one.
-                        with self.assertRaises((ValueError, OverflowError)):
-                            self.dumps(data, protocol=proto)
-                        continue
                     try:
                         pickled = self.dumps(data, protocol=proto)
-                        header = (pickle.BINBYTES8 +
-                                  struct.pack("<Q", len(data)))
-                        data_start = pickled.index(data)
-                        self.assertEqual(
-                            header,
-                            pickled[data_start-len(header):data_start])
+                        data_start = self.index(pickled, b'abcd', 0, 100)
+                        data_end = (self.rindex(pickled, b'abcd', -100) +
+                                    len(b'abcd'))
+                        if proto < 4:
+                            self.assertEqual(
+                                pickled[data_start-5: data_start-4],
+                                pickle.BINBYTES)
+                            self.assertIn(b'join', pickled[:data_start])
+                            self.assertGreater(data_end - data_start, len(data))
+                            self.assertLess(data_end - data_start,
+                                            len(data) + 1000)
+                            self.assertIn(pickle.REDUCE, pickled[:data_start])
+                        else:
+                            self.assertEqual(
+                                pickled[data_start-9: data_start],
+                                pickle.BINBYTES8 + struct.pack("<Q", len(data)))
+                            self.assertEqual(data_end - data_start, len(data))
                     finally:
                         pickled = None
         finally:
@@ -2081,20 +2101,30 @@ class BigmemPickleTests(unittest.TestCas
                 with self.subTest(proto=proto):
                     try:
                         pickled = self.dumps(data, protocol=proto)
-                        header = (pickle.BINUNICODE +
-                                  struct.pack("<I", len(data)))
-                        data_start = pickled.index(b'abcd')
-                        self.assertEqual(
-                            header,
-                            pickled[data_start-len(header):data_start])
-                        self.assertEqual((pickled.rindex(b"abcd") + len(b"abcd") -
-                                          pickled.index(b"abcd")), len(data))
+                        data_start = self.index(pickled, b'abcd', 0, 100)
+                        data_end = (self.rindex(pickled, b'abcd', -100) +
+                                    len(b'abcd'))
+                        if proto < 3:
+                            self.assertEqual(
+                                pickled[data_start-5: data_start-4],
+                                pickle.BINUNICODE)
+                            self.assertIn(b'join', pickled[:data_start])
+                            self.assertGreater(data_end - data_start, len(data))
+                            self.assertLess(data_end - data_start,
+                                            len(data) + 1000)
+                            self.assertIn(pickle.REDUCE, pickled[:data_start])
+                        else:
+                            self.assertEqual(
+                                pickled[data_start-5: data_start],
+                                pickle.BINUNICODE + struct.pack("<I", len(data)))
+                            self.assertEqual(data_end - data_start, len(data))
                     finally:
                         pickled = None
         finally:
             data = None
 
-    # BINUNICODE (protocols 1, 2 and 3) cannot carry more than 2**32 - 1 bytes
+    # BINUNICODE (protocols 1, 2 and 3) cannot carry more than 2**31 - 1
+    # (protocols 1 and 2) or 2**32 - 1 (protocol 3) bytes
     # of utf-8 encoded unicode. BINUNICODE8 (protocol 4) supports these huge
     # unicode strings however.
 
@@ -2106,20 +2136,25 @@ class BigmemPickleTests(unittest.TestCas
                 if proto == 0:
                     continue
                 with self.subTest(proto=proto):
-                    if proto < 4:
-                        with self.assertRaises((ValueError, OverflowError)):
-                            self.dumps(data, protocol=proto)
-                        continue
                     try:
                         pickled = self.dumps(data, protocol=proto)
-                        header = (pickle.BINUNICODE8 +
-                                  struct.pack("<Q", len(data)))
-                        data_start = pickled.index(b'abcd')
-                        self.assertEqual(
-                            header,
-                            pickled[data_start-len(header):data_start])
-                        self.assertEqual((pickled.rindex(b"abcd") + len(b"abcd") -
-                                          pickled.index(b"abcd")), len(data))
+                        data_start = self.index(pickled, b'abcd', 0, 100)
+                        data_end = (self.rindex(pickled, b'abcd', -100) +
+                                    len(b'abcd'))
+                        if proto < 4:
+                            self.assertEqual(
+                                pickled[data_start-5: data_start-4],
+                                pickle.BINUNICODE)
+                            self.assertIn(b'join', pickled[:data_start])
+                            self.assertGreater(data_end - data_start, len(data))
+                            self.assertLess(data_end - data_start,
+                                            len(data) + 1000)
+                            self.assertIn(pickle.REDUCE, pickled[:data_start])
+                        else:
+                            self.assertEqual(
+                                pickled[data_start-9: data_start],
+                                pickle.BINUNICODE8 + struct.pack("<Q", len(data)))
+                            self.assertEqual(data_end - data_start, len(data))
                     finally:
                         pickled = None
         finally:
diff -r de982d8b7b15 Modules/_pickle.c
--- a/Modules/_pickle.c	Tue Oct 13 21:26:35 2015 +0300
+++ b/Modules/_pickle.c	Wed Oct 14 13:06:22 2015 +0300
@@ -156,6 +156,12 @@ typedef struct {
     /* functools.partial, used for implementing __newobj_ex__ with protocols
        2 and 3 */
     PyObject *partial;
+    /* copyreg._reduce_large_str, used for saving large strings with
+       protocol < 4 */
+    PyObject *reduce_large_str;
+    /* copyreg._reduce_large_bytes, used for saving large bytes with
+       protocol < 4 */
+    PyObject *reduce_large_bytes;
 } PickleState;
 
 /* Forward declaration of the _pickle module definition. */
@@ -254,6 +260,14 @@ static int
                      "not %.200s", Py_TYPE(st->extension_cache)->tp_name);
         goto error;
     }
+    st->reduce_large_str = PyObject_GetAttrString(copyreg,
+                                                  "_reduce_large_str");
+    if (!st->reduce_large_str)
+        goto error;
+    st->reduce_large_bytes = PyObject_GetAttrString(copyreg,
+                                                    "_reduce_large_bytes");
+    if (!st->reduce_large_bytes)
+        goto error;
     Py_CLEAR(copyreg);
 
     /* Load the 2.x -> 3.x stdlib module mapping tables */
@@ -2087,9 +2101,19 @@ save_bytes(PicklerObject *self, PyObject
             len = 9;
         }
         else {
-            PyErr_SetString(PyExc_OverflowError,
-                            "cannot serialize a bytes object larger than 4 GiB");
-            return -1;          /* string too large */
+            PyObject *reduce_value;
+            int status;
+            PickleState *st = _Pickle_GetGlobalState();
+
+            reduce_value = PyObject_CallFunctionObjArgs(
+                    st->reduce_large_bytes, obj, NULL);
+            if (reduce_value == NULL)
+                return -1;
+
+            /* save_reduce() will memoize the object automatically. */
+            status = save_reduce(self, reduce_value, obj);
+            Py_DECREF(reduce_value);
+            return status;
         }
 
         if (_Pickler_Write(self, header, len) < 0)
@@ -2188,7 +2212,8 @@ write_utf8(PicklerObject *self, char *da
         header[1] = (unsigned char)(size & 0xff);
         len = 2;
     }
-    else if ((size_t)size <= 0xffffffffUL) {
+    else if ((size_t)size <= 0x7fffffffUL ||
+             (self->proto >= 3 && (size_t)size <= 0xffffffffUL)) {
         header[0] = BINUNICODE;
         header[1] = (unsigned char)(size & 0xff);
         header[2] = (unsigned char)((size >> 8) & 0xff);
@@ -2202,9 +2227,7 @@ write_utf8(PicklerObject *self, char *da
         len = 9;
     }
     else {
-        PyErr_SetString(PyExc_OverflowError,
-                        "cannot serialize a string larger than 4GiB");
-        return -1;
+        return -2;
     }
 
     if (_Pickler_Write(self, header, len) < 0)
@@ -2247,7 +2270,22 @@ static int
 save_unicode(PicklerObject *self, PyObject *obj)
 {
     if (self->bin) {
-        if (write_unicode_binary(self, obj) < 0)
+        int r = write_unicode_binary(self, obj);
+        if (r == -2) {
+            PyObject *reduce_value;
+            PickleState *st = _Pickle_GetGlobalState();
+
+            reduce_value = PyObject_CallFunctionObjArgs(
+                    st->reduce_large_str, obj, NULL);
+            if (reduce_value == NULL)
+                return -1;
+
+            /* save_reduce() will memoize the object automatically. */
+            r = save_reduce(self, reduce_value, obj);
+            Py_DECREF(reduce_value);
+            return r;
+        }
+        if (r < 0)
             return -1;
     }
     else {