python3 package update to version 3.6.5

Signed-off-by: basebuilder_pel7ppc64bebuilder0 <basebuilder@powerel.org>
7 years ago · a6d02a533b
34 changed files with 6687 additions and 0 deletions
--- a/SOURCES/00055-systemtap.patch
+++ b/SOURCES/00055-systemtap.patch
@ -0,0 +1,822 @@
				@@ -0,0 +1,822 @@
+diff -up Python-3.3.0rc2/configure.ac.systemtap Python-3.3.0rc2/configure.ac
+--- Python-3.3.0rc2/configure.ac.systemtap	2012-09-09 05:11:14.000000000 -0400
+++ Python-3.3.0rc2/configure.ac	2012-09-10 09:17:21.114511781 -0400
+@@ -2678,6 +2678,23 @@ if test "$with_valgrind" != no; then
+     OPT="-DDYNAMIC_ANNOTATIONS_ENABLED=1 $OPT"
+ fi
+ 
+# Check for systemtap support
+# On Linux, /usr/bin/dtrace is in fact a shim to SystemTap
+AC_MSG_CHECKING([for --with-systemtap])
+AC_ARG_WITH([systemtap],
+            AC_HELP_STRING([--with(out)-systemtap], [disable/enable SystemTap support]),,
+            with_systemtap=no)
+AC_MSG_RESULT([$with_systemtap])
+if test "$with_systemtap" != no; then
+    AC_DEFINE(WITH_SYSTEMTAP, 1,
+        [Define if you want to compile in SystemTap support])
+    SYSTEMTAPOBJS="Python/pysystemtap.o"
+    SYSTEMTAPDEPS="\$(srcdir)/Python/pysystemtap.h"
+fi
+
+AC_SUBST(SYSTEMTAPOBJS)
+AC_SUBST(SYSTEMTAPDEPS)
+
+ # -I${DLINCLDIR} is added to the compile rule for importdl.o
+ AC_SUBST(DLINCLDIR)
+ DLINCLDIR=.
+diff -up Python-3.3.0rc2/configure.systemtap Python-3.3.0rc2/configure
+--- Python-3.3.0rc2/configure.systemtap	2012-09-09 05:11:14.000000000 -0400
+++ Python-3.3.0rc2/configure	2012-09-10 09:17:21.116511780 -0400
+@@ -618,6 +618,8 @@ TRUE
+ MACHDEP_OBJS
+ DYNLOADFILE
+ DLINCLDIR
+SYSTEMTAPDEPS
+SYSTEMTAPOBJS
+ THREADOBJ
+ LDLAST
+ USE_THREAD_MODULE
+@@ -779,6 +781,7 @@ with_doc_strings
+ with_tsc
+ with_pymalloc
+ with_valgrind
+with_systemtap
+ with_fpectl
+ with_libm
+ with_libc
+@@ -1456,6 +1459,7 @@ Optional Packages:
+   --with(out)-tsc         enable/disable timestamp counter profile
+   --with(out)-pymalloc    disable/enable specialized mallocs
+   --with-valgrind         Enable Valgrind support
+  --with(out)-systemtap   disable/enable SystemTap support
+   --with-fpectl           enable SIGFPE catching
+   --with-libm=STRING      math library
+   --with-libc=STRING      C library
+@@ -10065,6 +10069,31 @@ fi
+     OPT="-DDYNAMIC_ANNOTATIONS_ENABLED=1 $OPT"
+ fi
+ 
+# Check for systemtap support
+# On Linux, /usr/bin/dtrace is in fact a shim to SystemTap
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for --with-systemtap" >&5
+$as_echo_n "checking for --with-systemtap... " >&6; }
+
+# Check whether --with-systemtap was given.
+if test "${with_systemtap+set}" = set; then :
+  withval=$with_systemtap;
+else
+  with_systemtap=no
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_systemtap" >&5
+$as_echo "$with_systemtap" >&6; }
+if test "$with_systemtap" != no; then
+
+$as_echo "#define WITH_SYSTEMTAP 1" >>confdefs.h
+
+    SYSTEMTAPOBJS="Python/pysystemtap.o"
+    SYSTEMTAPDEPS="\$(srcdir)/Python/pysystemtap.h"
+fi
+
+
+
+
+ # -I${DLINCLDIR} is added to the compile rule for importdl.o
+ 
+ DLINCLDIR=.
+diff -up Python-3.3.0rc2/Doc/howto/index.rst.systemtap Python-3.3.0rc2/Doc/howto/index.rst
+--- Python-3.3.0rc2/Doc/howto/index.rst.systemtap	2012-09-09 05:10:51.000000000 -0400
+++ Python-3.3.0rc2/Doc/howto/index.rst	2012-09-10 09:17:21.117511779 -0400
+@@ -29,4 +29,5 @@ Currently, the HOWTOs are:
+    argparse.rst
+    ipaddress.rst
+    clinic.rst
+   instrumentation.rst
+ 
+diff -up Python-3.3.0rc2/Doc/howto/instrumentation.rst.systemtap Python-3.3.0rc2/Doc/howto/instrumentation.rst
+--- Python-3.3.0rc2/Doc/howto/instrumentation.rst.systemtap	2012-09-10 09:17:21.117511779 -0400
+++ Python-3.3.0rc2/Doc/howto/instrumentation.rst	2012-09-10 09:17:21.117511779 -0400
+@@ -0,0 +1,295 @@
+.. _instrumentation:
+
+====================================
+Instrumenting CPython with SystemTap
+====================================
+
+:author: David Malcolm <dmalcolm@redhat.com>
+
+DTrace and SystemTap are monitoring tools, each providing a way to inspect
+what the processes on a computer system are doing.  They both use
+domain-specific languages allowing a user to write scripts which:
+
+  - filter which processes are to be observed
+  - gather data from the processes of interest
+  - generate reports on the data
+
+As of Python 3.3, CPython can be built with embedded "markers" that can be
+observed by a SystemTap script, making it easier to monitor what the CPython
+processes on a system are doing.
+
+.. Potentially this document could be expanded to also cover DTrace markers.
+   However, I'm not a DTrace expert.
+
+.. I'm using ".. code-block:: c" for SystemTap scripts, as "c" is syntactically
+   the closest match that Sphinx supports
+
+
+Enabling the static markers
+---------------------------
+
+In order to build CPython with the embedded markers for SystemTap, the
+SystemTap development tools must be installed.
+
+On a Fedora or Red Hat Enterprise Linux machine, this can be done via::
+
+   yum install systemtap-sdt-devel
+
+CPython must then be configured `--with-systemtap`::
+
+   checking for --with-systemtap... yes
+
+You can verify if the SystemTap static markers are present in the built
+binary by seeing if it contains a ".note.stapsdt" section.
+
+.. code-block:: bash
+
+   $ eu-readelf -S ./python | grep .note.stapsdt
+   [29] .note.stapsdt        NOTE         0000000000000000 00308d78 000000b8  0        0   0  4
+
+If you've built python as a shared library (with --enable-shared), you need
+to look instead within the shared library.  For example:
+
+.. code-block:: bash
+
+   $ eu-readelf -S libpython3.3dm.so.1.0 | grep .note.stapsdt
+   [28] .note.stapsdt        NOTE         0000000000000000 00365b68 000000b8  0        0   0  4
+
+Earlier versions of SystemTap stored the markers in a ".probes" section.
+
+For the curious, you can see the metadata for the static markers using this
+invocation.
+
+.. code-block:: bash
+
+  $ eu-readelf -x .note.stapsdt ./python
+
+  Hex dump of section [29] '.note.stapsdt', 184 bytes at offset 0x308d78:
+    0x00000000 08000000 45000000 03000000 73746170 ....E.......stap
+    0x00000010 73647400 d4664b00 00000000 4fc36600 sdt..fK.....O.f.
+    0x00000020 00000000 488d9000 00000000 70797468 ....H.......pyth
+    0x00000030 6f6e0066 756e6374 696f6e5f 5f656e74 on.function__ent
+    0x00000040 72790038 40257261 78203840 25726478 ry.8@%rax 8@%rdx
+    0x00000050 202d3440 25656378 00000000 08000000  -4@%ecx........
+    0x00000060 46000000 03000000 73746170 73647400 F.......stapsdt.
+    0x00000070 0d674b00 00000000 4fc36600 00000000 .gK.....O.f.....
+    0x00000080 4a8d9000 00000000 70797468 6f6e0066 J.......python.f
+    0x00000090 756e6374 696f6e5f 5f726574 75726e00 unction__return.
+    0x000000a0 38402572 61782038 40257264 78202d34 8@%rax 8@%rdx -4
+    0x000000b0 40256563 78000000                   @%ecx...
+
+and a sufficiently modern eu-readelf can print the metadata:
+
+.. code-block:: bash
+
+  $ eu-readelf -n ./python
+
+  Note section [ 1] '.note.gnu.build-id' of 36 bytes at offset 0x190:
+    Owner          Data size  Type
+    GNU                   20  GNU_BUILD_ID
+      Build ID: a28f8db1b224530b0d38ad7b82a249cf7c3f18d6
+
+  Note section [27] '.note.stapsdt' of 184 bytes at offset 0x1ae884:
+    Owner          Data size  Type
+    stapsdt               70  Version: 3
+      PC: 0xe0d3a, Base: 0x14b150, Semaphore: 0x3ae882
+      Provider: python, Name: function__return, Args: '8@%rbx 8@%r13 -4@%eax'
+    stapsdt               69  Version: 3
+      PC: 0xe0f37, Base: 0x14b150, Semaphore: 0x3ae880
+      Provider: python, Name: function__entry, Args: '8@%rbx 8@%r13 -4@%eax'
+
+The above metadata contains information for SystemTap describing how it can
+patch strategically-placed machine code instructions to enable the tracing
+hooks used by a SystemTap script.
+
+
+Static markers
+--------------
+
+The low-level way to use the SystemTap integration is to use the static
+markers directly.  This requires you to explicitly state the binary file
+containing them.
+
+For example, this script can be used to show the call/return hierarchy of a
+Python script:
+
+.. code-block:: c
+
+   probe process('python').mark("function__entry") {
+        filename = user_string($arg1);
+        funcname = user_string($arg2);
+        lineno = $arg3;
+
+        printf("%s => %s in %s:%d\\n",
+               thread_indent(1), funcname, filename, lineno);
+   }
+
+   probe process('python').mark("function__return") {
+       filename = user_string($arg1);
+       funcname = user_string($arg2);
+       lineno = $arg3;
+
+       printf("%s <= %s in %s:%d\\n",
+              thread_indent(-1), funcname, filename, lineno);
+   }
+
+It can be invoked like this:
+
+.. code-block:: bash
+
+   $ stap \
+     show-call-hierarchy.stp \
+     -c ./python test.py
+
+The output looks like this::
+
+   11408 python(8274):        => __contains__ in Lib/_abcoll.py:362
+   11414 python(8274):         => __getitem__ in Lib/os.py:425
+   11418 python(8274):          => encode in Lib/os.py:490
+   11424 python(8274):          <= encode in Lib/os.py:493
+   11428 python(8274):         <= __getitem__ in Lib/os.py:426
+   11433 python(8274):        <= __contains__ in Lib/_abcoll.py:366
+
+where the columns are:
+
+  - time in microseconds since start of script
+
+  - name of executable
+
+  - PID of process
+
+and the remainder indicates the call/return hierarchy as the script executes.
+
+For a `--enable-shared` build of CPython, the markers are contained within the
+libpython shared library, and the probe's dotted path needs to reflect this. For
+example, this line from the above example::
+
+   probe process('python').mark("function__entry") {
+
+should instead read::
+
+   probe process('python').library("libpython3.3dm.so.1.0").mark("function__entry") {
+
+(assuming a debug build of CPython 3.3)
+
+.. I'm reusing the "c:function" type for markers
+
+.. c:function:: function__entry(str filename, str funcname, int lineno)
+
+   This marker indicates that execution of a Python function has begun.  It is
+   only triggered for pure-python (bytecode) functions.
+
+   The filename, function name, and line number are provided back to the
+   tracing script as positional arguments, which must be accessed using
+   `$arg1`, `$arg2`:
+
+       * `$arg1` : `(const char *)` filename, accessible using `user_string($arg1)`
+
+       * `$arg2` : `(const char *)` function name, accessible using
+         `user_string($arg2)`
+
+       * `$arg3` : `int` line number
+
+       * `$arg4` : `(PyFrameObject *)`, the frame being executed
+
+.. c:function:: function__return(str filename, str funcname, int lineno)
+
+   This marker is the converse of `function__entry`, and indicates that
+   execution of a Python function has ended (either via ``return``, or via an
+   exception).  It is only triggered for pure-python (bytecode) functions.
+
+   The arguments are the same as for `function__entry`
+
+
+Tapsets
+-------
+
+The higher-level way to use the SystemTap integration is to use a "tapset":
+SystemTap's equivalent of a library, which hides some of the lower-level
+details of the static markers.
+
+Here is a tapset file, based on a non-shared build of CPython:
+
+.. code-block:: c
+
+    /*
+       Provide a higher-level wrapping around the function__entry and
+       function__return markers:
+     */
+    probe python.function.entry = process("python").mark("function__entry")
+    {
+        filename = user_string($arg1);
+        funcname = user_string($arg2);
+        lineno = $arg3;
+        frameptr = $arg4
+    }
+    probe python.function.return = process("python").mark("function__return")
+    {
+        filename = user_string($arg1);
+        funcname = user_string($arg2);
+        lineno = $arg3;
+        frameptr = $arg4
+    }
+
+If this file is installed in SystemTap's tapset directory (e.g.
+`/usr/share/systemtap/tapset`), then these additional probepoints become
+available:
+
+.. c:function:: python.function.entry(str filename, str funcname, int lineno, frameptr)
+
+   This probe point indicates that execution of a Python function has begun.
+   It is only triggered for pure-python (bytecode) functions.
+
+.. c:function:: python.function.return(str filename, str funcname, int lineno, frameptr)
+
+   This probe point is the converse of `python.function.return`, and indicates
+   that execution of a Python function has ended (either via ``return``, or
+   via an exception).  It is only triggered for pure-python (bytecode) functions.
+
+
+Examples
+--------
+This SystemTap script uses the tapset above to more cleanly implement the
+example given above of tracing the Python function-call hierarchy, without
+needing to directly name the static markers:
+
+.. code-block:: c
+
+    probe python.function.entry
+    {
+      printf("%s => %s in %s:%d\n",
+             thread_indent(1), funcname, filename, lineno);
+    }
+
+    probe python.function.return
+    {
+      printf("%s <= %s in %s:%d\n",
+             thread_indent(-1), funcname, filename, lineno);
+    }
+
+
+The following script uses the tapset above to provide a top-like view of all
+running CPython code, showing the top 20 most frequently-entered bytecode
+frames, each second, across the whole system:
+
+.. code-block:: c
+
+    global fn_calls;
+
+    probe python.function.entry
+    {
+      fn_calls[pid(), filename, funcname, lineno] += 1;
+    }
+
+    probe timer.ms(1000) {
+        printf("\033[2J\033[1;1H") /* clear screen */
+        printf("%6s %80s %6s %30s %6s\n",
+               "PID", "FILENAME", "LINE", "FUNCTION", "CALLS")
+        foreach ([pid, filename, funcname, lineno] in fn_calls- limit 20) {
+            printf("%6d %80s %6d %30s %6d\n",
+                pid, filename, lineno, funcname,
+                fn_calls[pid, filename, funcname, lineno]);
+        }
+        delete fn_calls;
+    }
+
+diff -up Python-3.3.0rc2/Lib/test/test_systemtap.py.systemtap Python-3.3.0rc2/Lib/test/test_systemtap.py
+--- Python-3.3.0rc2/Lib/test/test_systemtap.py.systemtap	2012-09-10 09:17:21.117511779 -0400
+++ Python-3.3.0rc2/Lib/test/test_systemtap.py	2012-09-10 09:17:21.117511779 -0400
+@@ -0,0 +1,234 @@
+# Verify that systemtap static probes work
+#
+import subprocess
+import sys
+import sysconfig
+import os
+import unittest
+
+from test.support import run_unittest, TESTFN, unlink
+
+if '--with-systemtap' not in sysconfig.get_config_var('CONFIG_ARGS'):
+    raise unittest.SkipTest("Python was not configured --with-systemtap")
+
+try:
+    _, stap_version = subprocess.Popen(["stap", "-V"],
+                                       stdout=subprocess.PIPE,
+                                       stderr=subprocess.PIPE,
+                                       ).communicate()
+except OSError:
+    # This is what "no stap" looks like.  There may, however, be other
+    # errors that manifest this way too.
+    raise unittest.SkipTest("Couldn't find stap on the path")
+
+def invoke_systemtap_script(script, cmd):
+    # Start a child process, probing with the given systemtap script
+    # (passed as stdin to the "stap" tool)
+    # The script should be a bytes instance
+    # Return (stdout, stderr) pair
+
+    p = subprocess.Popen(["stap", "-", '-vv', '-c', cmd],
+                         stdin=subprocess.PIPE,
+                         stdout=subprocess.PIPE,
+                         stderr=subprocess.PIPE)
+    out, err = p.communicate(input=script)
+    return out, err
+
+# Verify that stap can run a simple "hello world"-style script
+# This can fail for various reasons:
+# - missing kernel headers
+# - permissions (a non-root user needs to be in the "stapdev" group)
+TRIVIAL_STAP_SCRIPT = b'probe begin { println("hello world") exit () }'
+
+out, err = invoke_systemtap_script(TRIVIAL_STAP_SCRIPT, 'true')
+if out != b'hello world\n':
+    raise unittest.SkipTest("Test systemtap script did not run; stderr was: %s" % err)
+
+# We don't expect stderr to be empty, since we're invoking stap with "-vv": stap
+# will (we hope) generate debugging output on stderr.
+
+def invoke_python_under_systemtap(script, pythoncode=None, pythonfile=None):
+    # Start a child python process, probing with the given systemtap script
+    # (passed as stdin to the "stap" tool)
+    # The script should be a bytes instance
+    # Return (stdout, stderr) pair
+
+    if pythonfile:
+        pythoncmd = '%s %s' % (sys.executable, pythonfile)
+    else:
+        pythoncmd = '%s -c %r' % (sys.executable, pythoncode)
+
+    # The process tree of a stap invocation of a command goes through
+    # something like this:
+    #    stap ->fork/exec(staprun; exec stapio ->f/e(-c cmd); exec staprun -r)
+    # and this trip through setuid leads to LD_LIBRARY_PATH being dropped,
+    # which would lead to an --enable-shared build of python failing to be
+    # find its libpython, with an error like:
+    #    error while loading shared libraries: libpython3.3dm.so.1.0: cannot
+    #    open shared object file: No such file or directory
+    # Hence we need to jump through some hoops to expose LD_LIBRARY_PATH to
+    # the invoked python process:
+    LD_LIBRARY_PATH = os.environ.get('LD_LIBRARY_PATH', '')
+    if LD_LIBRARY_PATH:
+        pythoncmd = 'env LD_LIBRARY_PATH=%s ' % LD_LIBRARY_PATH + pythoncmd
+
+    return invoke_systemtap_script(script, pythoncmd)
+
+# When using the static markers, we need to supply the prefix of a systemtap
+# dotted probe point that containing the marker.
+# See http://sourceware.org/systemtap/langref/Probe_points.html
+#
+# We need to determine if this is a shared-library build
+#
+# Note that sysconfig can get this wrong; see:
+#   http://bugs.python.org/issue14774
+#
+if '--enable-shared' in sysconfig.get_config_var('CONFIG_ARGS'):
+    # For a shared-library build, the markers are in library(INSTSONAME):
+    INSTSONAME = sysconfig.get_config_var('INSTSONAME')
+    probe_prefix = 'process("%s").library("%s")' % (sys.executable, INSTSONAME)
+else:
+    # For a non-shared-library build, we can simply use sys.executable:
+    probe_prefix = 'process("%s")' % sys.executable
+
+# The following script ought to generate lots of lines showing recursive
+# function entry and return, of the form:
+#     11408 python(8274):        => __contains__ in Lib/_abcoll.py:362
+#     11414 python(8274):         => __getitem__ in Lib/os.py:425
+#     11418 python(8274):          => encode in Lib/os.py:490
+#     11424 python(8274):          <= encode in Lib/os.py:493
+#     11428 python(8274):         <= __getitem__ in Lib/os.py:426
+#     11433 python(8274):        <= __contains__ in Lib/_abcoll.py:366
+# where the column are:
+#  - time in microseconds since start of script
+#  - name of executable
+#  - PID of process
+#  and the remainder indicates the call/return hierarchy
+
+hierarchy_script = ('''
+probe %s.mark("function__entry") {
+    filename = user_string($arg1);
+    funcname = user_string($arg2);
+    lineno = $arg3;
+
+    printf("%%s => %%s in %%s:%%d\\n", thread_indent(1), funcname, filename, lineno);
+}
+
+probe %s.mark("function__return") {
+    filename = user_string($arg1);
+    funcname = user_string($arg2);
+    lineno = $arg3;
+
+    printf("%%s <= %%s in %%s:%%d\\n", thread_indent(-1), funcname, filename, lineno);
+}
+''' % (probe_prefix, probe_prefix)).encode('utf-8')
+
+
+class ErrorDumper:
+    # A context manager that dumps extra information if an exception is raised,
+    # to help track down why the problem occurred
+    def __init__(self, out, err):
+        self.out = out
+        self.err = err
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, type_, value, traceback):
+        if type_:
+            # an exception is being raised:
+            print('stdout: %s' % out.decode())
+            print('stderr: %s' % err.decode())
+
+class SystemtapTests(unittest.TestCase):
+
+    def test_invoking_python(self):
+        # Ensure that we can invoke python under stap, with a trivial stap
+        # script:
+        out, err = invoke_python_under_systemtap(
+            b'probe begin { println("hello from stap") exit () }',
+            pythoncode="print('hello from python')")
+        with ErrorDumper(out, err):
+            self.assertIn(b'hello from stap', out)
+            self.assertIn(b'hello from python', out)
+
+    def test_function_entry(self):
+        # Ensure that the function_entry static marker works
+        out, err = invoke_python_under_systemtap(hierarchy_script)
+        # stdout ought to contain various lines showing recursive function
+        # entry and return (see above)
+
+        # Uncomment this for debugging purposes:
+        # print(out.decode('utf-8'))
+
+        #   Executing the cmdline-supplied "pass":
+        #      0 python(8274): => <module> in <string>:1
+        #      5 python(8274): <= <module> in <string>:1
+        with ErrorDumper(out, err):
+            self.assertIn(b'=> <module> in <string>:1', out,
+                          msg="stdout: %s\nstderr: %s\n" % (out, err))
+
+    def test_function_encoding(self):
+        # Ensure that function names containing non-Latin 1 code
+        # points are handled:
+        pythonfile = TESTFN
+        try:
+            unlink(pythonfile)
+            f = open(pythonfile, "wb")
+            f.write("""
+# Sample script with non-ASCII filename, for use by test_systemtap.py
+# Implicitly UTF-8
+
+def 文字化け():
+    '''Function with non-ASCII identifier; I believe this reads "mojibake"'''
+    print("hello world!")
+
+文字化け()
+""".encode('utf-8'))
+            f.close()
+
+            out, err = invoke_python_under_systemtap(hierarchy_script,
+                                                     pythonfile=pythonfile)
+            out_utf8 = out.decode('utf-8')
+            with ErrorDumper(out, err):
+                self.assertIn('=> <module> in %s:5' % pythonfile, out_utf8)
+                self.assertIn(' => 文字化け in %s:5' % pythonfile, out_utf8)
+                self.assertIn(' <= 文字化け in %s:7' % pythonfile, out_utf8)
+                self.assertIn('<= <module> in %s:9' % pythonfile, out_utf8)
+        finally:
+            unlink(pythonfile)
+
+    @unittest.skipIf(sys.getfilesystemencoding() == 'ascii',
+                     'the test filename is not encodable with ASCII')
+    def test_filename_encoding(self):
+        # Ensure that scripts names containing non-Latin 1 code
+        # points are handled:
+        pythonfile = TESTFN + '_☠.py'
+        try:
+            unlink(pythonfile)
+            f = open(pythonfile, "wb")
+            f.write("""
+def foo():
+    '''Function with non-ASCII identifier; I believe this reads "mojibake"'''
+    print("hello world!")
+
+foo()
+""".encode('utf-8'))
+            f.close()
+
+            out, err = invoke_python_under_systemtap(hierarchy_script,
+                                                     pythonfile=pythonfile)
+            out_utf8 = out.decode('utf-8')
+            with ErrorDumper(out, err):
+                self.assertIn('=> <module> in %s:2' % pythonfile, out_utf8)
+                self.assertIn(' => foo in %s:2' % pythonfile, out_utf8)
+                self.assertIn(' <= foo in %s:4' % pythonfile, out_utf8)
+                self.assertIn('<= <module> in %s:6' % pythonfile, out_utf8)
+        finally:
+            unlink(pythonfile)
+
+def test_main():
+    run_unittest(SystemtapTests)
+
+if __name__ == "__main__":
+    test_main()
+diff -up Python-3.3.0rc2/Makefile.pre.in.systemtap Python-3.3.0rc2/Makefile.pre.in
+--- Python-3.3.0rc2/Makefile.pre.in.systemtap	2012-09-09 05:11:05.000000000 -0400
+++ Python-3.3.0rc2/Makefile.pre.in	2012-09-10 09:19:51.195501518 -0400
+@@ -363,6 +363,7 @@ PYTHON_OBJS=	\
+ 		Python/formatter_unicode.o \
+ 		Python/fileutils.o \
+ 		Python/$(DYNLOADFILE) \
+		@SYSTEMTAPOBJS@ \
+ 		$(LIBOBJS) \
+ 		$(MACHDEP_OBJS) \
+ 		$(THREADOBJ)
+@@ -713,7 +714,8 @@ Objects/setobject.o: $(srcdir)/Objects/s
+ $(OPCODETARGETS_H): $(OPCODETARGETGEN_FILES)
+ 	$(OPCODETARGETGEN) $(OPCODETARGETS_H)
+ 
+-Python/ceval.o: $(OPCODETARGETS_H) $(srcdir)/Python/ceval_gil.h
+Python/ceval.o: $(OPCODETARGETS_H) $(srcdir)/Python/ceval_gil.h \
+			$(srcdir)/Python/ceval_systemtap.h @SYSTEMTAPDEPS@
+ 
+ Python/frozen.o: Python/importlib.h Python/importlib_external.h
+ 
+@@ -724,6 +726,13 @@ Objects/typeobject.o: $(srcdir)/Objects/
+ Objects/typeslots.inc: $(srcdir)/Include/typeslots.h $(srcdir)/Objects/typeslots.py
+ 	$(PYTHON) $(srcdir)/Objects/typeslots.py < $(srcdir)/Include/typeslots.h > Objects/typeslots.inc
+ 
+# Only needed with --with-systemtap; not a public header:
+$(srcdir)/Python/pysystemtap.h: $(srcdir)/Python/pysystemtap.d
+	dtrace -o $@ $(DFLAGS) -C -h -s $(srcdir)/Python/pysystemtap.d
+
+Python/pysystemtap.o: $(srcdir)/Python/pysystemtap.d Python/ceval.o
+	dtrace -o $@ $(DFLAGS) -C -G -s $(srcdir)/Python/pysystemtap.d Python/ceval.o
+
+ ############################################################################
+ # Header files
+ 
+@@ -1345,6 +1354,7 @@ clean: pycremoval
+ 	-rm -f Lib/lib2to3/*Grammar*.pickle
+ 	-rm -f Programs/_testembed Programs/_freeze_importlib
+	-rm -rf build
+	-rm -f $(srcdir)/Python/pysystemtap.h
+ 
+ profile-removal:
+ 	find . -name '*.gc??' -exec rm -f {} ';'
+diff -up Python-3.3.0rc2/pyconfig.h.in.systemtap Python-3.3.0rc2/pyconfig.h.in
+--- Python-3.3.0rc2/pyconfig.h.in.systemtap	2012-09-09 05:11:14.000000000 -0400
+++ Python-3.3.0rc2/pyconfig.h.in	2012-09-10 09:17:21.120511781 -0400
+@@ -1306,6 +1306,9 @@
+ /* Define if you want to compile in Python-specific mallocs */
+ #undef WITH_PYMALLOC
+ 
+/* Define if you want to compile in SystemTap support */
+#undef WITH_SYSTEMTAP
+
+ /* Define if you want to compile in rudimentary thread support */
+ #undef WITH_THREAD
+ 
+diff -up Python-3.3.0rc2/Python/ceval.c.systemtap Python-3.3.0rc2/Python/ceval.c
+--- Python-3.3.0rc2/Python/ceval.c.systemtap	2012-09-09 05:11:12.000000000 -0400
+++ Python-3.3.0rc2/Python/ceval.c	2012-09-10 09:17:21.122511781 -0400
+@@ -18,6 +18,8 @@
+ 
+ #include <ctype.h>
+ 
+#include "ceval_systemtap.h"
+
+ #ifndef WITH_TSC
+ 
+ #define READ_TIMESTAMP(var)
+@@ -1160,6 +1162,10 @@ PyEval_EvalFrameEx(PyFrameObject *f, int
+         }
+     }
+ 
+    if (PYTHON_FUNCTION_ENTRY_ENABLED()) {
+        systemtap_function_entry(f);
+    }
+
+     co = f->f_code;
+     names = co->co_names;
+     consts = co->co_consts;
+@@ -3077,6 +3083,11 @@ fast_yield:
+ 
+     /* pop frame */
+ exit_eval_frame:
+
+    if (PYTHON_FUNCTION_RETURN_ENABLED()) {
+        systemtap_function_return(f);
+    }
+
+     Py_LeaveRecursiveCall();
+     f->f_executing = 0;
+     tstate->frame = f->f_back;
+diff -up Python-3.3.0rc2/Python/ceval_systemtap.h.systemtap Python-3.3.0rc2/Python/ceval_systemtap.h
+--- Python-3.3.0rc2/Python/ceval_systemtap.h.systemtap	2012-09-10 09:17:21.122511781 -0400
+++ Python-3.3.0rc2/Python/ceval_systemtap.h	2012-09-10 09:17:21.122511781 -0400
+@@ -0,0 +1,86 @@
+/*
+  Support for SystemTap static markers  
+*/
+
+#ifdef WITH_SYSTEMTAP
+
+#include "pysystemtap.h"
+
+/*
+  A struct to hold all of the information gathered when one of the traceable
+  markers is triggered
+*/
+struct frame_marker_info
+{
+    PyObject *filename_obj;
+    PyObject *funcname_obj;
+    const char *filename;
+    const char *funcname;
+    int lineno;
+};
+
+static void
+get_frame_marker_info(PyFrameObject *f, struct frame_marker_info *fmi)
+{
+    PyObject *ptype;
+    PyObject *pvalue;
+    PyObject *ptraceback;
+
+    PyErr_Fetch(&ptype, &pvalue, &ptraceback);
+
+    fmi->filename_obj = PyUnicode_EncodeFSDefault(f->f_code->co_filename);
+    if (fmi->filename_obj) {
+        fmi->filename = PyBytes_AsString(fmi->filename_obj);
+    } else {
+        fmi->filename = NULL;
+    }
+
+    fmi->funcname_obj = PyUnicode_AsUTF8String(f->f_code->co_name);
+    if (fmi->funcname_obj) {
+        fmi->funcname = PyBytes_AsString(fmi->funcname_obj);
+    } else {
+        fmi->funcname = NULL;
+    }
+
+    fmi->lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);
+
+    PyErr_Restore(ptype, pvalue, ptraceback);
+
+}
+
+static void
+release_frame_marker_info(struct frame_marker_info *fmi)
+{
+    Py_XDECREF(fmi->filename_obj);
+    Py_XDECREF(fmi->funcname_obj);
+}
+
+static void
+systemtap_function_entry(PyFrameObject *f)
+{
+    struct frame_marker_info fmi;
+    get_frame_marker_info(f, &fmi);
+    PYTHON_FUNCTION_ENTRY(fmi.filename, fmi.funcname, fmi.lineno, f);
+    release_frame_marker_info(&fmi);
+}
+
+static void
+systemtap_function_return(PyFrameObject *f)
+{
+    struct frame_marker_info fmi;
+    get_frame_marker_info(f, &fmi);
+    PYTHON_FUNCTION_RETURN(fmi.filename, fmi.funcname, fmi.lineno, f);
+    release_frame_marker_info(&fmi);
+}
+
+#else /* #ifdef WITH_SYSTEMTAP */
+
+/*
+  When configured --without-systemtap, everything compiles away to nothing:
+*/
+#define PYTHON_FUNCTION_ENTRY_ENABLED() 0
+#define PYTHON_FUNCTION_RETURN_ENABLED() 0
+#define systemtap_function_entry(f)
+#define systemtap_function_return(f)
+
+#endif
+diff -up Python-3.3.0rc2/Python/pysystemtap.d.systemtap Python-3.3.0rc2/Python/pysystemtap.d
+--- Python-3.3.0rc2/Python/pysystemtap.d.systemtap	2012-09-10 09:17:21.122511781 -0400
+++ Python-3.3.0rc2/Python/pysystemtap.d	2012-09-10 09:17:21.122511781 -0400
+@@ -0,0 +1,4 @@
+provider python {
+    probe function__entry(const char *, const char *, int, PyFrameObject *);
+    probe function__return(const char *, const char *, int, PyFrameObject *);
+};
--- a/SOURCES/00102-lib64.patch
+++ b/SOURCES/00102-lib64.patch
@ -0,0 +1,188 @@
				@@ -0,0 +1,188 @@
+diff --git a/Lib/distutils/command/install.py b/Lib/distutils/command/install.py
+index 9474e9c..c0ce4c6 100644
+--- a/Lib/distutils/command/install.py
+++ b/Lib/distutils/command/install.py
+@@ -30,14 +30,14 @@ WINDOWS_SCHEME = {
+ INSTALL_SCHEMES = {
+     'unix_prefix': {
+         'purelib': '$base/lib/python$py_version_short/site-packages',
+-        'platlib': '$platbase/lib/python$py_version_short/site-packages',
+        'platlib': '$platbase/lib64/python$py_version_short/site-packages',
+         'headers': '$base/include/python$py_version_short$abiflags/$dist_name',
+         'scripts': '$base/bin',
+         'data'   : '$base',
+         },
+     'unix_home': {
+         'purelib': '$base/lib/python',
+-        'platlib': '$base/lib/python',
+        'platlib': '$base/lib64/python',
+         'headers': '$base/include/python/$dist_name',
+         'scripts': '$base/bin',
+         'data'   : '$base',
+diff --git a/Lib/distutils/sysconfig.py b/Lib/distutils/sysconfig.py
+index 026cca7..6d3e077 100644
+--- a/Lib/distutils/sysconfig.py
+++ b/Lib/distutils/sysconfig.py
+@@ -132,8 +132,12 @@ def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
+             prefix = plat_specific and EXEC_PREFIX or PREFIX
+ 
+     if os.name == "posix":
+        if plat_specific or standard_lib:
+            lib = "lib64"
+        else:
+            lib = "lib"
+         libpython = os.path.join(prefix,
+-                                 "lib", "python" + get_python_version())
+                                 lib, "python" + get_python_version())
+         if standard_lib:
+             return libpython
+         else:
+diff --git a/Lib/site.py b/Lib/site.py
+index a84e3bb..ba0d3ea 100644
+--- a/Lib/site.py
+++ b/Lib/site.py
+@@ -303,11 +303,15 @@ def getsitepackages(prefixes=None):
+         seen.add(prefix)
+ 
+         if os.sep == '/':
+            sitepackages.append(os.path.join(prefix, "lib64",
+                                        "python" + sys.version[:3],
+                                        "site-packages"))
+             sitepackages.append(os.path.join(prefix, "lib",
+                                         "python%d.%d" % sys.version_info[:2],
+                                         "site-packages"))
+         else:
+             sitepackages.append(prefix)
+            sitepackages.append(os.path.join(prefix, "lib64", "site-packages"))
+             sitepackages.append(os.path.join(prefix, "lib", "site-packages"))
+         if sys.platform == "darwin":
+             # for framework builds *only* we add the standard Apple
+diff --git a/Lib/sysconfig.py b/Lib/sysconfig.py
+index b9bbfe5..2a5f29c 100644
+--- a/Lib/sysconfig.py
+++ b/Lib/sysconfig.py
+@@ -20,10 +20,10 @@ __all__ = [
+ 
+ _INSTALL_SCHEMES = {
+     'posix_prefix': {
+-        'stdlib': '{installed_base}/lib/python{py_version_short}',
+-        'platstdlib': '{platbase}/lib/python{py_version_short}',
+        'stdlib': '{installed_base}/lib64/python{py_version_short}',
+        'platstdlib': '{platbase}/lib64/python{py_version_short}',
+         'purelib': '{base}/lib/python{py_version_short}/site-packages',
+-        'platlib': '{platbase}/lib/python{py_version_short}/site-packages',
+        'platlib': '{platbase}/lib64/python{py_version_short}/site-packages',
+         'include':
+             '{installed_base}/include/python{py_version_short}{abiflags}',
+         'platinclude':
+@@ -61,10 +61,10 @@ _INSTALL_SCHEMES = {
+         'data': '{userbase}',
+         },
+     'posix_user': {
+-        'stdlib': '{userbase}/lib/python{py_version_short}',
+-        'platstdlib': '{userbase}/lib/python{py_version_short}',
+        'stdlib': '{userbase}/lib64/python{py_version_short}',
+        'platstdlib': '{userbase}/lib64/python{py_version_short}',
+         'purelib': '{userbase}/lib/python{py_version_short}/site-packages',
+-        'platlib': '{userbase}/lib/python{py_version_short}/site-packages',
+        'platlib': '{userbase}/lib64/python{py_version_short}/site-packages',
+         'include': '{userbase}/include/python{py_version_short}',
+         'scripts': '{userbase}/bin',
+         'data': '{userbase}',
+diff --git a/Lib/test/test_site.py b/Lib/test/test_site.py
+index f698927..bc977b5 100644
+--- a/Lib/test/test_site.py
+++ b/Lib/test/test_site.py
+@@ -248,8 +248,8 @@ class HelperFunctionsTests(unittest.TestCase):
+             self.assertEqual(dirs[1], wanted)
+         elif os.sep == '/':
+             # OS X non-framework builds, Linux, FreeBSD, etc
+-            self.assertEqual(len(dirs), 1)
+-            wanted = os.path.join('xoxo', 'lib',
+            self.assertEqual(len(dirs), 2)
+            wanted = os.path.join('xoxo', 'lib64',
+                                   'python%d.%d' % sys.version_info[:2],
+                                   'site-packages')
+             self.assertEqual(dirs[0], wanted)
+diff --git a/Makefile.pre.in b/Makefile.pre.in
+index 8fa7934..a693917 100644
+--- a/Makefile.pre.in
+++ b/Makefile.pre.in
+@@ -126,7 +126,7 @@ LIBDIR=		@libdir@
+ MANDIR=		@mandir@
+ INCLUDEDIR=	@includedir@
+ CONFINCLUDEDIR=	$(exec_prefix)/include
+-SCRIPTDIR=	$(prefix)/lib
+SCRIPTDIR=	$(prefix)/lib64
+ ABIFLAGS=	@ABIFLAGS@
+ 
+ # Detailed destination directories
+diff --git a/Modules/getpath.c b/Modules/getpath.c
+index 65b47a3..eaa756c 100644
+--- a/Modules/getpath.c
+++ b/Modules/getpath.c
+@@ -494,7 +494,7 @@ calculate_path(void)
+     _pythonpath = Py_DecodeLocale(PYTHONPATH, NULL);
+     _prefix = Py_DecodeLocale(PREFIX, NULL);
+     _exec_prefix = Py_DecodeLocale(EXEC_PREFIX, NULL);
+-    lib_python = Py_DecodeLocale("lib/python" VERSION, NULL);
+    lib_python = Py_DecodeLocale("lib64/python" VERSION, NULL);
+ 
+     if (!_pythonpath || !_prefix || !_exec_prefix || !lib_python) {
+         Py_FatalError(
+@@ -683,7 +683,7 @@ calculate_path(void)
+     }
+     else
+         wcsncpy(zip_path, _prefix, MAXPATHLEN);
+-    joinpath(zip_path, L"lib/python00.zip");
+    joinpath(zip_path, L"lib64/python00.zip");
+     bufsz = wcslen(zip_path);   /* Replace "00" with version */
+     zip_path[bufsz - 6] = VERSION[0];
+     zip_path[bufsz - 5] = VERSION[2];
+@@ -695,7 +695,7 @@ calculate_path(void)
+             fprintf(stderr,
+                 "Could not find platform dependent libraries <exec_prefix>\n");
+         wcsncpy(exec_prefix, _exec_prefix, MAXPATHLEN);
+-        joinpath(exec_prefix, L"lib/lib-dynload");
+        joinpath(exec_prefix, L"lib64/lib-dynload");
+     }
+     /* If we found EXEC_PREFIX do *not* reduce it!  (Yet.) */
+ 
+diff --git a/setup.py b/setup.py
+index 0f2dfc4..da37896 100644
+--- a/setup.py
+++ b/setup.py
+@@ -492,7 +492,7 @@ class PyBuildExt(build_ext):
+         # directories (i.e. '.' and 'Include') must be first.  See issue
+         # 10520.
+         if not cross_compiling:
+-            add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib')
+            add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib64')
+             add_dir_to_list(self.compiler.include_dirs, '/usr/local/include')
+         # only change this for cross builds for 3.3, issues on Mageia
+         if cross_compiling:
+@@ -780,11 +780,11 @@ class PyBuildExt(build_ext):
+             elif curses_library:
+                 readline_libs.append(curses_library)
+             elif self.compiler.find_library_file(lib_dirs +
+-                                                     ['/usr/lib/termcap'],
+                                                     ['/usr/lib64/termcap'],
+                                                      'termcap'):
+                 readline_libs.append('termcap')
+             exts.append( Extension('readline', ['readline.c'],
+-                                   library_dirs=['/usr/lib/termcap'],
+                                   library_dirs=['/usr/lib64/termcap'],
+                                    extra_link_args=readline_extra_link_args,
+                                    libraries=readline_libs) )
+         else:
+@@ -821,8 +821,8 @@ class PyBuildExt(build_ext):
+             if krb5_h:
+                 ssl_incs += krb5_h
+         ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
+-                                     ['/usr/local/ssl/lib',
+-                                      '/usr/contrib/ssl/lib/'
+                                     ['/usr/local/ssl/lib64',
+                                      '/usr/contrib/ssl/lib64/'
+                                      ] )
+ 
+         if (ssl_incs is not None and
--- a/SOURCES/00104-lib64-fix-for-test_install.patch
+++ b/SOURCES/00104-lib64-fix-for-test_install.patch
@ -0,0 +1,13 @@
				@@ -0,0 +1,13 @@
+--- Python-2.7.2/Lib/distutils/tests/test_install.py.lib64	2011-09-08 17:51:57.851405376 -0400
+++ Python-2.7.2/Lib/distutils/tests/test_install.py	2011-09-08 18:40:46.754205096 -0400
+@@ -41,8 +41,9 @@ class InstallTestCase(support.TempdirMan
+             self.assertEqual(got, expected)
+ 
+         libdir = os.path.join(destination, "lib", "python")
+        platlibdir = os.path.join(destination, "lib64", "python")
+         check_path(cmd.install_lib, libdir)
+-        check_path(cmd.install_platlib, libdir)
+        check_path(cmd.install_platlib, platlibdir)
+         check_path(cmd.install_purelib, libdir)
+         check_path(cmd.install_headers,
+                    os.path.join(destination, "include", "python", "foopkg"))
--- a/SOURCES/00111-no-static-lib.patch
+++ b/SOURCES/00111-no-static-lib.patch
@ -0,0 +1,60 @@
				@@ -0,0 +1,60 @@
+diff --git a/Makefile.pre.in b/Makefile.pre.in
+index 4b093e3..1088435 100644
+--- a/Makefile.pre.in
+++ b/Makefile.pre.in
+@@ -543,7 +543,7 @@ clinic: check-clean-src $(srcdir)/Modules/_blake2/blake2s_impl.c
+ 	$(PYTHON_FOR_REGEN) ./Tools/clinic/clinic.py --make
+ 
+ # Build the interpreter
+-$(BUILDPYTHON):	Programs/python.o $(LIBRARY) $(LDLIBRARY) $(PY3LIBRARY)
+$(BUILDPYTHON):	Programs/python.o $(LDLIBRARY) $(PY3LIBRARY)
+ 	$(LINKCC) $(PY_LDFLAGS) $(LINKFORSHARED) -o $@ Programs/python.o $(BLDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST)
+ 
+ platform: $(BUILDPYTHON) pybuilddir.txt
+@@ -588,18 +588,6 @@ sharedmods: $(BUILDPYTHON) pybuilddir.txt Modules/_math.o
+ 		$(PYTHON_FOR_BUILD) $(srcdir)/setup.py $$quiet build
+ 
+ 
+-# Build static library
+-# avoid long command lines, same as LIBRARY_OBJS
+-$(LIBRARY): $(LIBRARY_OBJS)
+-	-rm -f $@
+-	$(AR) $(ARFLAGS) $@ Modules/getbuildinfo.o
+-	$(AR) $(ARFLAGS) $@ $(PARSER_OBJS)
+-	$(AR) $(ARFLAGS) $@ $(OBJECT_OBJS)
+-	$(AR) $(ARFLAGS) $@ $(PYTHON_OBJS) Python/frozen.o
+-	$(AR) $(ARFLAGS) $@ $(MODULE_OBJS)
+-	$(AR) $(ARFLAGS) $@ $(MODOBJS)
+-	$(RANLIB) $@
+-
+ libpython$(LDVERSION).so: $(LIBRARY_OBJS)
+ 	if test $(INSTSONAME) != $(LDLIBRARY); then \
+ 		$(BLDSHARED) -Wl,-h$(INSTSONAME) -o $(INSTSONAME) $(LIBRARY_OBJS) $(MODLIBS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST); \
+@@ -689,7 +677,7 @@ Modules/Setup: $(srcdir)/Modules/Setup.dist
+ 		echo "-----------------------------------------------"; \
+ 	fi
+ 
+-Programs/_testembed: Programs/_testembed.o $(LIBRARY) $(LDLIBRARY) $(PY3LIBRARY)
+Programs/_testembed: Programs/_testembed.o $(LDLIBRARY) $(PY3LIBRARY)
+ 	$(LINKCC) $(PY_LDFLAGS) $(LINKFORSHARED) -o $@ Programs/_testembed.o $(BLDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST)
+ 
+ ############################################################################
+@@ -1425,18 +1413,6 @@ libainstall:	@DEF_MAKE_RULE@ python-config
+ 		else	true; \
+ 		fi; \
+ 	done
+-	@if test -d $(LIBRARY); then :; else \
+-		if test "$(PYTHONFRAMEWORKDIR)" = no-framework; then \
+-			if test "$(SHLIB_SUFFIX)" = .dll; then \
+-				$(INSTALL_DATA) $(LDLIBRARY) $(DESTDIR)$(LIBPL) ; \
+-			else \
+-				$(INSTALL_DATA) $(LIBRARY) $(DESTDIR)$(LIBPL)/$(LIBRARY) ; \
+-				$(RANLIB) $(DESTDIR)$(LIBPL)/$(LIBRARY) ; \
+-			fi; \
+-		else \
+-			echo Skip install of $(LIBRARY) - use make frameworkinstall; \
+-		fi; \
+-	fi
+ 	$(INSTALL_DATA) Modules/config.c $(DESTDIR)$(LIBPL)/config.c
+ 	$(INSTALL_DATA) Programs/python.o $(DESTDIR)$(LIBPL)/python.o
+ 	$(INSTALL_DATA) $(srcdir)/Modules/config.c.in $(DESTDIR)$(LIBPL)/config.c.in
--- a/SOURCES/00132-add-rpmbuild-hooks-to-unittest.patch
+++ b/SOURCES/00132-add-rpmbuild-hooks-to-unittest.patch
@ -0,0 +1,46 @@
				@@ -0,0 +1,46 @@
+diff -up Python-3.2.2/Lib/unittest/case.py.add-rpmbuild-hooks-to-unittest Python-3.2.2/Lib/unittest/case.py
+--- Python-3.2.2/Lib/unittest/case.py.add-rpmbuild-hooks-to-unittest	2011-09-03 12:16:44.000000000 -0400
+++ Python-3.2.2/Lib/unittest/case.py	2011-09-09 06:35:16.365568382 -0400
+@@ -3,6 +3,7 @@
+ import sys
+ import functools
+ import difflib
+import os
+ import logging
+ import pprint
+ import re
+@@ -101,5 +102,21 @@ def expectedFailure(func):
+         raise self.test_case.failureException(msg)
+ 
+# Non-standard/downstream-only hooks for handling issues with specific test
+# cases:
+
+def _skipInRpmBuild(reason):
+    """
+    Non-standard/downstream-only decorator for marking a specific unit test
+    to be skipped when run within the %check of an rpmbuild.
+
+    Specifically, this takes effect when WITHIN_PYTHON_RPM_BUILD is set within
+    the environment, and has no effect otherwise.
+    """
+    if 'WITHIN_PYTHON_RPM_BUILD' in os.environ:
+        return skip(reason)
+    else:
+        return _id
+
+ class _AssertRaisesBaseContext(_BaseTestCaseContext):
+ 
+     def __init__(self, expected, test_case, expected_regex=None):
+diff -up Python-3.2.2/Lib/unittest/__init__.py.add-rpmbuild-hooks-to-unittest Python-3.2.2/Lib/unittest/__init__.py
+--- Python-3.2.2/Lib/unittest/__init__.py.add-rpmbuild-hooks-to-unittest	2011-09-03 12:16:44.000000000 -0400
+++ Python-3.2.2/Lib/unittest/__init__.py	2011-09-09 06:35:16.366568382 -0400
+@@ -57,7 +57,8 @@ __unittest = True
+ 
+ from .result import TestResult
+ from .case import (TestCase, FunctionTestCase, SkipTest, skip, skipIf,
+-                   skipUnless, expectedFailure)
+                   skipUnless, expectedFailure,
+                   _skipInRpmBuild)
+ from .suite import BaseTestSuite, TestSuite
+ from .loader import (TestLoader, defaultTestLoader, makeSuite, getTestCaseNames,
+                      findTestCases)
--- a/SOURCES/00137-skip-distutils-tests-that-fail-in-rpmbuild.patch
+++ b/SOURCES/00137-skip-distutils-tests-that-fail-in-rpmbuild.patch
@ -0,0 +1,12 @@
				@@ -0,0 +1,12 @@
+diff -up Python-3.2.2/Lib/distutils/tests/test_bdist_rpm.py.skip-distutils-tests-that-fail-in-rpmbuild Python-3.2.2/Lib/distutils/tests/test_bdist_rpm.py
+--- Python-3.2.2/Lib/distutils/tests/test_bdist_rpm.py.skip-distutils-tests-that-fail-in-rpmbuild	2011-09-03 12:16:40.000000000 -0400
+++ Python-3.2.2/Lib/distutils/tests/test_bdist_rpm.py	2011-09-10 05:04:56.328852558 -0400
+@@ -23,6 +23,7 @@ setup(name='foo', version='0.1', py_modu
+ 
+ """
+ 
+@unittest._skipInRpmBuild("don't try to nest one rpm build inside another rpm build")
+ class BuildRpmTestCase(support.TempdirManager,
+                        support.EnvironGuard,
+                        support.LoggingSilencer,
+diff -up Python-3.2.2/Lib/distutils/tests/test_build_ext.py.skip-distutils-tests-that-fail-in-rpmbuild Python-3.2.2/Lib/distutils/tests/test_build_ext.py
--- a/SOURCES/00146-hashlib-fips.patch
+++ b/SOURCES/00146-hashlib-fips.patch
@ -0,0 +1,640 @@
				@@ -0,0 +1,640 @@
+diff --git a/Lib/hashlib.py b/Lib/hashlib.py
+index 316cece..b7ad879 100644
+--- a/Lib/hashlib.py
+++ b/Lib/hashlib.py
+@@ -23,6 +23,16 @@ the zlib module.
+ Choose your hash function wisely.  Some have known collision weaknesses.
+ sha384 and sha512 will be slow on 32 bit platforms.
+ 
+If the underlying implementation supports "FIPS mode", and this is enabled, it
+may restrict the available hashes to only those that are compliant with FIPS
+regulations.  For example, it may deny the use of MD5, on the grounds that this
+is not secure for uses such as authentication, system integrity checking, or
+digital signatures.   If you need to use such a hash for non-security purposes
+(such as indexing into a data structure for speed), you can override the keyword
+argument "usedforsecurity" from True to False to signify that your code is not
+relying on the hash for security purposes, and this will allow the hash to be
+usable even in FIPS mode.
+
+ Hash objects have these methods:
+  - update(arg): Update the hash object with the bytes in arg. Repeated calls
+                 are equivalent to a single call with the concatenation of all
+@@ -62,6 +72,18 @@ algorithms_available = set(__always_supported)
+ __all__ = __always_supported + ('new', 'algorithms_guaranteed',
+                                 'algorithms_available', 'pbkdf2_hmac')
+ 
+import functools
+def __ignore_usedforsecurity(func):
+    """Used for sha3_* functions. Until OpenSSL implements them, we want
+    to use them from Python _sha3 module, but we want them to accept
+    usedforsecurity argument too."""
+    # TODO: remove this function when OpenSSL implements sha3
+    @functools.wraps(func)
+    def inner(*args, **kwargs):
+        if 'usedforsecurity' in kwargs:
+            kwargs.pop('usedforsecurity')
+        return func(*args, **kwargs)
+    return inner
+ 
+ __builtin_constructor_cache = {}
+ 
+@@ -100,31 +122,39 @@ def __get_openssl_constructor(name):
+         f = getattr(_hashlib, 'openssl_' + name)
+         # Allow the C module to raise ValueError.  The function will be
+         # defined but the hash not actually available thanks to OpenSSL.
+-        f()
+        # We pass "usedforsecurity=False" to disable FIPS-based restrictions:
+        # at this stage we're merely seeing if the function is callable,
+        # rather than using it for actual work.
+        f(usedforsecurity=False)
+         # Use the C function directly (very fast)
+         return f
+     except (AttributeError, ValueError):
+        # TODO: We want to just raise here when OpenSSL implements sha3
+        # because we want to make sure that Fedora uses everything from OpenSSL
+         return __get_builtin_constructor(name)
+ 
+ 
+-def __py_new(name, data=b''):
+-    """new(name, data=b'') - Return a new hashing object using the named algorithm;
+-    optionally initialized with data (which must be bytes).
+def __py_new(name, data=b'', usedforsecurity=True):
+    """new(name, data=b'', usedforsecurity=True) - Return a new hashing object using
+    the named algorithm; optionally initialized with data (which must be bytes).
+    The 'usedforsecurity' keyword argument does nothing, and is for compatibilty
+    with the OpenSSL implementation
+     """
+     return __get_builtin_constructor(name)(data)
+ 
+ 
+-def __hash_new(name, data=b''):
+-    """new(name, data=b'') - Return a new hashing object using the named algorithm;
+-    optionally initialized with data (which must be bytes).
+def __hash_new(name, data=b'', usedforsecurity=True):
+    """new(name, data=b'', usedforsecurity=True) - Return a new hashing object using
+    the named algorithm; optionally initialized with data (which must be bytes).
+    
+    Override 'usedforsecurity' to False when using for non-security purposes in
+    a FIPS environment
+     """
+     try:
+-        return _hashlib.new(name, data)
+        return _hashlib.new(name, data, usedforsecurity)
+     except ValueError:
+-        # If the _hashlib module (OpenSSL) doesn't support the named
+-        # hash, try using our builtin implementations.
+-        # This allows for SHA224/256 and SHA384/512 support even though
+-        # the OpenSSL library prior to 0.9.8 doesn't provide them.
+        # TODO: We want to just raise here when OpenSSL implements sha3
+        # because we want to make sure that Fedora uses everything from OpenSSL
+         return __get_builtin_constructor(name)(data)
+ 
+ 
+@@ -207,7 +237,10 @@ for __func_name in __always_supported:
+     # try them all, some may not work due to the OpenSSL
+     # version not supporting that algorithm.
+     try:
+-        globals()[__func_name] = __get_hash(__func_name)
+        func = __get_hash(__func_name)
+        if 'sha3_' in __func_name:
+            func = __ignore_usedforsecurity(func)
+        globals()[__func_name] = func
+     except ValueError:
+         import logging
+         logging.exception('code for hash %s was not found.', __func_name)
+@@ -215,3 +248,4 @@ for __func_name in __always_supported:
+ # Cleanup locals()
+ del __always_supported, __func_name, __get_hash
+ del __py_new, __hash_new, __get_openssl_constructor
+del __ignore_usedforsecurity
+\ No newline at end of file
+diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py
+index c9b113e..60e2392 100644
+--- a/Lib/test/test_hashlib.py
+++ b/Lib/test/test_hashlib.py
+@@ -24,7 +24,22 @@ from test.support import _4G, bigmemtest, import_fresh_module
+ COMPILED_WITH_PYDEBUG = hasattr(sys, 'gettotalrefcount')
+ 
+ c_hashlib = import_fresh_module('hashlib', fresh=['_hashlib'])
+-py_hashlib = import_fresh_module('hashlib', blocked=['_hashlib'])
+# skipped on Fedora, since we always use OpenSSL implementation
+# py_hashlib = import_fresh_module('hashlib', blocked=['_hashlib'])
+
+def openssl_enforces_fips():
+    # Use the "openssl" command (if present) to try to determine if the local
+    # OpenSSL is configured to enforce FIPS
+    from subprocess import Popen, PIPE
+    try:
+        p = Popen(['openssl', 'md5'],
+                  stdin=PIPE, stdout=PIPE, stderr=PIPE)
+    except OSError:
+        # "openssl" command not found
+        return False
+    stdout, stderr = p.communicate(input=b'abc')
+    return b'unknown cipher' in stderr
+OPENSSL_ENFORCES_FIPS = openssl_enforces_fips()
+ 
+ def hexstr(s):
+     assert isinstance(s, bytes), repr(s)
+@@ -34,6 +49,16 @@ def hexstr(s):
+         r += h[(i >> 4) & 0xF] + h[i & 0xF]
+     return r
+ 
+# hashlib and _hashlib-based functions support a "usedforsecurity" keyword
+# argument, and FIPS mode requires that it be used overridden with a False
+# value for these selftests to work.  Other cryptographic code within Python
+# doesn't support this keyword.
+# Modify a function to one in which "usedforsecurity=False" is added to the
+# keyword arguments:
+def suppress_fips(f):
+    def g(*args, **kwargs):
+        return f(*args, usedforsecurity=False, **kwargs)
+    return g
+ 
+ class HashLibTestCase(unittest.TestCase):
+     supported_hash_names = ( 'md5', 'MD5', 'sha1', 'SHA1',
+@@ -63,11 +88,11 @@ class HashLibTestCase(unittest.TestCase):
+         # For each algorithm, test the direct constructor and the use
+         # of hashlib.new given the algorithm name.
+         for algorithm, constructors in self.constructors_to_test.items():
+-            constructors.add(getattr(hashlib, algorithm))
+            constructors.add(suppress_fips(getattr(hashlib, algorithm)))
+             def _test_algorithm_via_hashlib_new(data=None, _alg=algorithm):
+                 if data is None:
+-                    return hashlib.new(_alg)
+-                return hashlib.new(_alg, data)
+                    return suppress_fips(hashlib.new)(_alg)
+                return suppress_fips(hashlib.new)(_alg, data)
+             constructors.add(_test_algorithm_via_hashlib_new)
+ 
+         _hashlib = self._conditional_import_module('_hashlib')
+@@ -79,27 +104,12 @@ class HashLibTestCase(unittest.TestCase):
+             for algorithm, constructors in self.constructors_to_test.items():
+                 constructor = getattr(_hashlib, 'openssl_'+algorithm, None)
+                 if constructor:
+-                    constructors.add(constructor)
+                    constructors.add(suppress_fips(constructor))
+ 
+         def add_builtin_constructor(name):
+             constructor = getattr(hashlib, "__get_builtin_constructor")(name)
+             self.constructors_to_test[name].add(constructor)
+ 
+-        _md5 = self._conditional_import_module('_md5')
+-        if _md5:
+-            add_builtin_constructor('md5')
+-        _sha1 = self._conditional_import_module('_sha1')
+-        if _sha1:
+-            add_builtin_constructor('sha1')
+-        _sha256 = self._conditional_import_module('_sha256')
+-        if _sha256:
+-            add_builtin_constructor('sha224')
+-            add_builtin_constructor('sha256')
+-        _sha512 = self._conditional_import_module('_sha512')
+-        if _sha512:
+-            add_builtin_constructor('sha384')
+-            add_builtin_constructor('sha512')
+-
+         super(HashLibTestCase, self).__init__(*args, **kwargs)
+ 
+     @property
+@@ -148,9 +158,6 @@ class HashLibTestCase(unittest.TestCase):
+             else:
+                 del sys.modules['_md5']
+         self.assertRaises(TypeError, get_builtin_constructor, 3)
+-        constructor = get_builtin_constructor('md5')
+-        self.assertIs(constructor, _md5.md5)
+-        self.assertEqual(sorted(builtin_constructor_cache), ['MD5', 'md5'])
+ 
+     def test_hexdigest(self):
+         for cons in self.hash_constructors:
+@@ -433,6 +440,64 @@ class HashLibTestCase(unittest.TestCase):
+ 
+         self.assertEqual(expected_hash, hasher.hexdigest())
+ 
+    def test_issue9146(self):
+        # Ensure that various ways to use "MD5" from "hashlib" don't segfault:
+        m = hashlib.md5(usedforsecurity=False)
+        m.update(b'abc\n')
+        self.assertEquals(m.hexdigest(), "0bee89b07a248e27c83fc3d5951213c1")
+        
+        m = hashlib.new('md5', usedforsecurity=False)
+        m.update(b'abc\n')
+        self.assertEquals(m.hexdigest(), "0bee89b07a248e27c83fc3d5951213c1")
+        
+        m = hashlib.md5(b'abc\n', usedforsecurity=False)
+        self.assertEquals(m.hexdigest(), "0bee89b07a248e27c83fc3d5951213c1")
+        
+        m = hashlib.new('md5', b'abc\n', usedforsecurity=False)
+        self.assertEquals(m.hexdigest(), "0bee89b07a248e27c83fc3d5951213c1")
+
+    @unittest.skipUnless(OPENSSL_ENFORCES_FIPS,
+                         'FIPS enforcement required for this test.')
+    def test_hashlib_fips_mode(self):        
+        # Ensure that we raise a ValueError on vanilla attempts to use MD5
+        # in hashlib in a FIPS-enforced setting:
+        with self.assertRaisesRegexp(ValueError, '.*unknown cipher'):
+            m = hashlib.md5()
+            
+        if not self._conditional_import_module('_md5'):
+            with self.assertRaisesRegexp(ValueError, '.*unknown cipher'):
+                m = hashlib.new('md5')
+
+    @unittest.skipUnless(OPENSSL_ENFORCES_FIPS,
+                         'FIPS enforcement required for this test.')
+    def test_hashopenssl_fips_mode(self):
+        # Verify the _hashlib module's handling of md5:
+        _hashlib = self._conditional_import_module('_hashlib')
+        if _hashlib:
+            assert hasattr(_hashlib, 'openssl_md5')
+
+            # Ensure that _hashlib raises a ValueError on vanilla attempts to
+            # use MD5 in a FIPS-enforced setting:
+            with self.assertRaisesRegexp(ValueError, '.*unknown cipher'):
+                m = _hashlib.openssl_md5()
+            with self.assertRaisesRegexp(ValueError, '.*unknown cipher'):
+                m = _hashlib.new('md5')
+
+            # Ensure that in such a setting we can whitelist a callsite with
+            # usedforsecurity=False and have it succeed:
+            m = _hashlib.openssl_md5(usedforsecurity=False)
+            m.update(b'abc\n')
+            self.assertEquals(m.hexdigest(), "0bee89b07a248e27c83fc3d5951213c1")
+        
+            m = _hashlib.new('md5', usedforsecurity=False)
+            m.update(b'abc\n')
+            self.assertEquals(m.hexdigest(), "0bee89b07a248e27c83fc3d5951213c1")
+       
+            m = _hashlib.openssl_md5(b'abc\n', usedforsecurity=False)
+            self.assertEquals(m.hexdigest(), "0bee89b07a248e27c83fc3d5951213c1")
+        
+            m = _hashlib.new('md5', b'abc\n', usedforsecurity=False)
+            self.assertEquals(m.hexdigest(), "0bee89b07a248e27c83fc3d5951213c1")
+ 
+ class KDFTests(unittest.TestCase):
+ 
+@@ -516,7 +581,7 @@ class KDFTests(unittest.TestCase):
+         out = pbkdf2(hash_name='sha1', password=b'password', salt=b'salt',
+             iterations=1, dklen=None)
+         self.assertEqual(out, self.pbkdf2_results['sha1'][0][0])
+-
+    @unittest.skip('skipped on Fedora, as we always use OpenSSL pbkdf2_hmac')
+     def test_pbkdf2_hmac_py(self):
+         self._test_pbkdf2_hmac(py_hashlib.pbkdf2_hmac)
+ 
+diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c
+index 44765ac..b8cf490 100644
+--- a/Modules/_hashopenssl.c
+++ b/Modules/_hashopenssl.c
+@@ -20,6 +20,8 @@
+ 
+ 
+ /* EVP is the preferred interface to hashing in OpenSSL */
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+ #include <openssl/evp.h>
+ #include <openssl/hmac.h>
+ /* We use the object interface to discover what hashes OpenSSL supports. */
+@@ -45,11 +47,19 @@ typedef struct {
+ 
+ static PyTypeObject EVPtype;
+ 
+/* Struct to hold all the cached information we need on a specific algorithm.
+   We have one of these per algorithm */
+typedef struct {
+    PyObject *name_obj;
+    EVP_MD_CTX ctxs[2];
+    /* ctx_ptrs will point to ctxs unless an error occurred, when it will
+       be NULL: */
+    EVP_MD_CTX *ctx_ptrs[2];
+    PyObject *error_msgs[2];
+} EVPCachedInfo;
+ 
+-#define DEFINE_CONSTS_FOR_NEW(Name)  \
+-    static PyObject *CONST_ ## Name ## _name_obj = NULL; \
+-    static EVP_MD_CTX CONST_new_ ## Name ## _ctx; \
+-    static EVP_MD_CTX *CONST_new_ ## Name ## _ctx_p = NULL;
+#define DEFINE_CONSTS_FOR_NEW(Name) \
+    static EVPCachedInfo cached_info_ ##Name;
+ 
+ DEFINE_CONSTS_FOR_NEW(md5)
+ DEFINE_CONSTS_FOR_NEW(sha1)
+@@ -92,6 +102,48 @@ EVP_hash(EVPobject *self, const void *vp, Py_ssize_t len)
+     }
+ }
+ 
+static void
+mc_ctx_init(EVP_MD_CTX *ctx, int usedforsecurity)
+{
+    EVP_MD_CTX_init(ctx);
+
+    /*
+      If the user has declared that this digest is being used in a
+      non-security role (e.g. indexing into a data structure), set
+      the exception flag for openssl to allow it
+    */
+    if (!usedforsecurity) {
+#ifdef EVP_MD_CTX_FLAG_NON_FIPS_ALLOW
+        EVP_MD_CTX_set_flags(ctx,
+                             EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
+#endif
+    }
+}
+
+/* Get an error msg for the last error as a PyObject */
+static PyObject *
+error_msg_for_last_error(void)
+{
+    char *errstr;
+
+    errstr = ERR_error_string(ERR_peek_last_error(), NULL);
+    ERR_clear_error();
+
+    return PyUnicode_FromString(errstr); /* Can be NULL */
+}
+
+static void
+set_evp_exception(void)
+{
+    char *errstr;
+
+    errstr = ERR_error_string(ERR_peek_last_error(), NULL);
+    ERR_clear_error();
+
+    PyErr_SetString(PyExc_ValueError, errstr);
+}
+
+
+ /* Internal methods for a hash object */
+ 
+ static void
+@@ -259,15 +311,16 @@ EVP_repr(EVPobject *self)
+ static int
+ EVP_tp_init(EVPobject *self, PyObject *args, PyObject *kwds)
+ {
+-    static char *kwlist[] = {"name", "string", NULL};
+    static char *kwlist[] = {"name", "string", "usedforsecurity", NULL};
+     PyObject *name_obj = NULL;
+     PyObject *data_obj = NULL;
+    int usedforsecurity = 1;
+     Py_buffer view;
+     char *nameStr;
+     const EVP_MD *digest;
+ 
+-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:HASH", kwlist,
+-                                     &name_obj, &data_obj)) {
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|Oi:HASH", kwlist,
+                                     &name_obj, &data_obj, &usedforsecurity)) {
+         return -1;
+     }
+ 
+@@ -288,7 +341,12 @@ EVP_tp_init(EVPobject *self, PyObject *args, PyObject *kwds)
+             PyBuffer_Release(&view);
+         return -1;
+     }
+-    EVP_DigestInit(&self->ctx, digest);
+    mc_ctx_init(&self->ctx, usedforsecurity);
+    if (!EVP_DigestInit_ex(&self->ctx, digest, NULL)) {
+        set_evp_exception();
+        PyBuffer_Release(&view);
+        return -1;
+    }
+ 
+     self->name = name_obj;
+     Py_INCREF(self->name);
+@@ -372,7 +430,8 @@ static PyTypeObject EVPtype = {
+ static PyObject *
+ EVPnew(PyObject *name_obj,
+        const EVP_MD *digest, const EVP_MD_CTX *initial_ctx,
+-       const unsigned char *cp, Py_ssize_t len)
+       const unsigned char *cp, Py_ssize_t len,
+       int usedforsecurity)
+ {
+     EVPobject *self;
+ 
+@@ -387,7 +446,12 @@ EVPnew(PyObject *name_obj,
+     if (initial_ctx) {
+         EVP_MD_CTX_copy(&self->ctx, initial_ctx);
+     } else {
+-        EVP_DigestInit(&self->ctx, digest);
+        mc_ctx_init(&self->ctx, usedforsecurity);
+        if (!EVP_DigestInit_ex(&self->ctx, digest, NULL)) {
+            set_evp_exception();
+            Py_DECREF(self);
+            return NULL;
+        }
+     }
+ 
+     if (cp && len) {
+@@ -411,21 +475,29 @@ PyDoc_STRVAR(EVP_new__doc__,
+ An optional string argument may be provided and will be\n\
+ automatically hashed.\n\
+ \n\
+-The MD5 and SHA1 algorithms are always supported.\n");
+The MD5 and SHA1 algorithms are always supported.\n\
+\n\
+An optional \"usedforsecurity=True\" keyword argument is provided for use in\n\
+environments that enforce FIPS-based restrictions.  Some implementations of\n\
+OpenSSL can be configured to prevent the usage of non-secure algorithms (such\n\
+as MD5).  If you have a non-security use for these algorithms (e.g. a hash\n\
+table), you can override this argument by marking the callsite as\n\
+\"usedforsecurity=False\".");
+ 
+ static PyObject *
+ EVP_new(PyObject *self, PyObject *args, PyObject *kwdict)
+ {
+-    static char *kwlist[] = {"name", "string", NULL};
+    static char *kwlist[] = {"name", "string", "usedforsecurity", NULL};
+     PyObject *name_obj = NULL;
+     PyObject *data_obj = NULL;
+    int usedforsecurity = 1;
+     Py_buffer view = { 0 };
+     PyObject *ret_obj;
+     char *name;
+     const EVP_MD *digest;
+ 
+-    if (!PyArg_ParseTupleAndKeywords(args, kwdict, "O|O:new", kwlist,
+-                                     &name_obj, &data_obj)) {
+    if (!PyArg_ParseTupleAndKeywords(args, kwdict, "O|Oi:new", kwlist,
+                                     &name_obj, &data_obj, &usedforsecurity)) {
+         return NULL;
+     }
+ 
+@@ -439,7 +511,8 @@ EVP_new(PyObject *self, PyObject *args, PyObject *kwdict)
+ 
+     digest = EVP_get_digestbyname(name);
+ 
+-    ret_obj = EVPnew(name_obj, digest, NULL, (unsigned char*)view.buf, view.len);
+    ret_obj = EVPnew(name_obj, digest, NULL, (unsigned char*)view.buf, view.len,
+                    usedforsecurity);
+ 
+     if (data_obj)
+         PyBuffer_Release(&view);
+@@ -722,57 +795,114 @@ generate_hash_name_list(void)
+ 
+ 
+ /*
+- *  This macro generates constructor function definitions for specific
+- *  hash algorithms.  These constructors are much faster than calling
+- *  the generic one passing it a python string and are noticably
+- *  faster than calling a python new() wrapper.  Thats important for
+ *  This macro and function generates a family of constructor function
+ *  definitions for specific hash algorithms.  These constructors are much
+ *  faster than calling the generic one passing it a python string and are
+ *  noticably faster than calling a python new() wrapper.  That's important for
+  *  code that wants to make hashes of a bunch of small strings.
+  */
+ #define GEN_CONSTRUCTOR(NAME)  \
+     static PyObject * \
+-    EVP_new_ ## NAME (PyObject *self, PyObject *args) \
+    EVP_new_ ## NAME (PyObject *self, PyObject *args, PyObject *kwdict)        \
+     { \
+-        PyObject *data_obj = NULL; \
+-        Py_buffer view = { 0 }; \
+-        PyObject *ret_obj; \
+-     \
+-        if (!PyArg_ParseTuple(args, "|O:" #NAME , &data_obj)) { \
+-            return NULL; \
+-        } \
+-     \
+-        if (data_obj) \
+-            GET_BUFFER_VIEW_OR_ERROUT(data_obj, &view); \
+-     \
+-        ret_obj = EVPnew( \
+-                    CONST_ ## NAME ## _name_obj, \
+-                    NULL, \
+-                    CONST_new_ ## NAME ## _ctx_p, \
+-                    (unsigned char*)view.buf, \
+-                    view.len); \
+-     \
+-        if (data_obj) \
+-            PyBuffer_Release(&view); \
+-        return ret_obj; \
+       return implement_specific_EVP_new(self, args, kwdict,      \
+                                         "|Oi:" #NAME,            \
+                                         &cached_info_ ## NAME ); \
+     }
+ 
+static PyObject *
+implement_specific_EVP_new(PyObject *self, PyObject *args, PyObject *kwdict,
+                           const char *format,
+                           EVPCachedInfo *cached_info)
+{
+    static char *kwlist[] = {"string", "usedforsecurity", NULL}; 
+    PyObject *data_obj = NULL;
+    Py_buffer view = { 0 };
+    int usedforsecurity = 1;
+    int idx;
+    PyObject *ret_obj = NULL;
+
+    assert(cached_info);
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwdict, format, kwlist,
+                                     &data_obj, &usedforsecurity)) {
+        return NULL;
+    }
+
+    if (data_obj)
+       GET_BUFFER_VIEW_OR_ERROUT(data_obj, &view);
+
+    idx = usedforsecurity ? 1 : 0;
+
+    /*
+     * If an error occurred during creation of the global content, the ctx_ptr
+     * will be NULL, and the error_msg will hopefully be non-NULL:
+     */
+    if (cached_info->ctx_ptrs[idx]) {
+        /* We successfully initialized this context; copy it: */
+        ret_obj = EVPnew(cached_info->name_obj,
+                         NULL,
+                         cached_info->ctx_ptrs[idx],
+                         (unsigned char*)view.buf, view.len,
+                         usedforsecurity);
+    } else {
+        /* Some kind of error happened initializing the global context for
+           this (digest, usedforsecurity) pair.
+           Raise an exception with the saved error message: */
+        if (cached_info->error_msgs[idx]) {
+            PyErr_SetObject(PyExc_ValueError, cached_info->error_msgs[idx]);
+        } else {
+            PyErr_SetString(PyExc_ValueError, "Error initializing hash");
+        }
+     }
+ 
+    if (data_obj)
+        PyBuffer_Release(&view);
+
+    return ret_obj;
+}
+
+ /* a PyMethodDef structure for the constructor */
+ #define CONSTRUCTOR_METH_DEF(NAME)  \
+-    {"openssl_" #NAME, (PyCFunction)EVP_new_ ## NAME, METH_VARARGS, \
+    {"openssl_" #NAME, (PyCFunction)EVP_new_ ## NAME, \
+        METH_VARARGS|METH_KEYWORDS, \
+         PyDoc_STR("Returns a " #NAME \
+                   " hash object; optionally initialized with a string") \
+     }
+ 
+-/* used in the init function to setup a constructor: initialize OpenSSL
+-   constructor constants if they haven't been initialized already.  */
+-#define INIT_CONSTRUCTOR_CONSTANTS(NAME)  do { \
+-    if (CONST_ ## NAME ## _name_obj == NULL) { \
+-        CONST_ ## NAME ## _name_obj = PyUnicode_FromString(#NAME); \
+-        if (EVP_get_digestbyname(#NAME)) { \
+-            CONST_new_ ## NAME ## _ctx_p = &CONST_new_ ## NAME ## _ctx; \
+-            EVP_DigestInit(CONST_new_ ## NAME ## _ctx_p, EVP_get_digestbyname(#NAME)); \
+-        } \
+-    } \
+/*
+  Macro/function pair to set up the constructors.
+
+  Try to initialize a context for each hash twice, once with
+  EVP_MD_CTX_FLAG_NON_FIPS_ALLOW and once without.
+  
+  Any that have errors during initialization will end up with a NULL ctx_ptrs
+  entry, and err_msgs will be set (unless we're very low on memory)
+*/
+#define INIT_CONSTRUCTOR_CONSTANTS(NAME)  do {    \
+    init_constructor_constant(&cached_info_ ## NAME, #NAME); \
+ } while (0);
+static void
+init_constructor_constant(EVPCachedInfo *cached_info, const char *name)
+{
+    assert(cached_info);
+    cached_info->name_obj = PyUnicode_FromString(name);
+    if (EVP_get_digestbyname(name)) {
+        int i;
+        for (i=0; i<2; i++) {
+            mc_ctx_init(&cached_info->ctxs[i], i);
+            if (EVP_DigestInit_ex(&cached_info->ctxs[i],
+                                  EVP_get_digestbyname(name), NULL)) {
+                /* Success: */
+                cached_info->ctx_ptrs[i] = &cached_info->ctxs[i];
+            } else {
+                /* Failure: */
+              cached_info->ctx_ptrs[i] = NULL;
+              cached_info->error_msgs[i] = error_msg_for_last_error();
+            }
+        }
+    }
+}
+ 
+ GEN_CONSTRUCTOR(md5)
+ GEN_CONSTRUCTOR(sha1)
+@@ -819,13 +949,10 @@ PyInit__hashlib(void)
+ {
+     PyObject *m, *openssl_md_meth_names;
+ 
+-    OpenSSL_add_all_digests();
+-    ERR_load_crypto_strings();
+    SSL_load_error_strings();
+    SSL_library_init();
+ 
+-    /* TODO build EVP_functions openssl_* entries dynamically based
+-     * on what hashes are supported rather than listing many
+-     * but having some be unsupported.  Only init appropriate
+-     * constants. */
+    OpenSSL_add_all_digests();
+ 
+     Py_TYPE(&EVPtype) = &PyType_Type;
+     if (PyType_Ready(&EVPtype) < 0)
--- a/SOURCES/00155-avoid-ctypes-thunks.patch
+++ b/SOURCES/00155-avoid-ctypes-thunks.patch
@ -0,0 +1,15 @@
				@@ -0,0 +1,15 @@
+diff -up Python-3.2.3/Lib/ctypes/__init__.py.rhbz814391 Python-3.2.3/Lib/ctypes/__init__.py
+--- Python-3.2.3/Lib/ctypes/__init__.py.rhbz814391	2012-04-20 15:12:49.017867692 -0400
+++ Python-3.2.3/Lib/ctypes/__init__.py	2012-04-20 15:15:09.501111408 -0400
+@@ -275,11 +275,6 @@ def _reset_cache():
+     # _SimpleCData.c_char_p_from_param
+     POINTER(c_char).from_param = c_char_p.from_param
+     _pointer_type_cache[None] = c_void_p
+-    # XXX for whatever reasons, creating the first instance of a callback
+-    # function is needed for the unittests on Win64 to succeed.  This MAY
+-    # be a compiler bug, since the problem occurs only when _ctypes is
+-    # compiled with the MS SDK compiler.  Or an uninitialized variable?
+-    CFUNCTYPE(c_int)(lambda: None)
+ 
+ def create_unicode_buffer(init, size=None):
+     """create_unicode_buffer(aString) -> character array
--- a/SOURCES/00157-uid-gid-overflows.patch
+++ b/SOURCES/00157-uid-gid-overflows.patch
@ -0,0 +1,68 @@
				@@ -0,0 +1,68 @@
+diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
+index e9fdb07..ea60e6e 100644
+--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
+@@ -1723,30 +1723,36 @@ class PosixUidGidTests(unittest.TestCase):
+     def test_setuid(self):
+         if os.getuid() != 0:
+             self.assertRaises(OSError, os.setuid, 0)
+        self.assertRaises(TypeError, os.setuid, 'not an int')
+         self.assertRaises(OverflowError, os.setuid, 1<<32)
+ 
+     @unittest.skipUnless(hasattr(os, 'setgid'), 'test needs os.setgid()')
+     def test_setgid(self):
+         if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
+             self.assertRaises(OSError, os.setgid, 0)
+        self.assertRaises(TypeError, os.setgid, 'not an int')
+         self.assertRaises(OverflowError, os.setgid, 1<<32)
+ 
+     @unittest.skipUnless(hasattr(os, 'seteuid'), 'test needs os.seteuid()')
+     def test_seteuid(self):
+         if os.getuid() != 0:
+             self.assertRaises(OSError, os.seteuid, 0)
+        self.assertRaises(TypeError, os.seteuid, 'not an int')
+         self.assertRaises(OverflowError, os.seteuid, 1<<32)
+ 
+     @unittest.skipUnless(hasattr(os, 'setegid'), 'test needs os.setegid()')
+     def test_setegid(self):
+         if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
+             self.assertRaises(OSError, os.setegid, 0)
+        self.assertRaises(TypeError, os.setegid, 'not an int')
+         self.assertRaises(OverflowError, os.setegid, 1<<32)
+ 
+     @unittest.skipUnless(hasattr(os, 'setreuid'), 'test needs os.setreuid()')
+     def test_setreuid(self):
+         if os.getuid() != 0:
+             self.assertRaises(OSError, os.setreuid, 0, 0)
+        self.assertRaises(TypeError, os.setreuid, 'not an int', 0)
+        self.assertRaises(TypeError, os.setreuid, 0, 'not an int')
+         self.assertRaises(OverflowError, os.setreuid, 1<<32, 0)
+         self.assertRaises(OverflowError, os.setreuid, 0, 1<<32)
+ 
+@@ -1762,6 +1768,8 @@ class PosixUidGidTests(unittest.TestCase):
+     def test_setregid(self):
+         if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
+             self.assertRaises(OSError, os.setregid, 0, 0)
+        self.assertRaises(TypeError, os.setregid, 'not an int', 0)
+        self.assertRaises(TypeError, os.setregid, 0, 'not an int')
+         self.assertRaises(OverflowError, os.setregid, 1<<32, 0)
+         self.assertRaises(OverflowError, os.setregid, 0, 1<<32)
+ 
+diff --git a/Lib/test/test_pwd.py b/Lib/test/test_pwd.py
+index ac9cff7..db98159 100644
+--- a/Lib/test/test_pwd.py
+++ b/Lib/test/test_pwd.py
+@@ -104,11 +104,11 @@ class PwdTest(unittest.TestCase):
+         # In some cases, byuids isn't a complete list of all users in the
+         # system, so if we try to pick a value not in byuids (via a perturbing
+         # loop, say), pwd.getpwuid() might still be able to find data for that
+-        # uid. Using sys.maxint may provoke the same problems, but hopefully
+        # uid. Using 2**32 - 2 may provoke the same problems, but hopefully
+         # it will be a more repeatable failure.
+         # Android accepts a very large span of uids including sys.maxsize and
+         # -1; it raises KeyError with 1 or 2 for example.
+-        fakeuid = sys.maxsize
+        fakeuid = 2**32 - 2
+         self.assertNotIn(fakeuid, byuids)
+         if not support.is_android:
+             self.assertRaises(KeyError, pwd.getpwuid, fakeuid)
--- a/SOURCES/00160-disable-test_fs_holes-in-rpm-build.patch
+++ b/SOURCES/00160-disable-test_fs_holes-in-rpm-build.patch
@ -0,0 +1,11 @@
				@@ -0,0 +1,11 @@
+diff -up cpython-59223da36dec/Lib/test/test_posix.py.disable-test_fs_holes-in-rpm-build cpython-59223da36dec/Lib/test/test_posix.py
+--- cpython-59223da36dec/Lib/test/test_posix.py.disable-test_fs_holes-in-rpm-build	2012-08-07 17:15:59.000000000 -0400
+++ cpython-59223da36dec/Lib/test/test_posix.py	2012-08-07 17:16:53.528330330 -0400
+@@ -973,6 +973,7 @@ class PosixTester(unittest.TestCase):
+         posix.RTLD_GLOBAL
+         posix.RTLD_LOCAL
+ 
+    @unittest._skipInRpmBuild('running kernel may not match kernel in chroot')
+     @unittest.skipUnless(hasattr(os, 'SEEK_HOLE'),
+                          "test needs an OS that reports file holes")
+     def test_fs_holes(self):
--- a/SOURCES/00163-disable-parts-of-test_socket-in-rpm-build.patch
+++ b/SOURCES/00163-disable-parts-of-test_socket-in-rpm-build.patch
@ -0,0 +1,11 @@
				@@ -0,0 +1,11 @@
+diff -up Python-3.3.0b1/Lib/test/test_socket.py.disable-test_socket-in-rpm-builds Python-3.3.0b1/Lib/test/test_socket.py
+--- Python-3.3.0b1/Lib/test/test_socket.py.disable-test_socket-in-rpm-builds	2012-07-24 15:02:30.823355067 -0400
+++ Python-3.3.0b1/Lib/test/test_socket.py	2012-07-24 15:08:13.021354999 -0400
+@@ -2188,6 +2188,7 @@ class RecvmsgGenericStreamTests(RecvmsgG
+     # Tests which require a stream socket and can use either recvmsg()
+     # or recvmsg_into().
+ 
+    @unittest._skipInRpmBuild('fails intermittently when run within Koji')
+     def testRecvmsgEOF(self):
+         # Receive end-of-stream indicator (b"", peer socket closed).
+         msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock, 1024)
--- a/SOURCES/00170-gc-assertions.patch
+++ b/SOURCES/00170-gc-assertions.patch
@ -0,0 +1,310 @@
				@@ -0,0 +1,310 @@
+diff --git a/Include/object.h b/Include/object.h
+index 0c88603..e3413e8 100644
+--- a/Include/object.h
+++ b/Include/object.h
+@@ -1059,6 +1059,49 @@ PyAPI_FUNC(void)
+ _PyObject_DebugTypeStats(FILE *out);
+ #endif /* ifndef Py_LIMITED_API */
+ 
+/* 
+   Define a pair of assertion macros.
+
+   These work like the regular C assert(), in that they will abort the
+   process with a message on stderr if the given condition fails to hold,
+   but compile away to nothing if NDEBUG is defined.
+
+   However, before aborting, Python will also try to call _PyObject_Dump() on
+   the given object.  This may be of use when investigating bugs in which a
+   particular object is corrupt (e.g. buggy a tp_visit method in an extension
+   module breaking the garbage collector), to help locate the broken objects.
+
+   The WITH_MSG variant allows you to supply an additional message that Python
+   will attempt to print to stderr, after the object dump.
+*/
+#ifdef NDEBUG
+/* No debugging: compile away the assertions: */
+#define PyObject_ASSERT_WITH_MSG(obj, expr, msg) ((void)0)
+#else
+/* With debugging: generate checks: */
+#define PyObject_ASSERT_WITH_MSG(obj, expr, msg) \
+  ((expr)                                           \
+   ? (void)(0)                                      \
+   : _PyObject_AssertFailed((obj),                  \
+                            (msg),                  \
+                            (__STRING(expr)),       \
+                            (__FILE__),             \
+                            (__LINE__),             \
+                            (__PRETTY_FUNCTION__)))
+#endif
+
+#define PyObject_ASSERT(obj, expr) \
+  PyObject_ASSERT_WITH_MSG(obj, expr, NULL)
+
+/* 
+   Declare and define the entrypoint even when NDEBUG is defined, to avoid
+   causing compiler/linker errors when building extensions without NDEBUG
+   against a Python built with NDEBUG defined
+*/
+PyAPI_FUNC(void) _PyObject_AssertFailed(PyObject *,  const char *,
+                                        const char *, const char *, int,
+                                        const char *);
+
+ #ifdef __cplusplus
+ }
+ #endif
+diff --git a/Lib/test/test_gc.py b/Lib/test/test_gc.py
+index e727499..6efcafb 100644
+--- a/Lib/test/test_gc.py
+++ b/Lib/test/test_gc.py
+@@ -1,10 +1,11 @@
+ import unittest
+ from test.support import (verbose, refcount_test, run_unittest,
+                           strip_python_stderr, cpython_only, start_threads,
+-                          temp_dir, requires_type_collecting)
+                          temp_dir, import_module, requires_type_collecting)
+ from test.support.script_helper import assert_python_ok, make_script
+ 
+ import sys
+import sysconfig
+ import time
+ import gc
+ import weakref
+@@ -50,6 +51,8 @@ class GC_Detector(object):
+         # gc collects it.
+         self.wr = weakref.ref(C1055820(666), it_happened)
+ 
+BUILD_WITH_NDEBUG = ('-DNDEBUG' in sysconfig.get_config_vars()['PY_CFLAGS'])
+
+ @with_tp_del
+ class Uncollectable(object):
+     """Create a reference cycle with multiple __del__ methods.
+@@ -862,6 +865,50 @@ class GCCallbackTests(unittest.TestCase):
+         self.assertEqual(len(gc.garbage), 0)
+ 
+ 
+    @unittest.skipIf(BUILD_WITH_NDEBUG,
+                     'built with -NDEBUG')
+    def test_refcount_errors(self):
+        self.preclean()
+        # Verify the "handling" of objects with broken refcounts
+        import_module("ctypes") #skip if not supported
+
+        import subprocess
+        code = '''if 1:
+        a = []
+        b = [a]
+
+        # Simulate the refcount of "a" being too low (compared to the
+        # references held on it by live data), but keeping it above zero
+        # (to avoid deallocating it):
+        import ctypes
+        ctypes.pythonapi.Py_DecRef(ctypes.py_object(a))
+
+        # The garbage collector should now have a fatal error when it reaches
+        # the broken object:
+        import gc
+        gc.collect()
+        '''
+        p = subprocess.Popen([sys.executable, "-c", code],
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+        stdout, stderr = p.communicate()
+        p.stdout.close()
+        p.stderr.close()
+        # Verify that stderr has a useful error message:
+        self.assertRegex(stderr,
+            b'Modules/gcmodule.c:[0-9]+: visit_decref: Assertion "\(\(gc\)->gc.gc_refs >> \(1\)\) != 0" failed.')
+        self.assertRegex(stderr,
+            b'refcount was too small')
+        self.assertRegex(stderr,
+            b'object  : \[\]')
+        self.assertRegex(stderr,
+            b'type    : list')
+        self.assertRegex(stderr,
+            b'refcount: 1')
+        self.assertRegex(stderr,
+            b'address : 0x[0-9a-f]+')
+
+
+ class GCTogglingTests(unittest.TestCase):
+     def setUp(self):
+         gc.enable()
+diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c
+index 0c6f444..87edd5a 100644
+--- a/Modules/gcmodule.c
+++ b/Modules/gcmodule.c
+@@ -341,7 +341,8 @@ update_refs(PyGC_Head *containers)
+ {
+     PyGC_Head *gc = containers->gc.gc_next;
+     for (; gc != containers; gc = gc->gc.gc_next) {
+-        assert(_PyGCHead_REFS(gc) == GC_REACHABLE);
+        PyObject_ASSERT(FROM_GC(gc),
+                        _PyGCHead_REFS(gc) == GC_REACHABLE);
+         _PyGCHead_SET_REFS(gc, Py_REFCNT(FROM_GC(gc)));
+         /* Python's cyclic gc should never see an incoming refcount
+          * of 0:  if something decref'ed to 0, it should have been
+@@ -361,7 +362,8 @@ update_refs(PyGC_Head *containers)
+          * so serious that maybe this should be a release-build
+          * check instead of an assert?
+          */
+-        assert(_PyGCHead_REFS(gc) != 0);
+        PyObject_ASSERT(FROM_GC(gc),
+                        _PyGCHead_REFS(gc) != 0);
+     }
+ }
+ 
+@@ -376,7 +378,9 @@ visit_decref(PyObject *op, void *data)
+          * generation being collected, which can be recognized
+          * because only they have positive gc_refs.
+          */
+-        assert(_PyGCHead_REFS(gc) != 0); /* else refcount was too small */
+        PyObject_ASSERT_WITH_MSG(FROM_GC(gc),
+                        _PyGCHead_REFS(gc) != 0,
+                        "refcount was too small"); /* else refcount was too small */
+         if (_PyGCHead_REFS(gc) > 0)
+             _PyGCHead_DECREF(gc);
+     }
+@@ -436,9 +440,10 @@ visit_reachable(PyObject *op, PyGC_Head *reachable)
+          * If gc_refs == GC_UNTRACKED, it must be ignored.
+          */
+          else {
+-            assert(gc_refs > 0
+-                   || gc_refs == GC_REACHABLE
+-                   || gc_refs == GC_UNTRACKED);
+             PyObject_ASSERT(FROM_GC(gc),
+                             gc_refs > 0
+                             || gc_refs == GC_REACHABLE
+                             || gc_refs == GC_UNTRACKED);
+          }
+     }
+     return 0;
+@@ -480,7 +485,7 @@ move_unreachable(PyGC_Head *young, PyGC_Head *unreachable)
+              */
+             PyObject *op = FROM_GC(gc);
+             traverseproc traverse = Py_TYPE(op)->tp_traverse;
+-            assert(_PyGCHead_REFS(gc) > 0);
+            PyObject_ASSERT(op, _PyGCHead_REFS(gc) > 0);
+             _PyGCHead_SET_REFS(gc, GC_REACHABLE);
+             (void) traverse(op,
+                             (visitproc)visit_reachable,
+@@ -543,7 +548,7 @@ move_legacy_finalizers(PyGC_Head *unreachable, PyGC_Head *finalizers)
+     for (gc = unreachable->gc.gc_next; gc != unreachable; gc = next) {
+         PyObject *op = FROM_GC(gc);
+ 
+-        assert(IS_TENTATIVELY_UNREACHABLE(op));
+        PyObject_ASSERT(op, IS_TENTATIVELY_UNREACHABLE(op));
+         next = gc->gc.gc_next;
+ 
+         if (has_legacy_finalizer(op)) {
+@@ -619,7 +624,7 @@ handle_weakrefs(PyGC_Head *unreachable, PyGC_Head *old)
+         PyWeakReference **wrlist;
+ 
+         op = FROM_GC(gc);
+-        assert(IS_TENTATIVELY_UNREACHABLE(op));
+        PyObject_ASSERT(op, IS_TENTATIVELY_UNREACHABLE(op));
+         next = gc->gc.gc_next;
+ 
+         if (! PyType_SUPPORTS_WEAKREFS(Py_TYPE(op)))
+@@ -640,9 +645,9 @@ handle_weakrefs(PyGC_Head *unreachable, PyGC_Head *old)
+              * the callback pointer intact.  Obscure:  it also
+              * changes *wrlist.
+              */
+-            assert(wr->wr_object == op);
+            PyObject_ASSERT(wr->wr_object, wr->wr_object == op);
+             _PyWeakref_ClearRef(wr);
+-            assert(wr->wr_object == Py_None);
+            PyObject_ASSERT(wr->wr_object, wr->wr_object == Py_None);
+             if (wr->wr_callback == NULL)
+                 continue;                       /* no callback */
+ 
+@@ -676,7 +681,7 @@ handle_weakrefs(PyGC_Head *unreachable, PyGC_Head *old)
+      */
+             if (IS_TENTATIVELY_UNREACHABLE(wr))
+                 continue;
+-            assert(IS_REACHABLE(wr));
+            PyObject_ASSERT(op, IS_REACHABLE(wr));
+ 
+             /* Create a new reference so that wr can't go away
+              * before we can process it again.
+@@ -685,7 +690,8 @@ handle_weakrefs(PyGC_Head *unreachable, PyGC_Head *old)
+ 
+             /* Move wr to wrcb_to_call, for the next pass. */
+             wrasgc = AS_GC(wr);
+-            assert(wrasgc != next); /* wrasgc is reachable, but
+            PyObject_ASSERT(op, wrasgc != next);
+                                    /* wrasgc is reachable, but
+                                        next isn't, so they can't
+                                        be the same */
+             gc_list_move(wrasgc, &wrcb_to_call);
+@@ -701,11 +707,11 @@ handle_weakrefs(PyGC_Head *unreachable, PyGC_Head *old)
+ 
+         gc = wrcb_to_call.gc.gc_next;
+         op = FROM_GC(gc);
+-        assert(IS_REACHABLE(op));
+-        assert(PyWeakref_Check(op));
+        PyObject_ASSERT(op, IS_REACHABLE(op));
+        PyObject_ASSERT(op, PyWeakref_Check(op));
+         wr = (PyWeakReference *)op;
+         callback = wr->wr_callback;
+-        assert(callback != NULL);
+        PyObject_ASSERT(op, callback != NULL);
+ 
+         /* copy-paste of weakrefobject.c's handle_callback() */
+         temp = PyObject_CallFunctionObjArgs(callback, wr, NULL);
+@@ -822,12 +828,14 @@ check_garbage(PyGC_Head *collectable)
+     for (gc = collectable->gc.gc_next; gc != collectable;
+          gc = gc->gc.gc_next) {
+         _PyGCHead_SET_REFS(gc, Py_REFCNT(FROM_GC(gc)));
+-        assert(_PyGCHead_REFS(gc) != 0);
+        PyObject_ASSERT(FROM_GC(gc),
+                        _PyGCHead_REFS(gc) != 0);
+     }
+     subtract_refs(collectable);
+     for (gc = collectable->gc.gc_next; gc != collectable;
+          gc = gc->gc.gc_next) {
+-        assert(_PyGCHead_REFS(gc) >= 0);
+        PyObject_ASSERT(FROM_GC(gc),
+                        _PyGCHead_REFS(gc) >= 0);
+         if (_PyGCHead_REFS(gc) != 0)
+             return -1;
+     }
+diff --git a/Objects/object.c b/Objects/object.c
+index 559794f..a47d47f 100644
+--- a/Objects/object.c
+++ b/Objects/object.c
+@@ -2022,6 +2022,35 @@ _PyTrash_thread_destroy_chain(void)
+     }
+ }
+ 
+PyAPI_FUNC(void)
+_PyObject_AssertFailed(PyObject *obj, const char *msg, const char *expr,
+              const char *file, int line, const char *function)
+{
+    fprintf(stderr,
+            "%s:%d: %s: Assertion \"%s\" failed.\n",
+            file, line, function, expr);
+    if (msg) {
+        fprintf(stderr, "%s\n", msg);
+    }
+
+    fflush(stderr);
+
+    if (obj) {
+        /* This might succeed or fail, but we're about to abort, so at least
+           try to provide any extra info we can: */
+        _PyObject_Dump(obj);
+    }
+    else {
+        fprintf(stderr, "NULL object\n");
+    }
+
+    fflush(stdout);
+    fflush(stderr);
+
+    /* Terminate the process: */
+    abort();
+}
+
+ #ifndef Py_TRACE_REFS
+ /* For Py_LIMITED_API, we need an out-of-line version of _Py_Dealloc.
+    Define this here, so we can undefine the macro. */
--- a/SOURCES/00178-dont-duplicate-flags-in-sysconfig.patch
+++ b/SOURCES/00178-dont-duplicate-flags-in-sysconfig.patch
@ -0,0 +1,30 @@
				@@ -0,0 +1,30 @@
+diff -r 39b9b05c3085 Lib/distutils/sysconfig.py
+--- a/Lib/distutils/sysconfig.py	Wed Apr 10 00:27:23 2013 +0200
+++ b/Lib/distutils/sysconfig.py	Wed Apr 10 10:14:18 2013 +0200
+@@ -362,7 +362,10 @@
+                     done[n] = item = ""
+                 if found:
+                     after = value[m.end():]
+-                    value = value[:m.start()] + item + after
+                    value = value[:m.start()]
+                    if item.strip() not in value:
+                        value += item
+                    value += after
+                     if "$" in after:
+                         notdone[name] = value
+                     else:
+diff -r 39b9b05c3085 Lib/sysconfig.py
+--- a/Lib/sysconfig.py	Wed Apr 10 00:27:23 2013 +0200
+++ b/Lib/sysconfig.py	Wed Apr 10 10:14:18 2013 +0200
+@@ -296,7 +296,10 @@
+ 
+                 if found:
+                     after = value[m.end():]
+-                    value = value[:m.start()] + item + after
+                    value = value[:m.start()]
+                    if item.strip() not in value:
+                        value += item
+                    value += after
+                     if "$" in after:
+                         notdone[name] = value
+                     else:
--- a/SOURCES/00180-python-add-support-for-ppc64p7.patch
+++ b/SOURCES/00180-python-add-support-for-ppc64p7.patch
@ -0,0 +1,13 @@
				@@ -0,0 +1,13 @@
+diff --git a/config.sub b/config.sub
+index 40ea5df..932128b 100755
+--- a/config.sub
+++ b/config.sub
+@@ -1045,7 +1045,7 @@ case $basic_machine in
+ 		;;
+ 	ppc64)	basic_machine=powerpc64-unknown
+ 		;;
+-	ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+	ppc64-* | ppc64p7-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+ 		;;
+ 	ppc64le | powerpc64little)
+ 		basic_machine=powerpc64le-unknown
--- a/SOURCES/00186-dont-raise-from-py_compile.patch
+++ b/SOURCES/00186-dont-raise-from-py_compile.patch
@ -0,0 +1,14 @@
				@@ -0,0 +1,14 @@
+diff -r 7fa3e824a4ee Lib/test/test_py_compile.py
+--- a/Lib/test/test_py_compile.py	Tue Oct 29 22:25:06 2013 -0400
+++ b/Lib/test/test_py_compile.py	Wed Oct 30 11:08:31 2013 +0100
+@@ -54,6 +54,10 @@
+         self.assertTrue(os.path.exists(self.pyc_path))
+         self.assertFalse(os.path.exists(self.cache_path))
+ 
+    def test_bad_coding(self):
+        bad_coding = os.path.join(os.path.dirname(__file__), 'bad_coding2.py')
+        self.assertIsNone(py_compile.compile(bad_coding, doraise=False))
+
+     def test_relative_path(self):
+         py_compile.compile(os.path.relpath(self.source_path),
+                            os.path.relpath(self.pyc_path))
--- a/SOURCES/00188-fix-lib2to3-tests-when-hashlib-doesnt-compile-properly.patch
+++ b/SOURCES/00188-fix-lib2to3-tests-when-hashlib-doesnt-compile-properly.patch
@ -0,0 +1,11 @@
				@@ -0,0 +1,11 @@
+diff -r 28c04e954bb6 Lib/lib2to3/main.py
+--- a/Lib/lib2to3/main.py	Tue Oct 29 22:25:55 2013 -0400
+++ b/Lib/lib2to3/main.py	Wed Nov 06 14:33:07 2013 +0100
+@@ -213,6 +213,7 @@
+ 
+     # Set up logging handler
+     level = logging.DEBUG if options.verbose else logging.INFO
+    logging.root.handlers = []
+     logging.basicConfig(format='%(name)s: %(message)s', level=level)
+     logger = logging.getLogger('lib2to3.main')
+ 
--- a/SOURCES/00189-add-rewheel-module.patch
+++ b/SOURCES/00189-add-rewheel-module.patch
@ -0,0 +1,233 @@
				@@ -0,0 +1,233 @@
+diff --git a/Lib/ensurepip/__init__.py b/Lib/ensurepip/__init__.py
+index d69e09f..5cb12df 100644
+--- a/Lib/ensurepip/__init__.py
+++ b/Lib/ensurepip/__init__.py
+@@ -1,8 +1,10 @@
+ import os
+ import os.path
+ import pkgutil
+import shutil
+ import sys
+ import tempfile
+from ensurepip import rewheel
+ 
+ 
+ __all__ = ["version", "bootstrap"]
+@@ -25,6 +27,8 @@ def _run_pip(args, additional_paths=None):
+ 
+     # Install the bundled software
+     import pip
+    if args[0] in ["install", "list", "wheel"]:
+        args.append('--pre')
+     return pip.main(args)
+ 
+ 
+@@ -88,20 +92,39 @@ def _bootstrap(*, root=None, upgrade=False, user=False,
+         # omit pip and easy_install
+         os.environ["ENSUREPIP_OPTIONS"] = "install"
+ 
+    whls = []
+    rewheel_dir = None
+    # try to see if we have system-wide versions of _PROJECTS
+    dep_records = rewheel.find_system_records([p[0] for p in _PROJECTS])
+    # TODO: check if system-wide versions are the newest ones
+    # if --upgrade is used?
+    if all(dep_records):
+        # if we have all _PROJECTS installed system-wide, we'll recreate
+        # wheels from them and install those
+        rewheel_dir = tempfile.TemporaryDirectory()
+        for dr in dep_records:
+            new_whl = rewheel.rewheel_from_record(dr, rewheel_dir.name)
+            whls.append(os.path.join(rewheel_dir.name, new_whl))
+    else:
+        # if we don't have all the _PROJECTS installed system-wide,
+        # let's just fall back to bundled wheels
+        for project, version in _PROJECTS:
+            whl = os.path.join(
+                os.path.dirname(__file__),
+                "_bundled",
+                "{}-{}-py2.py3-none-any.whl".format(project, version)
+            )
+            whls.append(whl)
+
+     with tempfile.TemporaryDirectory() as tmpdir:
+         # Put our bundled wheels into a temporary directory and construct the
+         # additional paths that need added to sys.path
+         additional_paths = []
+-        for project, version in _PROJECTS:
+-            wheel_name = "{}-{}-py2.py3-none-any.whl".format(project, version)
+-            whl = pkgutil.get_data(
+-                "ensurepip",
+-                "_bundled/{}".format(wheel_name),
+-            )
+-            with open(os.path.join(tmpdir, wheel_name), "wb") as fp:
+-                fp.write(whl)
+-
+-            additional_paths.append(os.path.join(tmpdir, wheel_name))
+        for whl in whls:
+            shutil.copy(whl, tmpdir)
+            additional_paths.append(os.path.join(tmpdir, os.path.basename(whl)))
+        if rewheel_dir:
+            rewheel_dir.cleanup()
+ 
+         # Construct the arguments to be passed to the pip command
+         args = ["install", "--no-index", "--find-links", tmpdir]
+diff -Nur Python-3.4.1/Lib/ensurepip/rewheel/__init__.py Python-3.4.1-rewheel/Lib/ensurepip/rewheel/__init__.py
+--- Python-3.4.1/Lib/ensurepip/rewheel/__init__.py  1970-01-01 01:00:00.000000000 +0100
+++ Python-3.4.1-rewheel/Lib/ensurepip/rewheel/__init__.py  2014-08-21 10:11:22.560320121 +0200
+@@ -0,0 +1,143 @@
+import argparse
+import codecs
+import csv
+import email.parser
+import os
+import io
+import re
+import site
+import subprocess
+import sys
+import zipfile
+
+def run():
+    parser = argparse.ArgumentParser(description='Recreate wheel of package with given RECORD.')
+    parser.add_argument('record_path',
+                        help='Path to RECORD file')
+    parser.add_argument('-o', '--output-dir',
+                        help='Dir where to place the wheel, defaults to current working dir.',
+                        dest='outdir',
+                        default=os.path.curdir)
+
+    ns = parser.parse_args()
+    retcode = 0
+    try:
+        print(rewheel_from_record(**vars(ns)))
+    except BaseException as e:
+        print('Failed: {}'.format(e))
+        retcode = 1
+    sys.exit(1)
+
+def find_system_records(projects):
+    """Return list of paths to RECORD files for system-installed projects.
+
+    If a project is not installed, the resulting list contains None instead
+    of a path to its RECORD
+    """
+    records = []
+    # get system site-packages dirs
+    sys_sitepack = site.getsitepackages([sys.base_prefix, sys.base_exec_prefix])
+    sys_sitepack = [sp for sp in sys_sitepack if os.path.exists(sp)]
+    # try to find all projects in all system site-packages
+    for project in projects:
+        path = None
+        for sp in sys_sitepack:
+            dist_info_re = os.path.join(sp, project) + r'-[^\{0}]+\.dist-info'.format(os.sep)
+            candidates = [os.path.join(sp, p) for p in os.listdir(sp)]
+            # filter out candidate dirs based on the above regexp
+            filtered = [c for c in candidates if re.match(dist_info_re, c)]
+            # if we have 0 or 2 or more dirs, something is wrong...
+            if len(filtered) == 1:
+                path = filtered[0]
+        if path is not None:
+            records.append(os.path.join(path, 'RECORD'))
+        else:
+            records.append(None)
+    return records
+
+def rewheel_from_record(record_path, outdir):
+    """Recreates a whee of package with given record_path and returns path
+    to the newly created wheel."""
+    site_dir = os.path.dirname(os.path.dirname(record_path))
+    record_relpath = record_path[len(site_dir):].strip(os.path.sep)
+    to_write, to_omit = get_records_to_pack(site_dir, record_relpath)
+    new_wheel_name = get_wheel_name(record_path)
+    new_wheel_path = os.path.join(outdir, new_wheel_name + '.whl')
+
+    new_wheel = zipfile.ZipFile(new_wheel_path, mode='w', compression=zipfile.ZIP_DEFLATED)
+    # we need to write a new record with just the files that we will write,
+    # e.g. not binaries and *.pyc/*.pyo files
+    new_record = io.StringIO()
+    writer = csv.writer(new_record)
+
+    # handle files that we can write straight away
+    for f, sha_hash, size in to_write:
+        new_wheel.write(os.path.join(site_dir, f), arcname=f)
+        writer.writerow([f, sha_hash,size])
+
+    # rewrite the old wheel file with a new computed one
+    writer.writerow([record_relpath, '', ''])
+    new_wheel.writestr(record_relpath, new_record.getvalue())
+
+    new_wheel.close()
+
+    return new_wheel.filename
+
+def get_wheel_name(record_path):
+    """Return proper name of the wheel, without .whl."""
+
+    wheel_info_path = os.path.join(os.path.dirname(record_path), 'WHEEL')
+    with codecs.open(wheel_info_path, encoding='utf-8') as wheel_info_file:
+        wheel_info = email.parser.Parser().parsestr(wheel_info_file.read())
+
+    metadata_path = os.path.join(os.path.dirname(record_path), 'METADATA')
+    with codecs.open(metadata_path, encoding='utf-8') as metadata_file:
+        metadata = email.parser.Parser().parsestr(metadata_file.read())
+
+    # construct name parts according to wheel spec
+    distribution = metadata.get('Name')
+    version = metadata.get('Version')
+    build_tag = '' # nothing for now
+    lang_tag = []
+    for t in wheel_info.get_all('Tag'):
+        lang_tag.append(t.split('-')[0])
+    lang_tag = '.'.join(lang_tag)
+    abi_tag, plat_tag = wheel_info.get('Tag').split('-')[1:3]
+    # leave out build tag, if it is empty
+    to_join = filter(None, [distribution, version, build_tag, lang_tag, abi_tag, plat_tag])
+    return '-'.join(list(to_join))
+
+def get_records_to_pack(site_dir, record_relpath):
+    """Accepts path of sitedir and path of RECORD file relative to it.
+    Returns two lists:
+    - list of files that can be written to new RECORD straight away
+    - list of files that shouldn't be written or need some processing
+      (pyc and pyo files, scripts)
+    """
+    record_file_path = os.path.join(site_dir, record_relpath)
+    with codecs.open(record_file_path, encoding='utf-8') as record_file:
+        record_contents = record_file.read()
+    # temporary fix for https://github.com/pypa/pip/issues/1376
+    # we need to ignore files under ".data" directory
+    data_dir = os.path.dirname(record_relpath).strip(os.path.sep)
+    data_dir = data_dir[:-len('dist-info')] + 'data'
+
+    to_write = []
+    to_omit = []
+    for l in record_contents.splitlines():
+        spl = l.split(',')
+        if len(spl) == 3:
+            # new record will omit (or write differently):
+            # - abs paths, paths with ".." (entry points),
+            # - pyc+pyo files
+            # - the old RECORD file
+            # TODO: is there any better way to recognize an entry point?
+            if os.path.isabs(spl[0]) or spl[0].startswith('..') or \
+               spl[0].endswith('.pyc') or spl[0].endswith('.pyo') or \
+               spl[0] == record_relpath or spl[0].startswith(data_dir):
+                to_omit.append(spl)
+            else:
+                to_write.append(spl)
+        else:
+            pass # bad RECORD or empty line
+    return to_write, to_omit
+diff -Nur Python-3.4.1/Makefile.pre.in Python-3.4.1-rewheel/Makefile.pre.in
+--- Python-3.4.1/Makefile.pre.in    2014-08-21 10:49:31.512695040 +0200
+++ Python-3.4.1-rewheel/Makefile.pre.in    2014-08-21 10:10:41.961341722 +0200
+@@ -1145,7 +1145,7 @@
+ 		test/test_asyncio \
+ 		collections concurrent concurrent/futures encodings \
+ 		email email/mime test/test_email test/test_email/data \
+-		ensurepip ensurepip/_bundled \
+		ensurepip ensurepip/_bundled ensurepip/rewheel \
+ 		html json test/test_json http dbm xmlrpc \
+ 		sqlite3 sqlite3/test \
+ 		logging csv wsgiref urllib \
--- a/SOURCES/00205-make-libpl-respect-lib64.patch
+++ b/SOURCES/00205-make-libpl-respect-lib64.patch
@ -0,0 +1,12 @@
				@@ -0,0 +1,12 @@
+diff -up Python-3.5.0/Makefile.pre.in.lib Python-3.5.0/Makefile.pre.in
+--- Python-3.5.0/Makefile.pre.in.lib	2015-09-21 15:39:47.928286620 +0200
+++ Python-3.5.0/Makefile.pre.in	2015-09-21 15:42:58.004042762 +0200
+@@ -1340,7 +1340,7 @@ inclinstall:
+ 
+ # Install the library and miscellaneous stuff needed for extending/embedding
+ # This goes into $(exec_prefix)
+-LIBPL=		@LIBPL@
+LIBPL=		$(LIBDEST)/config-$(LDVERSION)-$(MULTIARCH)
+ 
+ # pkgconfig directory
+ LIBPC=		$(LIBDIR)/pkgconfig
--- a/SOURCES/00206-remove-hf-from-arm-triplet.patch
+++ b/SOURCES/00206-remove-hf-from-arm-triplet.patch
@ -0,0 +1,15 @@
				@@ -0,0 +1,15 @@
+diff -up Python-3.5.0/configure.ac.eabi Python-3.5.0/configure.ac
+--- Python-3.5.0/configure.eabi	2015-09-23 13:52:20.756909744 +0200
+++ Python-3.5.0/configure	2015-09-23 13:52:46.859163629 +0200
+@@ -762,9 +762,9 @@ cat >> conftest.c <<EOF
+         alpha-linux-gnu
+ # elif defined(__ARM_EABI__) && defined(__ARM_PCS_VFP)
+ #  if defined(__ARMEL__)
+-        arm-linux-gnueabihf
+        arm-linux-gnueabi
+ #  else
+-        armeb-linux-gnueabihf
+        armeb-linux-gnueabi
+ #  endif
+ # elif defined(__ARM_EABI__) && !defined(__ARM_PCS_VFP)
+ #  if defined(__ARMEL__)
--- a/SOURCES/00243-fix-mips64-triplet.patch
+++ b/SOURCES/00243-fix-mips64-triplet.patch
@ -0,0 +1,42 @@
				@@ -0,0 +1,42 @@
+diff -urp Python-3.5.0/configure p/configure
+--- Python-3.5.0/configure	2016-02-25 16:12:12.615184011 +0000
+++ p/configure	2016-02-25 16:13:01.293412517 +0000
+@@ -5133,7 +5133,7 @@ cat >> conftest.c <<EOF
+ #  elif _MIPS_SIM == _ABIN32
+         mips64el-linux-gnuabin32
+ #  elif _MIPS_SIM == _ABI64
+-        mips64el-linux-gnuabi64
+        mips64el-linux-gnu
+ #  else
+ #   error unknown platform triplet
+ #  endif
+@@ -5143,7 +5143,7 @@ cat >> conftest.c <<EOF
+ #  elif _MIPS_SIM == _ABIN32
+         mips64-linux-gnuabin32
+ #  elif _MIPS_SIM == _ABI64
+-        mips64-linux-gnuabi64
+        mips64-linux-gnu
+ #  else
+ #   error unknown platform triplet
+ #  endif
+diff -urp Python-3.5.0/configure.ac p/configure.ac
+--- Python-3.5.0/configure.ac	2016-02-25 16:12:11.663159985 +0000
+++ p/configure.ac	2016-02-25 16:13:18.814854710 +0000
+@@ -784,7 +784,7 @@ cat >> conftest.c <<EOF
+ #  elif _MIPS_SIM == _ABIN32
+         mips64el-linux-gnuabin32
+ #  elif _MIPS_SIM == _ABI64
+-        mips64el-linux-gnuabi64
+        mips64el-linux-gnu
+ #  else
+ #   error unknown platform triplet
+ #  endif
+@@ -794,7 +794,7 @@ cat >> conftest.c <<EOF
+ #  elif _MIPS_SIM == _ABIN32
+         mips64-linux-gnuabin32
+ #  elif _MIPS_SIM == _ABI64
+-        mips64-linux-gnuabi64
+        mips64-linux-gnu
+ #  else
+ #   error unknown platform triplet
+ #  endif
--- a/SOURCES/00262-pep538_coerce_legacy_c_locale.patch
+++ b/SOURCES/00262-pep538_coerce_legacy_c_locale.patch
--- a/SOURCES/00292-restore-PyExc_RecursionErrorInst-symbol.patch
+++ b/SOURCES/00292-restore-PyExc_RecursionErrorInst-symbol.patch
@ -0,0 +1,106 @@
				@@ -0,0 +1,106 @@
+diff --git a/Doc/whatsnew/3.6.rst b/Doc/whatsnew/3.6.rst
+index 847b50140a6..570dc3ed6fe 100644
+--- a/Doc/whatsnew/3.6.rst
+++ b/Doc/whatsnew/3.6.rst
+@@ -1852,10 +1852,10 @@ Build and C API Changes
+ * The :c:func:`PyUnicode_FSConverter` and :c:func:`PyUnicode_FSDecoder`
+   functions will now accept :term:`path-like objects <path-like object>`.
+ 
+-* The ``PyExc_RecursionErrorInst`` singleton that was part of the public API
+-  has been removed as its members being never cleared may cause a segfault
+-  during finalization of the interpreter. Contributed by Xavier de Gaye in
+-  :issue:`22898` and :issue:`30697`.
+* The ``PyExc_RecursionErrorInst`` singleton is not used anymore as its members
+  being never cleared may cause a segfault during finalization of the
+  interpreter. Contributed by Xavier de Gaye in :issue:`22898` and
+  :issue:`30697`.
+ 
+ 
+ Other Improvements
+diff --git a/Include/pyerrors.h b/Include/pyerrors.h
+index c28c1373f82..8c1dbc5047b 100644
+--- a/Include/pyerrors.h
+++ b/Include/pyerrors.h
+@@ -219,6 +219,8 @@ PyAPI_DATA(PyObject *) PyExc_IOError;
+ PyAPI_DATA(PyObject *) PyExc_WindowsError;
+ #endif
+ 
+PyAPI_DATA(PyObject *) PyExc_RecursionErrorInst;
+
+ /* Predefined warning categories */
+ PyAPI_DATA(PyObject *) PyExc_Warning;
+ PyAPI_DATA(PyObject *) PyExc_UserWarning;
+diff --git a/Misc/NEWS.d/next/C API/2017-12-20-15-23-06.bpo-30697.v9FmgG.rst b/Misc/NEWS.d/next/C API/2017-12-20-15-23-06.bpo-30697.v9FmgG.rst
+new file mode 100644
+index 00000000000..28f74ad4f30
+--- /dev/null
+++ b/Misc/NEWS.d/next/C API/2017-12-20-15-23-06.bpo-30697.v9FmgG.rst	
+@@ -0,0 +1 @@
+Restore PyExc_RecursionErrorInst in 3.6
+diff --git a/Objects/exceptions.c b/Objects/exceptions.c
+index df4899372a5..271e293e325 100644
+--- a/Objects/exceptions.c
+++ b/Objects/exceptions.c
+@@ -2430,6 +2430,12 @@ SimpleExtendsException(PyExc_Warning, ResourceWarning,
+ 
+ 
+ 
+/* Pre-computed RecursionError instance for when recursion depth is reached.
+   Meant to be used when normalizing the exception for exceeding the recursion
+   depth will cause its own infinite recursion.
+*/
+PyObject *PyExc_RecursionErrorInst = NULL;
+
+ #define PRE_INIT(TYPE) \
+     if (!(_PyExc_ ## TYPE.tp_flags & Py_TPFLAGS_READY)) { \
+         if (PyType_Ready(&_PyExc_ ## TYPE) < 0) \
+@@ -2691,11 +2697,37 @@ _PyExc_Init(PyObject *bltinmod)
+     ADD_ERRNO(TimeoutError, ETIMEDOUT);
+ 
+     preallocate_memerrors();
+
+    if (!PyExc_RecursionErrorInst) {
+        PyExc_RecursionErrorInst = BaseException_new(&_PyExc_RecursionError, NULL, NULL);
+        if (!PyExc_RecursionErrorInst)
+            Py_FatalError("Cannot pre-allocate RecursionError instance for "
+                            "recursion errors");
+        else {
+            PyBaseExceptionObject *err_inst =
+                (PyBaseExceptionObject *)PyExc_RecursionErrorInst;
+            PyObject *args_tuple;
+            PyObject *exc_message;
+            exc_message = PyUnicode_FromString("maximum recursion depth exceeded");
+            if (!exc_message)
+                Py_FatalError("cannot allocate argument for RecursionError "
+                                "pre-allocation");
+            args_tuple = PyTuple_Pack(1, exc_message);
+            if (!args_tuple)
+                Py_FatalError("cannot allocate tuple for RecursionError "
+                                "pre-allocation");
+            Py_DECREF(exc_message);
+            if (BaseException_init(err_inst, args_tuple, NULL))
+                Py_FatalError("init of pre-allocated RecursionError failed");
+            Py_DECREF(args_tuple);
+        }
+    }
+ }
+ 
+ void
+ _PyExc_Fini(void)
+ {
+    Py_CLEAR(PyExc_RecursionErrorInst);
+     free_preallocated_memerrors();
+     Py_CLEAR(errnomap);
+ }
+diff --git a/PC/python3.def b/PC/python3.def
+index 4fc4a6814ee..ff70718fc37 100644
+--- a/PC/python3.def
+++ b/PC/python3.def
+@@ -224,6 +224,7 @@ EXPORTS
+   PyExc_PermissionError=python36.PyExc_PermissionError DATA
+   PyExc_ProcessLookupError=python36.PyExc_ProcessLookupError DATA
+   PyExc_RecursionError=python36.PyExc_RecursionError DATA
+  PyExc_RecursionErrorInst=python36.PyExc_RecursionErrorInst DATA
+   PyExc_ReferenceError=python36.PyExc_ReferenceError DATA
+   PyExc_ResourceWarning=python36.PyExc_ResourceWarning DATA
+   PyExc_RuntimeError=python36.PyExc_RuntimeError DATA
--- a/SOURCES/00301-pathfix-add-n-option-for-no-backup.patch
+++ b/SOURCES/00301-pathfix-add-n-option-for-no-backup.patch
@ -0,0 +1,104 @@
				@@ -0,0 +1,104 @@
+From 5affd5c29eb1493cb31ef3cfdde15538ac134689 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Miro=20Hron=C4=8Dok?= <miro@hroncok.cz>
+Date: Tue, 13 Mar 2018 10:56:43 +0100
+Subject: [PATCH] bpo-32885: Tools/scripts/pathfix.py: Add -n option for no
+ backup~ (#5772)
+
+Creating backup files with ~ suffix can be undesirable in some environment,
+such as when building RPM packages. Instead of requiring the user to remove
+those files manually, option -n was added, that simply disables this feature.
+
+-n was selected because 2to3 has the same option with this behavior.
+---
+ Misc/ACKS                                          |  1 +
+ .../2018-02-20-12-16-47.bpo-32885.dL5x7C.rst       |  2 ++
+ Tools/scripts/pathfix.py                           | 28 +++++++++++++++-------
+ 3 files changed, 23 insertions(+), 8 deletions(-)
+ create mode 100644 Misc/NEWS.d/next/Tools-Demos/2018-02-20-12-16-47.bpo-32885.dL5x7C.rst
+
+diff --git a/Misc/ACKS b/Misc/ACKS
+index d8179c8b03ab..d752d8a35434 100644
+--- a/Misc/ACKS
+++ b/Misc/ACKS
+@@ -687,6 +687,7 @@ Ken Howard
+ Brad Howes
+ Mike Hoy
+ Ben Hoyt
+Miro Hrončok
+ Chiu-Hsiang Hsu
+ Chih-Hao Huang
+ Christian Hudon
+diff --git a/Misc/NEWS.d/next/Tools-Demos/2018-02-20-12-16-47.bpo-32885.dL5x7C.rst b/Misc/NEWS.d/next/Tools-Demos/2018-02-20-12-16-47.bpo-32885.dL5x7C.rst
+new file mode 100644
+index 000000000000..e003e1d84fd0
+--- /dev/null
+++ b/Misc/NEWS.d/next/Tools-Demos/2018-02-20-12-16-47.bpo-32885.dL5x7C.rst
+@@ -0,0 +1,2 @@
+Add an ``-n`` flag for ``Tools/scripts/pathfix.py`` to disbale automatic
+backup creation (files with ``~`` suffix).
+diff --git a/Tools/scripts/pathfix.py b/Tools/scripts/pathfix.py
+index 562bbc737812..c5bf984306a3 100755
+--- a/Tools/scripts/pathfix.py
+++ b/Tools/scripts/pathfix.py
+@@ -7,8 +7,9 @@
+ # Directories are searched recursively for files whose name looks
+ # like a python module.
+ # Symbolic links are always ignored (except as explicit directory
+-# arguments).  Of course, the original file is kept as a back-up
+-# (with a "~" attached to its name).
+# arguments).
+# The original file is kept as a back-up (with a "~" attached to its name),
+# -n flag can be used to disable this.
+ #
+ # Undoubtedly you can do this using find and sed or perl, but this is
+ # a nice example of Python code that recurses down a directory tree
+@@ -31,14 +32,17 @@
+ 
+ new_interpreter = None
+ preserve_timestamps = False
+create_backup = True
+
+ 
+ def main():
+     global new_interpreter
+     global preserve_timestamps
+-    usage = ('usage: %s -i /interpreter -p file-or-directory ...\n' %
+    global create_backup
+    usage = ('usage: %s -i /interpreter -p -n file-or-directory ...\n' %
+              sys.argv[0])
+     try:
+-        opts, args = getopt.getopt(sys.argv[1:], 'i:p')
+        opts, args = getopt.getopt(sys.argv[1:], 'i:pn')
+     except getopt.error as msg:
+         err(str(msg) + '\n')
+         err(usage)
+@@ -48,6 +52,8 @@ def main():
+             new_interpreter = a.encode()
+         if o == '-p':
+             preserve_timestamps = True
+        if o == '-n':
+            create_backup = False
+     if not new_interpreter or not new_interpreter.startswith(b'/') or \
+            not args:
+         err('-i option or file-or-directory missing\n')
+@@ -134,10 +140,16 @@ def fix(filename):
+     except OSError as msg:
+         err('%s: warning: chmod failed (%r)\n' % (tempname, msg))
+     # Then make a backup of the original file as filename~
+-    try:
+-        os.rename(filename, filename + '~')
+-    except OSError as msg:
+-        err('%s: warning: backup failed (%r)\n' % (filename, msg))
+    if create_backup:
+        try:
+            os.rename(filename, filename + '~')
+        except OSError as msg:
+            err('%s: warning: backup failed (%r)\n' % (filename, msg))
+    else:
+        try:
+            os.remove(filename)
+        except OSError as msg:
+            err('%s: warning: removing failed (%r)\n' % (filename, msg))
+     # Now move the temp file to the original file
+     try:
+         os.rename(tempname, filename)
--- a/SOURCES/Python-3.1.1-rpath.patch
+++ b/SOURCES/Python-3.1.1-rpath.patch
@ -0,0 +1,19 @@
				@@ -0,0 +1,19 @@
+diff -up Python-3.1.1/Lib/distutils/unixccompiler.py.rpath Python-3.1.1/Lib/distutils/unixccompiler.py
+--- Python-3.1.1/Lib/distutils/unixccompiler.py.rpath	2009-09-04 17:29:34.000000000 -0400
+++ Python-3.1.1/Lib/distutils/unixccompiler.py	2009-09-04 17:49:54.000000000 -0400
+@@ -141,6 +141,15 @@ class UnixCCompiler(CCompiler):
+     if sys.platform == "cygwin":
+         exe_extension = ".exe"
+ 
+    def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs):
+        """Remove standard library path from rpath"""
+        libraries, library_dirs, runtime_library_dirs = super()._fix_lib_args(
+            libraries, library_dirs, runtime_library_dirs)
+        libdir = sysconfig.get_config_var('LIBDIR')
+        if runtime_library_dirs and (libdir in runtime_library_dirs):
+            runtime_library_dirs.remove(libdir)
+        return libraries, library_dirs, runtime_library_dirs
+
+     def preprocess(self, source, output_file=None, macros=None,
+                    include_dirs=None, extra_preargs=None, extra_postargs=None):
+         fixed_args = self._fix_compile_args(None, macros, include_dirs)
--- a/SOURCES/check-pyc-and-pyo-timestamps.py
+++ b/SOURCES/check-pyc-and-pyo-timestamps.py
@ -0,0 +1,50 @@
				@@ -0,0 +1,50 @@
+"""Checks if all *.pyc and *.pyo files have later mtime than their *.py files."""
+
+import imp
+import os
+import sys
+
+# list of test and other files that we expect not to have bytecode
+not_compiled = [
+    'test/bad_coding.py',
+    'test/bad_coding2.py',
+    'test/badsyntax_3131.py',
+    'test/badsyntax_future3.py',
+    'test/badsyntax_future4.py',
+    'test/badsyntax_future5.py',
+    'test/badsyntax_future6.py',
+    'test/badsyntax_future7.py',
+    'test/badsyntax_future8.py',
+    'test/badsyntax_future9.py',
+    'test/badsyntax_future10.py',
+    'test/badsyntax_pep3120.py',
+    'lib2to3/tests/data/bom.py',
+    'lib2to3/tests/data/crlf.py',
+    'lib2to3/tests/data/different_encoding.py',
+    'lib2to3/tests/data/false_encoding.py',
+    'lib2to3/tests/data/py2_test_grammar.py',
+    '.debug-gdb.py',
+]
+failed = 0
+
+def bytecode_expected(source):
+    for f in not_compiled:
+        if source.endswith(f):
+            return False
+    return True
+
+compiled = filter(lambda f: bytecode_expected(f), sys.argv[1:])
+for f in compiled:
+    # check both pyo and pyc
+    to_check = map(lambda b: imp.cache_from_source(f, b), (True, False))
+    f_mtime = os.path.getmtime(f)
+    for c in to_check:
+        c_mtime = os.path.getmtime(c)
+        if c_mtime < f_mtime:
+            sys.stderr.write('Failed bytecompilation timestamps check: ')
+            sys.stderr.write('Bytecode file {} is older than source file {}.\n'.format(c, f))
+            failed += 1
+
+if failed:
+    sys.stderr.write('\n{} files failed bytecompilation timestamps check.\n'.format(failed))
+    sys.exit(1)
--- a/SOURCES/idle3.appdata.xml
+++ b/SOURCES/idle3.appdata.xml
@ -0,0 +1,35 @@
				@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- Copyright 2017 Zbigniew Jędrzejewski-Szmek -->
+<application>
+  <id type="desktop">idle3.desktop</id>
+  <name>IDLE3</name>
+  <metadata_licence>CC0</metadata_licence>
+  <project_license>Python-2.0</project_license>
+  <summary>Python 3 Integrated Development and Learning Environment</summary>
+  <description>
+    <p>
+      IDLE is Python’s Integrated Development and Learning Environment.
+      The GUI is uniform between Windows, Unix, and Mac OS X.
+      IDLE provides an easy way to start writing, running, and debugging
+      Python code.
+    </p>
+    <p>
+      IDLE is written in pure Python, and uses the tkinter GUI toolkit.
+      It provides:
+    </p>
+    <ul>
+       <li>a Python shell window (interactive interpreter) with colorizing of code input, output, and error messages,</li>
+       <li>a multi-window text editor with multiple undo, Python colorizing, smart indent, call tips, auto completion, and other features,</li>
+       <li>search within any window, replace within editor windows, and search through multiple files (grep),</li>
+       <li>a debugger with persistent breakpoints, stepping, and viewing of global and local namespaces.</li>
+    </ul>
+  </description>
+  <url type="homepage">https://docs.python.org/3/library/idle.html</url>
+  <screenshots>
+    <screenshot type="default">http://in.waw.pl/~zbyszek/fedora/idle3-appdata/idle3-main-window.png</screenshot>
+    <screenshot>http://in.waw.pl/~zbyszek/fedora/idle3-appdata/idle3-class-browser.png</screenshot>
+    <screenshot>http://in.waw.pl/~zbyszek/fedora/idle3-appdata/idle3-code-viewer.png</screenshot>
+  </screenshots>
+  <update_contact>zbyszek@in.waw.pl</update_contact>
+</application>
--- a/SOURCES/idle3.desktop
+++ b/SOURCES/idle3.desktop
@ -0,0 +1,11 @@
				@@ -0,0 +1,11 @@
+[Desktop Entry]
+Version=1.0
+Name=IDLE 3
+Comment=Python 3 Integrated Development and Learning Environment
+Exec=idle3 %F
+TryExec=idle3
+Terminal=false
+Type=Application
+Icon=idle3
+Categories=Development;IDE;
+MimeType=text/x-python;
--- a/SOURCES/libpython.stp
+++ b/SOURCES/libpython.stp
@ -0,0 +1,17 @@
				@@ -0,0 +1,17 @@
+/* Systemtap tapset to make it easier to trace Python */
+
+/*
+   Define python.function.entry/return:
+*/
+probe python.function.entry = process("python").library("LIBRARY_PATH").mark("function__entry")
+{
+    filename = user_string($arg1);
+    funcname = user_string($arg2);
+    lineno = $arg3;
+}
+probe python.function.return = process("python").library("LIBRARY_PATH").mark("function__return")
+{
+    filename = user_string($arg1);
+    funcname = user_string($arg2);
+    lineno = $arg3;
+}
--- a/SOURCES/macros.pybytecompile3.6
+++ b/SOURCES/macros.pybytecompile3.6
@ -0,0 +1,25 @@
				@@ -0,0 +1,25 @@
+# Note that the path could itself be a python file, or a directory
+
+# Python's compile_all module only works on directories, and requires a max
+# recursion depth
+
+# Note that the py_byte_compile macro should work for python2 as well
+# Which unfortunately makes the definition more complicated than it should be
+# The condition should be reversed once /usr/bin/python is python3!
+
+%py_byte_compile()\
+py2_byte_compile () {\
+    python_binary="%1"\
+    bytecode_compilation_path="%2"\
+    find $bytecode_compilation_path -type f -a -name "*.py" -print0 | xargs -0 $python_binary -c 'import py_compile, sys; [py_compile.compile(f, dfile=f.partition("$RPM_BUILD_ROOT")[2]) for f in sys.argv[1:]]' || :\
+    find $bytecode_compilation_path -type f -a -name "*.py" -print0 | xargs -0 $python_binary -O -c 'import py_compile, sys; [py_compile.compile(f, dfile=f.partition("$RPM_BUILD_ROOT")[2]) for f in sys.argv[1:]]' || :\
+}\
+\
+py3_byte_compile () {\
+    python_binary="%1"\
+    bytecode_compilation_path="%2"\
+    find $bytecode_compilation_path -type f -a -name "*.py" -print0 | xargs -0 $python_binary -O -c 'import py_compile, sys; [py_compile.compile(f, dfile=f.partition("$RPM_BUILD_ROOT")[2], optimize=opt) for opt in range(2) for f in sys.argv[1:]]' || :\
+}\
+\
+[[ "%1" == *python3* ]] || py2_byte_compile "%1" "%2" && py3_byte_compile "%1" "%2" \
+%{nil}
--- a/SOURCES/macros.systempython
+++ b/SOURCES/macros.systempython
@ -0,0 +1,4 @@
				@@ -0,0 +1,4 @@
+%system_python_abi %{expand: \
+%global __requires_exclude ^python\\\\(abi\\\\) = 3\\\\..$
+Requires: system-python(abi) = %{python3_version}
+}
--- a/SOURCES/pyfuntop.stp
+++ b/SOURCES/pyfuntop.stp
@ -0,0 +1,21 @@
				@@ -0,0 +1,21 @@
+#!/usr/bin/stap 
+
+global fn_calls;
+
+probe python.function.entry
+{ 
+  fn_calls[pid(), filename, funcname, lineno] += 1;
+}
+
+probe timer.ms(1000) {
+    printf("\033[2J\033[1;1H") /* clear screen */
+    printf("%6s %80s %6s %30s %6s\n",
+           "PID", "FILENAME", "LINE", "FUNCTION", "CALLS")
+    foreach ([pid, filename, funcname, lineno] in fn_calls- limit 20) {
+        printf("%6d %80s %6d %30s %6d\n",
+            pid, filename, lineno, funcname,
+            fn_calls[pid, filename, funcname, lineno]);
+    }
+
+    delete fn_calls;
+}
--- a/SOURCES/python3-powerppc-arch.patch
+++ b/SOURCES/python3-powerppc-arch.patch
@ -0,0 +1,30 @@
				@@ -0,0 +1,30 @@
+diff -up Python-3.5.0/configure.ac.than Python-3.5.0/configure.ac
+--- Python-3.5.0/configure.ac.than	2015-11-13 11:51:32.039560172 -0500
+++ Python-3.5.0/configure.ac	2015-11-13 11:52:11.670168157 -0500
+@@ -804,9 +804,9 @@ cat >> conftest.c <<EOF
+         powerpc-linux-gnuspe
+ # elif defined(__powerpc64__)
+ #  if defined(__LITTLE_ENDIAN__)
+-        powerpc64le-linux-gnu
+        ppc64le-linux-gnu
+ #  else
+-        powerpc64-linux-gnu
+        ppc64-linux-gnu
+ #  endif
+ # elif defined(__powerpc__)
+         powerpc-linux-gnu
+diff -up Python-3.5.0/configure.than Python-3.5.0/configure
+--- Python-3.5.0/configure.than	2015-11-13 12:13:19.039658399 -0500
+++ Python-3.5.0/configure	2015-11-13 12:13:35.199906857 -0500
+@@ -5153,9 +5153,9 @@ cat >> conftest.c <<EOF
+         powerpc-linux-gnuspe
+ # elif defined(__powerpc64__)
+ #  if defined(__LITTLE_ENDIAN__)
+-        powerpc64le-linux-gnu
+        ppc64le-linux-gnu
+ #  else
+-        powerpc64-linux-gnu
+        ppc64-linux-gnu
+ #  endif
+ # elif defined(__powerpc__)
+         powerpc-linux-gnu
--- a/SOURCES/systemtap-example.stp
+++ b/SOURCES/systemtap-example.stp
@ -0,0 +1,19 @@
				@@ -0,0 +1,19 @@
+/*
+    Example usage of the Python systemtap tapset to show a nested view of all
+    Python function calls (and returns) across the whole system.
+
+    Run this using
+        stap systemtap-example.stp
+    to instrument all Python processes on the system, or (for example) using
+        stap systemtap-example.stp -c COMMAND
+    to instrument a specific program (implemented in Python)
+*/
+probe python.function.entry
+{
+  printf("%s => %s in %s:%d\n", thread_indent(1), funcname, filename, lineno);
+}
+
+probe python.function.return
+{
+  printf("%s <= %s in %s:%d\n", thread_indent(-1), funcname, filename, lineno);
+}
--- a/SPECS/python3.spec
+++ b/SPECS/python3.spec