From: Dmitry Shachnev Date: Mon, 19 Oct 2020 18:50:57 +0000 (+0100) Subject: pyside2 (5.15.0-5) unstable; urgency=medium X-Git-Tag: archive/raspbian/5.15.0-5+rpi1^2~6 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=022a66621aa810129315ce6fdf07ad3b906bc84f;p=pyside2.git pyside2 (5.15.0-5) unstable; urgency=medium * Team upload. * Run tests with QSG_NO_DEPTH_BUFFER=1 on mips64el (see #868745). [dgit import unpatched pyside2 5.15.0-5] --- 022a66621aa810129315ce6fdf07ad3b906bc84f diff --cc debian/changelog index 0000000,0000000..49a217b new file mode 100644 --- /dev/null +++ b/debian/changelog @@@ -1,0 -1,0 +1,252 @@@ ++pyside2 (5.15.0-5) unstable; urgency=medium ++ ++ * Team upload. ++ * Run tests with QSG_NO_DEPTH_BUFFER=1 on mips64el (see #868745). ++ ++ -- Dmitry Shachnev Mon, 19 Oct 2020 21:50:57 +0300 ++ ++pyside2 (5.15.0-4) unstable; urgency=medium ++ ++ * Team upload. ++ * Drop preload-libglx-mesa.patch, not needed with glibc ≥ 2.31-1. ++ * Backport upstream patch to add support for Python 3.9 (closes: #972194). ++ ++ -- Dmitry Shachnev Thu, 15 Oct 2020 20:06:52 +0300 ++ ++pyside2 (5.15.0-3) unstable; urgency=medium ++ ++ [ Dmitry Shachnev ] ++ * Bump Qt build-dependencies to 5.14. As most Qt packages have a ++ Build-Depends-Package field in their symbols files, dpkg-shlibdeps will ++ use that information and generate a runtime dependency on a new enough ++ Qt version (closes: #963983). ++ ++ [ Kurt Kremitzki ] ++ * Remove Freexian folks and add myself to Uploaders ++ * Correct libshiboken2 CMake include path (Closes: #964201) ++ ++ -- Kurt Kremitzki Sun, 05 Jul 2020 05:13:51 -0500 ++ ++pyside2 (5.15.0-2) unstable; urgency=medium ++ ++ * Team upload. ++ * Preload libGLX_mesa.so.0 in web_engine_initialize.py, to work around ++ test failure on arm64 (closes: #963709). ++ ++ -- Dmitry Shachnev Mon, 29 Jun 2020 15:26:26 +0300 ++ ++pyside2 (5.15.0-1) unstable; urgency=medium ++ ++ [ Gianfranco Costamagna ] ++ * Team upload ++ * Upload to unstable ++ * Drop trailing spaces from changelog file ++ * Bump compat level to 13 ++ * Bump std-version to 4.5.0 ++ * Add R^3: no ++ ++ -- Kurt Kremitzki Thu, 25 Jun 2020 21:15:20 -0500 ++ ++pyside2 (5.15.0-1~exp1) experimental; urgency=medium ++ ++ [ Steve Langasek ] ++ * Add test dependency on python3-all to fix autopkgtests (Closes: #950127) ++ ++ [ Gianfranco Costamagna ] ++ * Add python3-distro needed for tests. ++ * Drop "uic" and "rcc" from control file, removed upstream (LP: #1874095) ++ * Add missing Breaks/Replaces for upgrading from previous version ++ (Closes: #949339) ++ * Drop pyside2uic tests, dropped upstream ++ * New upstream version 5.15.0 (Closes: #950126, Closes: #960008) ++ * Drop old Fix-build-with-Qt-5.12, addressed upstream ++ * Add patch to fix build failures with old qt implementation ++ * Refresh patches ++ * Bump copyright years ++ * Bump soname to 15 ++ * Drop manpage, removed upstream ++ * Use llvm-9 to build, fixing a build failure ++ ++ -- Gianfranco Costamagna Sat, 06 Jun 2020 14:48:45 +0200 ++ ++pyside2 (5.14.0-1~exp1) experimental; urgency=medium ++ ++ [ Raphaël Hertzog ] ++ * Team upload ++ * New upstream version 5.14.0. Closes: #945376, #947101 ++ * Update patches (3 dropped, one new for Qt 5.12 compat) ++ * Use --ignore-git option instead of custom patch ++ * Update package names for version 5.14 ++ * Drop python3-pyside2uic, there's no such library anymore ++ * Re-enable tests failing due to broken XDG_RUNTIME_DIR ++ * Drop package prefix from lintian overrides ++ * Drop removed file from debian/copyright ++ * Fix arch-all build on 32 bit arches. Closes: #948764 ++ Thanks to peter green for the patch. ++ ++ [ Kurt Kremitzki ] ++ * Add CMake sed for pyside2 include path ++ * Add CMake sed for multi-Python version support ++ ++ -- Kurt Kremitzki Mon, 13 Jan 2020 00:10:14 -0600 ++ ++pyside2 (5.13.2-2.2) unstable; urgency=medium ++ ++ * Non-maintainer upload ++ * Update cmake paths for new locations ++ ++ -- Gianfranco Costamagna Sun, 29 Dec 2019 22:44:55 +0100 ++ ++pyside2 (5.13.2-2.1) unstable; urgency=medium ++ ++ * Non-maintainer upload ++ * Add an explicit shiboken dependency to fix FTBFS for reverse-dependencies ++ cmake based, who expect it being installed (Closes: #946082) ++ - thanks Tommaso Colombo for the patch ++ ++ -- Gianfranco Costamagna Tue, 24 Dec 2019 09:22:39 +0100 ++ ++pyside2 (5.13.2-2) unstable; urgency=medium ++ ++ * Do not build-depends on libqt5datavisualization5-dev on mipsel and ++ mpis64el (Closes: #945174) and limit .*qtdatavisualization binary package ++ to arch: amd64 arm64 armel armhf i386 ppc64el s390x ++ * Limit python3-pyside2.qtwebengine to amd64 arm64 armhf i386 mipsel ++ (qtwebengine5-dev is not available for other architectures) ++ * Add a patch to blacklist failing tests ++ ++ -- Sophie Brun Fri, 22 Nov 2019 10:28:55 +0100 ++ ++pyside2 (5.13.2-1) unstable; urgency=medium ++ ++ [ Ondřej Nový ] ++ * Remove almost all of Python 2 binary packages (no rdeps): ++ - python-pyside2.qt3dcore ++ - python-pyside2.qt3dinput ++ - python-pyside2.qt3dlogic ++ - python-pyside2.qt3drender ++ - python-pyside2.qtcharts ++ - python-pyside2.qtconcurrent ++ - python-pyside2.qthelp ++ - python-pyside2.qtlocation ++ - python-pyside2.qtmultimedia ++ - python-pyside2.qtmultimediawidgets ++ - python-pyside2.qtnetwork ++ - python-pyside2.qtpositioning ++ - python-pyside2.qtprintsupport ++ - python-pyside2.qtqml ++ - python-pyside2.qtquick ++ - python-pyside2.qtquickwidgets ++ - python-pyside2.qtscript ++ - python-pyside2.qtscripttools ++ - python-pyside2.qtsensors ++ - python-pyside2.qtsql ++ - python-pyside2.qttest ++ - python-pyside2.qttexttospeech ++ - python-pyside2.qtwebchannel ++ - python-pyside2.qtwebenginecore ++ - python-pyside2.qtwebenginewidgets ++ - python-pyside2.qtwebsockets ++ - python-pyside2.qtx11extras ++ - python-pyside2.qtxmlpatterns ++ ++ [ Sophie Brun ] ++ * Update debian/watch ++ * New upstream version 5.13.2 ++ * Refresh patches and remove obsolete patches ++ * Add missing build-deps ++ * Force pybuild to use distutils, not Cmake ++ * Replace deprecated upstream option --jobs with --parallel ++ * Update documentation build ++ * Add a patch to support Python 3.8 (Closes: #942753) ++ * Add new binary packages ++ - python3-pyside2.qtdatavisualization ++ - python3-pyside2.qtopenglfunctions ++ - python3-pyside2.qtscxml ++ - python3-pyside2.qtwebengine ++ * Update list of built files in debian/rules ++ * Switch pyside2-tools to Python3 ++ * Switch to debhelper-compat 12 ++ * Bump Standards-Version to 4.4.1 (no changes) ++ * Update installation of python3 module shiboken2 ++ * Add autopkgtest ++ * Add missing Conflicts/Replaces and Provides for libpyside2-* ++ * Add a patch to use python3 in pyside2-tools ++ * Remove disable failing test in debian/rules ++ * Add missing depends (Closes: #943709) ++ * Run the tests and add missing build-deps for tests ++ * Remove useless build-dep pyqt5-dev ++ ++ [ Raphaël Hertzog ] ++ * Drop remaining python2 parts. ++ ++ -- Sophie Brun Fri, 15 Nov 2019 10:15:57 +0100 ++ ++pyside2 (5.11.2-3) unstable; urgency=medium ++ ++ [ Sébastien Delafond ] ++ * Do not build-depends on patchelf on mips and mipsel (Closes: #917199) ++ ++ -- Sebastien Delafond Wed, 16 Jan 2019 16:30:16 +0100 ++ ++pyside2 (5.11.2-2) unstable; urgency=medium ++ ++ [ Sébastien Delafond ] ++ * Add myself to uploaders ++ * Do not build-depends on patchelf on mips64el (Closes: #917200) ++ ++ -- Sebastien Delafond Thu, 10 Jan 2019 09:21:43 +0100 ++ ++pyside2 (5.11.2-1) unstable; urgency=medium ++ ++ [ Raphaël Hertzog ] ++ * New upstream version 5.11.2 ++ * Remove patches merged upstream ++ * Merge fix-PAGESIZE.patch into update-patchelf.patch ++ * Add patchelf to Build-Depends ++ * Bump Standards-Version to 4.2.1 ++ ++ [ Frédéric Bonnard ] ++ * Fix hardcoded PAGESIZE for patchelf.cc. Closes: #909265 ++ ++ -- Raphaël Hertzog Fri, 28 Sep 2018 15:09:34 +0200 ++ ++pyside2 (5.11.0-4) unstable; urgency=medium ++ ++ * Use default llvm-dev and libclang-dev (Closes: #906168) ++ * Add Cmake config files for Python3 (Closes: #906020) ++ * Fix debian/libpyside2-5.11.install for triplets that are not *-linux-gnu ++ (thanks to Adrian Bunk) ++ * Add an upstream patch to fix build on armel/armhf ++ ++ -- Sophie Brun Mon, 27 Aug 2018 12:53:29 +0200 ++ ++pyside2 (5.11.0-3) unstable; urgency=medium ++ ++ * More fixes for builds building only arch any or only arch all. ++ * Really fix the build with dpkg-buildpackage -A. ++ ++ -- Raphaël Hertzog Tue, 31 Jul 2018 21:33:04 +0200 ++ ++pyside2 (5.11.0-2) unstable; urgency=medium ++ ++ [ Raphaël Hertzog ] ++ * Fix build with dpkg-buildpackage -A. Closes: #904892 ++ * Fix python-pyside2 dependencies. Replace python-pyside2.widgets by ++ python-pyside2.qtwidgets. ++ ++ [ Sophie Brun ] ++ * Drop useless "Testsuite: autopkgtest-pkg-python". ++ * Enable parallel build. ++ * Limit QtWebEngine packages to amd64 arm64 armhf i386 mipsel. ++ * Remove unused lintian-overrides. ++ * Use python2 only in pyside2-tools. ++ * Remove big metapackages python-pyside2 and python3-pyside2. ++ ++ -- Raphaël Hertzog Tue, 31 Jul 2018 16:37:40 +0200 ++ ++pyside2 (5.11.0-1) unstable; urgency=medium ++ ++ * Initial release (Closes: #877871) ++ ++ -- Sophie Brun Thu, 26 Jul 2018 17:47:45 +0200 diff --cc debian/control index 0000000,0000000..4998a4d new file mode 100644 --- /dev/null +++ b/debian/control @@@ -1,0 -1,0 +1,646 @@@ ++Source: pyside2 ++Section: python ++Priority: optional ++Maintainer: Debian Qt/KDE Maintainers ++Uploaders: Kurt Kremitzki ++Build-Depends: chrpath, ++ cmake (>= 3.1), ++ debhelper-compat (= 13), ++ dh-exec, ++ dh-python, ++ graphviz, ++ libclang-9-dev, ++ libqt5charts5-dev (>= 5.14), ++ libqt5datavisualization5-dev (>= 5.14) [!mips64el !mipsel !mips], ++ libqt5opengl5-dev (>= 5.14), ++ libqt5scxml5-bin (>= 5.14), ++ libqt5scxml5-dev (>= 5.14), ++ libqt5sensors5-dev (>= 5.14), ++ libqt5svg5-dev (>= 5.14), ++ libqt5texttospeech5-dev (>= 5.14), ++ libqt5webchannel5-dev (>= 5.14), ++ libqt5webkit5-dev (>= 5.14), ++ libqt5websockets5-dev (>= 5.14), ++ libqt5x11extras5-dev (>= 5.14), ++ libqt5xmlpatterns5-dev (>= 5.14), ++ libxml2-dev, ++ libxslt1-dev, ++ llvm-9-dev, ++ patchelf [!mips64el !mipsel !mips], ++ python3-all-dev, ++ python3-distro, ++ python3-setuptools, ++ python3-sphinx, ++ python3-sphinx-rtd-theme, ++ python3-wheel, ++ qml-module-qtquick-controls (>= 5.14), ++ qml-module-qtquick-layouts (>= 5.14), ++ qml-module-qtquick2 (>= 5.14), ++ qt3d-assimpsceneimport-plugin (>= 5.14), ++ qt3d-defaultgeometryloader-plugin (>= 5.14), ++ qt3d-gltfsceneio-plugin (>= 5.14), ++ qt3d-scene2d-plugin (>= 5.14), ++ qt3d5-dev (>= 5.14), ++ qt5-qmake (>= 5.14), ++ qt5-qmake-bin (>= 5.14), ++ qtbase5-dev (>= 5.14), ++ qtbase5-private-dev (>= 5.14), ++ qtchooser, ++ qtdeclarative5-dev (>= 5.14), ++ qtdeclarative5-private-dev (>= 5.14), ++ qtlocation5-dev (>= 5.14), ++ qtmultimedia5-dev (>= 5.14), ++ qtpositioning5-dev (>= 5.14), ++ qtscript5-dev (>= 5.14), ++ qttools5-dev (>= 5.14), ++ qtwebengine5-dev (>= 5.14) [amd64 arm64 armhf i386 mipsel], ++ xauth, ++ xvfb ++Rules-Requires-Root: no ++Standards-Version: 4.5.0 ++Homepage: https://wiki.qt.io/Qt_for_Python ++Vcs-Git: https://salsa.debian.org/qt-kde-team/qt/pyside2.git ++Vcs-Browser: https://salsa.debian.org/qt-kde-team/qt/pyside2 ++ ++Package: python-pyside2-doc ++Architecture: all ++Section: doc ++Depends: ${misc:Depends}, ${sphinxdoc:Depends} ++Description: Python bindings for Qt5 (common documentation) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains the common documentation package. ++ ++Package: libpyside2-py3-5.15 ++Section: libs ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends} ++Conflicts: libpyside2-py3-5.11, libpyside2-py3-5.13, libpyside2-py3-5.14 ++Replaces: libpyside2-py3-5.11, libpyside2-py3-5.13, libpyside2-py3-5.14 ++Provides: libpyside2-py3 ++Description: Python 3 bindings for Qt5 (base files) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python3 base file used by all modules. ++ ++Package: libpyside2-dev ++Section: libdevel ++Architecture: any ++Depends: ${misc:Depends}, ${shlibs:Depends}, libpyside2-py3-5.15 (= ${binary:Version}) ++Description: Python bindings for Qt5 (development files) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package provides the development headers for the libpyside2 library. ++ ++Package: python3-pyside2.qtcore ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends} ++Suggests: python-pyside2-doc ++Description: Python bindings for Qt5 core module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtCore module. ++ ++Package: shiboken2 ++Section: devel ++Architecture: any ++Depends: ${misc:Depends}, ${shlibs:Depends} ++Description: CPython bindings generator for C++ libraries ++ Shiboken2 is a bindings generator for C++ libraries that outputs CPython ++ source code. It collects information from library headers, and then ++ merges modifications and handwritten code defined in the typesystem ++ description. ++ . ++ Shiboken2 is the binding generator used to create the PySide2 bindings. ++ ++Package: libshiboken2-py3-5.15 ++Section: libs ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends} ++Conflicts: libshiboken2-py3-5.11, libshiboken2-py3-5.13, libshiboken2-py3-5.14 ++Replaces: libshiboken2-py3-5.11, libshiboken2-py3-5.13, libshiboken2-py3-5.14 ++Provides: libshiboken2-py3 ++Description: CPython bindings generator for C++ libraries (Python3 shared library) ++ Shiboken2 is a bindings generator for C++ libraries that outputs CPython ++ source code. It collects information from library headers, and then ++ merges modifications and handwritten code defined in the typesystem ++ description. ++ . ++ Shiboken2 is the binding generator used to create the PySide2 bindings. ++ . ++ This package contains the shared Python 3 library used by shiboken2. ++ ++Package: libshiboken2-dev ++Section: libdevel ++Architecture: any ++Depends: ${misc:Depends}, ${shlibs:Depends}, ++ libshiboken2-py3-5.15 (= ${binary:Version}), shiboken2 (= ${binary:Version}), python3-dev ++Description: CPython bindings generator for C++ libraries (development files) ++ Shiboken2 is a bindings generator for C++ libraries that outputs CPython ++ source code. It collects information from library headers, and then ++ merges modifications and handwritten code defined in the typesystem ++ description. ++ . ++ Shiboken2 is the binding generator used to create the PySide2 bindings. ++ . ++ This package provides the development headers for the libshiboken2 library. ++ ++Package: shiboken2-doc ++Architecture: all ++Section: doc ++Depends: ${misc:Depends}, ${sphinxdoc:Depends} ++Description: CPython bindings generator for C++ libraries (common documentation) ++ Shiboken2 is a bindings generator for C++ libraries that outputs CPython ++ source code. It collects information from library headers, and then ++ merges modifications and handwritten code defined in the typesystem ++ description. ++ . ++ Shiboken2 is the binding generator used to create the PySide2 bindings. ++ . ++ This package contains the common documentation. ++ ++Package: pyside2-tools ++Architecture: any ++Depends: ${misc:Depends}, ${shlibs:Depends}, ${python3:Depends}, python3-pyside2.qtcore ++Description: development tools for PySide2 (lupdate) ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ PySide2 ships Python bindings for the Qt5 framework. This package ships ++ the following accompanying tools: ++ * pyside2-lupdate - update Qt Linguist translation files for PySide ++ ++Package: python3-pyside2.qtwidgets ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtgui ++Description: Python bindings for Qt5 Widgets module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtWidgets module. ++ ++Package: python3-pyside2.qt3drender ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qt3dcore, python3-pyside2.qtcore, python3-pyside2.qtgui ++Description: Python bindings for Qt5 3DRender module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the Qt3DRender module. ++ ++Package: python3-pyside2.qtquick ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtnetwork, python3-pyside2.qtqml, ++ python3-pyside2.qtgui ++Description: Python bindings for Qt5 Quick module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtQuick module. ++ ++Package: python3-pyside2.qtpositioning ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 Positioning module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtPositioning module. ++ ++Package: python3-pyside2.qtx11extras ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtgui ++Description: Python bindings for Qt5 X11Extras module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtX11Extras module. ++ ++Package: python3-pyside2.qtqml ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtgui, python3-pyside2.qtnetwork ++Description: Python bindings for Qt5 Qml module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtQml module. ++ ++Package: python3-pyside2.qtwebenginecore ++Architecture: amd64 arm64 armhf i386 mipsel ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 WebEngineCore module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtWebEngineCore module. ++ ++Package: python3-pyside2.qttexttospeech ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 TextToSpeech module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtTextToSpeech module. ++ ++Package: python3-pyside2.qthelp ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtwidgets, python3-pyside2.qtcore, python3-pyside2.qtgui ++Description: Python bindings for Qt5 Help module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtHelp module. ++ ++Package: python3-pyside2.qtscripttools ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtscript, python3-pyside2.qtwidgets, python3-pyside2.qtgui, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 ScriptTools module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtScriptTools module. ++ ++Package: python3-pyside2.qtnetwork ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 Network module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtNetwork module. ++ ++Package: python3-pyside2.qtmultimediawidgets ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtgui, python3-pyside2.qtnetwork, ++ python3-pyside2.qtwidgets, python3-pyside2.qtmultimedia ++Description: Python bindings for Qt5 MultimediaWidgets module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtMultimediaWidgets module. ++ ++Package: python3-pyside2.qtlocation ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtpositioning ++Description: Python bindings for Qt5 Location module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtLocation module. ++ ++Package: python3-pyside2.qt3dlogic ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtgui, python3-pyside2.qt3dcore ++Description: Python bindings for Qt5 3DLogic module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the Qt3DLogic module. ++ ++Package: python3-pyside2.qtsensors ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 Sensors module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtSensors module. ++ ++Package: python3-pyside2.qtmultimedia ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtgui, python3-pyside2.qtnetwork ++Description: Python bindings for Qt5 Multimedia module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtMultimedia module. ++ ++Package: python3-pyside2.qtscript ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 Script module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtScript module. ++ ++Package: python3-pyside2.qtwebchannel ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 WebChannel module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtWebChannel module. ++ ++Package: python3-pyside2.qtprintsupport ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtwidgets, python3-pyside2.qtcore, python3-pyside2.qtgui ++Description: Python bindings for Qt5 PrintSupport module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtPrintSupport module. ++ ++Package: python3-pyside2.qtquickwidgets ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtgui, python3-pyside2.qtwidgets, ++ python3-pyside2.qtnetwork, python3-pyside2.qtquick, python3-pyside2.qtqml ++Description: Python bindings for Qt5 QuickWidgets module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtQuickWidgets module. ++ ++Package: python3-pyside2.qt3dinput ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qt3dcore, python3-pyside2.qtcore, python3-pyside2.qtgui ++Description: Python bindings for Qt5 3DInput module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the Qt3DInput module. ++ ++Package: python3-pyside2.qtxml ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 Xml module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtXml module. ++ ++Package: python3-pyside2.qttest ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtgui, python3-pyside2.qtwidgets ++Description: Python bindings for Qt5 Test module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtTest module. ++ ++Package: python3-pyside2.qtwebenginewidgets ++Architecture: amd64 arm64 armhf i386 mipsel ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtgui, python3-pyside2.qtwidgets, ++ python3-pyside2.qtnetwork, python3-pyside2.qtwebchannel, ++ python3-pyside2.qtwebenginecore, python3-pyside2.qtprintsupport ++Description: Python bindings for Qt5 WebEngineWidgets module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtWebEngineWidgets module. ++ ++Package: python3-pyside2.qtconcurrent ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 Concurrent module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtConcurrent module. ++ ++Package: python3-pyside2.qtxmlpatterns ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 XmlPatterns module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtXmlPatterns module. ++ ++Package: python3-pyside2.qtcharts ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtwidgets, python3-pyside2.qtcore, python3-pyside2.qtgui ++Description: Python bindings for Qt5 Charts module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtCharts module. ++ ++Package: python3-pyside2.qtuitools ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtwidgets, python3-pyside2.qtxml, python3-pyside2.qtcore, ++ python3-pyside2.qtgui ++Description: Python bindings for Qt5 UiTools module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtUiTools module. ++ ++Package: python3-pyside2.qtopengl ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtwidgets, python3-pyside2.qtcore, python3-pyside2.qtgui ++Description: Python bindings for Qt5 OpenGL module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtOpenGL module. ++ ++Package: python3-pyside2.qt3dcore ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtgui, python3-pyside2.qtcore, python3-pyside2.qtnetwork ++Description: Python bindings for Qt5 3DCore module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the Qt3DCore module. ++ ++Package: python3-pyside2.qtsql ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtwidgets, python3-pyside2.qtgui, python3-pyside2.qtcore ++Description: Python bindings for Qt5 Sql module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtSql module. ++ ++Package: python3-pyside2.qtgui ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 Gui module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtGui module. ++ ++Package: python3-pyside2.qtsvg ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtwidgets, python3-pyside2.qtgui, python3-pyside2.qtcore ++Description: Python bindings for Qt5 Svg module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtSvg module. ++ ++Package: python3-pyside2.qtwebsockets ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore, python3-pyside2.qtnetwork ++Description: Python bindings for Qt5 WebSockets module (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtWebSockets module. ++ ++Package: python3-pyside2.qtdatavisualization ++Architecture: amd64 arm64 armel armhf i386 ppc64el s390x ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtgui, python3-pyside2.qtcore ++Description: Python bindings for Qt5 Data Visualization (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtDataVisualization module. ++ ++Package: python3-pyside2.qtopenglfunctions ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtgui, python3-pyside2.qtcore ++Description: Python bindings for Qt5 Open GL Functions (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the OpenGLFunctions module. ++ ++Package: python3-pyside2.qtscxml ++Architecture: any ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 Scxml (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the Scxml module. ++ ++Package: python3-pyside2.qtwebengine ++Architecture: amd64 arm64 armhf i386 mipsel ++Depends: ${misc:Depends}, ${python3:Depends}, ${shlibs:Depends}, ++ python3-pyside2.qtcore ++Description: Python bindings for Qt5 Web Engine (Python 3) ++ pyside2 provides Python bindings for Qt 5.x framework. ++ . ++ Qt is a cross-platform C++ application framework. Qt's primary feature ++ is its rich set of widgets that provide standard GUI functionality. ++ . ++ This package contains Python 3 bindings for the QtWebEngine module. diff --cc debian/copyright index 0000000,0000000..4a4cb21 new file mode 100644 --- /dev/null +++ b/debian/copyright @@@ -1,0 -1,0 +1,260 @@@ ++Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ ++Upstream-Name: pyside2 ++Source: https://download.qt.io/official_releases/QtForPython/ ++ ++Files: * ++Copyright: 2016-2020 The Qt Company Ltd. ++License: GPL-2 or GPL-3 or LGPL-3 ++ ++Files: examples/* ++Copyright: 2016-2018 The Qt Company Ltd. ++ 2011 Arun Srinivasan ++ 2010-2013 Riverbank Computing Limited. ++ 2010 Hans-Peter Jansen ++ 2010 velociraptor Genjix ++ 2009 Darryl Wallace, 2009 ++License: BSD-3-clause ++ ++Files: sources/patchelf/* ++Copyright: 2004-2009 Eelco Dolstra ++License: GPL-3+ ++ ++Files: sources/patchelf/elf.h ++Copyright: 1995-2008 Free Software Foundation, Inc. ++License: LGPL-2.1+ ++ ++Files: sources/pyside2/doc/typesystem_doc.xml.in ++ sources/pyside2/doc/codesnippets/* ++ sources/pyside2/doc/tutorials/* ++Copyright: 2016 The Qt Company Ltd. ++License: BSD-3-clause ++ ++Files: sources/pyside2/doc/inheritance_diagram.py ++Copyright: 2010-2011 by the PySide team ++ 2007-2011 by the Sphinx team ++License: BSD-2-clause ++ All rights reserved. ++ . ++ Redistribution and use in source and binary forms, with or without ++ modification, are permitted provided that the following conditions are ++ met: ++ . ++ * Redistributions of source code must retain the above copyright ++ notice, this list of conditions and the following disclaimer. ++ . ++ * Redistributions in binary form must reproduce the above copyright ++ notice, this list of conditions and the following disclaimer in the ++ documentation and/or other materials provided with the distribution. ++ . ++ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++ HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++Files: sources/pyside2/tests/run_test.sh ++ sources/pyside2/tests/Qt* ++ sources/pyside2/tests/mac/qmacstyle_test.py ++ sources/pyside2/tests/manually/* ++ sources/pyside2/tests/pysidetest/* ++ sources/pyside2/tests/signals/* ++ sources/pyside2/tests/util/* ++ sources/shiboken2/ApiExtractor/* ++ sources/shiboken2/generator/* ++ sources/shiboken2/generatorrunnermacros.h ++ sources/shiboken2/generators/* ++ sources/shiboken2/tests/* ++ sources/pyside2/tests/QtQml/qquickitem_grabToImage.* ++Copyright: 2009 Matthias Klose ++ 2002-2005 Roberto Raggi ++ 2011 Thomas Perl ++ 2013 Kitware, Inc. ++ 2016-2017 The Qt Company Ltd. ++License: GPL-3-EXCEPT ++ ++Files: sources/pyside2-tools/* ++Copyright: 2016 The Qt Company Ltd. ++ 2010 Riverbank Computing Limited. ++ 2009-2011 Nokia Corporation and/or its subsidiary(-ies) ++ 2009 Torsten Marek ++ 2002-2007 Detlev Offenbach ++ 1992-2006 Trolltech AS. All rights reserved. ++License: GPL-2 ++ ++Files: debian/* ++Copyright: 2018 Sophie Brun ++License: GPL-2+ ++ This package is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 2 of the License, or ++ (at your option) any later version. ++ . ++ This package is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ . ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see ++ . ++ On Debian systems, the complete text of the GNU General ++ Public License version 2 can be found in "/usr/share/common-licenses/GPL-2". ++ ++License: BSD-3-clause ++ Redistribution and use in source and binary forms, with or without ++ modification, are permitted provided that the following conditions are ++ met: ++ * Redistributions of source code must retain the above copyright ++ notice, this list of conditions and the following disclaimer. ++ * Redistributions in binary form must reproduce the above copyright ++ notice, this list of conditions and the following disclaimer in ++ the documentation and/or other materials provided with the ++ distribution. ++ * Neither the name of The Qt Company Ltd nor the names of its ++ contributors may be used to endorse or promote products derived ++ from this software without specific prior written permission. ++ . ++ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." ++ ++License: GPL-2 ++ This package is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License version 2 as ++ published by the Free Software Foundation. ++ . ++ This package is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ . ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see ++ . ++ On Debian systems, the complete text of the GNU General ++ Public License version 2 can be found in "/usr/share/common-licenses/GPL-2" ++ ++License: GPL-3 ++ This package is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License version 3 as ++ published by the Free Software Foundation. ++ . ++ This package is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ . ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see ++ . ++ On Debian systems, the complete text of the GNU General ++ Public License version 3 can be found in "/usr/share/common-licenses/GPL-3" ++ ++License: GPL-3+ ++ This package is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation, either version 3 of the License, or ++ (at your option) any later version. ++ . ++ This package is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ . ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see ++ . ++ On Debian systems, the complete text of the GNU General ++ Public License version 3 can be found in "/usr/share/common-licenses/GPL-3" ++ ++License: GPL-3-EXCEPT ++ This package is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License version 3 as ++ published by the Free Software Foundation, annotated with The Qt Company ++ GPL Exception 1.0: ++ . ++ The Qt Company GPL Exception 1.0 ++ . ++ Exception 1: ++ . ++ As a special exception you may create a larger work which contains the ++ output of this application and distribute that work under terms of your ++ choice, so long as the work is not otherwise derived from or based on ++ this application and so long as the work does not in itself generate ++ output that contains the output from this application in its original ++ or modified form. ++ . ++ Exception 2: ++ . ++ As a special exception, you have permission to combine this application ++ with Plugins licensed under the terms of your choice, to produce an ++ executable, and to copy and distribute the resulting executable under ++ the terms of your choice. However, the executable must be accompanied ++ by a prominent notice offering all users of the executable the entire ++ source code to this application, excluding the source code of the ++ independent modules, but including any changes you have made to this ++ application, under the terms of this license. ++ . ++ This package is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ . ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see ++ . ++ On Debian systems, the complete text of the GNU General ++ Public License version 3 can be found in "/usr/share/common-licenses/GPL-3" ++ ++License: LGPL-2.1+ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ . ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ . ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library; if not, write to the Free Software ++ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 ++ USA ++ . ++ On Debian systems, the complete text of the Lesser GNU General ++ Public License version 2.1 can be found in ++ "/usr/share/common-licenses/LGPL-2.1" ++ ++License: LGPL-3 ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License version 3 as published by the Free Software Foundation. ++ . ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ . ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library; if not, write to the Free Software ++ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 ++ USA ++ . ++ On Debian systems, the complete text of the Lesser GNU General ++ Public License version 3 can be found in ++ "/usr/share/common-licenses/LGPL-3" diff --cc debian/libpyside2-dev.install index 0000000,0000000..6a8e25e new file mode 100755 --- /dev/null +++ b/debian/libpyside2-dev.install @@@ -1,0 -1,0 +1,6 @@@ ++#!/usr/bin/dh-exec --with=subst ++pyside3_install/py3*-relwithdebinfo/include/PySide2 usr/include ++pyside3_install/py3*-relwithdebinfo/share/PySide2 usr/share ++pyside3_install/py3*-relwithdebinfo/lib/pkgconfig/pyside2.pc usr/lib/${DEB_HOST_MULTIARCH}/pkgconfig ++pyside3_install/py3*-relwithdebinfo/lib/libpyside2*.so usr/lib/${DEB_HOST_MULTIARCH} ++pyside3_install/py3*-relwithdebinfo/lib/cmake/PySide2* usr/lib/${DEB_HOST_MULTIARCH}/cmake diff --cc debian/libpyside2-py3-5.15.install index 0000000,0000000..28f46be new file mode 100755 --- /dev/null +++ b/debian/libpyside2-py3-5.15.install @@@ -1,0 -1,0 +1,5 @@@ ++#!/usr/bin/dh-exec ++pyside3_install/py3*-relwithdebinfo/lib/libpyside2*.so.* usr/lib/${DEB_HOST_MULTIARCH} ++pyside3_install/py3*-relwithdebinfo/lib/python*/site-packages/PySide2/_git_pyside_version.py usr/lib/python3/dist-packages/PySide2 ++pyside3_install/py3*-relwithdebinfo/lib/python*/site-packages/PySide2/__init__.py usr/lib/python3/dist-packages/PySide2 ++pyside3_install/py3*-relwithdebinfo/lib/python*/site-packages/PySide2/_config.py usr/lib/python3/dist-packages/PySide2 diff --cc debian/libpyside2-py3-5.15.lintian-overrides index 0000000,0000000..c85f9d2 new file mode 100644 --- /dev/null +++ b/debian/libpyside2-py3-5.15.lintian-overrides @@@ -1,0 -1,0 +1,2 @@@ ++# We ship compiled versions for each supported python3 version, with a symlink to the default version ++package-name-doesnt-match-sonames * diff --cc debian/libshiboken2-dev.install index 0000000,0000000..58d7607 new file mode 100755 --- /dev/null +++ b/debian/libshiboken2-dev.install @@@ -1,0 -1,0 +1,5 @@@ ++#!/usr/bin/dh-exec --with=subst ++pyside3_install/py3*-relwithdebinfo/include/shiboken2 usr/include ++pyside3_install/py3*-relwithdebinfo/lib/pkgconfig/shiboken2.pc usr/lib/${DEB_HOST_MULTIARCH}/pkgconfig ++pyside3_install/py3*-relwithdebinfo/lib/libshiboken2*.so usr/lib/${DEB_HOST_MULTIARCH} ++pyside3_install/py3*-relwithdebinfo/lib/cmake/Shiboken2* usr/lib/${DEB_HOST_MULTIARCH}/cmake diff --cc debian/libshiboken2-py3-5.15.install index 0000000,0000000..10e7460 new file mode 100755 --- /dev/null +++ b/debian/libshiboken2-py3-5.15.install @@@ -1,0 -1,0 +1,3 @@@ ++#!/usr/bin/dh-exec ++pyside3_install/py3*-relwithdebinfo/lib/libshiboken2*.so.* usr/lib/${DEB_HOST_MULTIARCH} ++pyside3_install/py3*-relwithdebinfo/lib/python3*/site-packages/shiboken2/* usr/lib/python3/dist-packages/shiboken2 diff --cc debian/libshiboken2-py3-5.15.lintian-overrides index 0000000,0000000..c85f9d2 new file mode 100644 --- /dev/null +++ b/debian/libshiboken2-py3-5.15.lintian-overrides @@@ -1,0 -1,0 +1,2 @@@ ++# We ship compiled versions for each supported python3 version, with a symlink to the default version ++package-name-doesnt-match-sonames * diff --cc debian/patches/blacklist-failing-tests.patch index 0000000,0000000..43c58e9 new file mode 100644 --- /dev/null +++ b/debian/patches/blacklist-failing-tests.patch @@@ -1,0 -1,0 +1,34 @@@ ++From: Sophie Brun ++Date: Fri, 22 Nov 2019 13:24:54 +0100 ++Subject: Blacklist failing tests ++ ++Forwarded: ++https://bugreports.qt.io/projects/PYSIDE/issues/PYSIDE-1146?filter=allopenissues ++--- ++ build_history/blacklist.txt | 6 ++++++ ++ 1 file changed, 6 insertions(+) ++ ++diff --git a/build_history/blacklist.txt b/build_history/blacklist.txt ++index adcf520..710d506 100644 ++--- a/build_history/blacklist.txt +++++ b/build_history/blacklist.txt ++@@ -25,6 +25,9 @@ ++ linux ++ darwin ++ win32 +++# crash on s390x Debian build, https://bugreports.qt.io/projects/PYSIDE/issues/PYSIDE-1146 +++[QtCore::qbytearray_test] +++ linux ++ [QtGui::qmatrix_test] ++ win32 ++ [QtWidgets::bug_576] ++@@ -86,6 +89,9 @@ ++ win32 ++ linux ++ darwin +++# crash on s390x Debian build, https://bugreports.qt.io/projects/PYSIDE/issues/PYSIDE-1146 +++[QtQml::qquickitem_grabToImage] +++ linux ++ # In addition to a pre-existing windows failure, ++ # qtlocation/ac899dcc40bb3ad09307583fb7e6befd45a77b33 / QTBUG-66304 introduced ++ # a failure in 5.14 diff --cc debian/patches/fix-spelling-errors.patch index 0000000,0000000..65a4b59 new file mode 100644 --- /dev/null +++ b/debian/patches/fix-spelling-errors.patch @@@ -1,0 -1,0 +1,42 @@@ ++From: Sophie Brun ++Date: Tue, 5 Nov 2019 10:39:14 +0100 ++Subject: Fix spelling errors ++ ++Last-Update: 2018-07-12 ++ ++Last-Update: 2018-07-12 ++--- ++ sources/pyside2/libpyside/pysideproperty.cpp | 6 +++--- ++ 1 file changed, 3 insertions(+), 3 deletions(-) ++ ++diff --git a/sources/pyside2/libpyside/pysideproperty.cpp b/sources/pyside2/libpyside/pysideproperty.cpp ++index 009a17a..4d3f450 100644 ++--- a/sources/pyside2/libpyside/pysideproperty.cpp +++++ b/sources/pyside2/libpyside/pysideproperty.cpp ++@@ -253,7 +253,7 @@ PyObject *qPropertySetter(PyObject *self, PyObject *callback) ++ Py_INCREF(callback); ++ return callback; ++ } ++- PyErr_SetString(PyExc_TypeError, "Invalid property setter agument."); +++ PyErr_SetString(PyExc_TypeError, "Invalid property setter argument."); ++ return nullptr; ++ } ++ ++@@ -269,7 +269,7 @@ PyObject *qPropertyGetter(PyObject *self, PyObject *callback) ++ Py_INCREF(callback); ++ return callback; ++ } ++- PyErr_SetString(PyExc_TypeError, "Invalid property getter agument."); +++ PyErr_SetString(PyExc_TypeError, "Invalid property getter argument."); ++ return nullptr; ++ } ++ ++@@ -389,7 +389,7 @@ int setValue(PySideProperty *self, PyObject *source, PyObject *value) ++ Shiboken::AutoDecRef result(PyObject_CallObject(fset, args)); ++ return (result.isNull() ? -1 : 0); ++ } else { ++- PyErr_SetString(PyExc_AttributeError, "Attibute read only"); +++ PyErr_SetString(PyExc_AttributeError, "Attribute read only"); ++ } ++ return -1; ++ } diff --cc debian/patches/ftbfs-old-qt.patch index 0000000,0000000..96e32f7 new file mode 100644 --- /dev/null +++ b/debian/patches/ftbfs-old-qt.patch @@@ -1,0 -1,0 +1,1917 @@@ ++Description: Revert endl changes because incompatible with qt 5.14 ++Author: Gianfranco Costamagna ++Last-Update: 2020-06-06 ++ ++Index: pyside2/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp ++=================================================================== ++--- pyside2.orig/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp +++++ pyside2/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp ++@@ -2908,7 +2908,7 @@ ++ ++ ++ for (int reason = 0; reason < AbstractMetaBuilder::NoReason; ++reason) { ++- s << QString(72, QLatin1Char('*')) << Qt::endl; +++ s << QString(72, QLatin1Char('*')) << endl; ++ switch (reason) { ++ case AbstractMetaBuilder::NotInTypeSystem: ++ s << "Not in type system"; ++@@ -2941,16 +2941,16 @@ ++ break; ++ } ++ ++- s << Qt::endl; +++ s << endl; ++ ++ for (QMap::const_iterator it = rejects.constBegin(); ++ it != rejects.constEnd(); ++it) { ++ if (it.value() != reason) ++ continue; ++- s << " - " << it.key() << Qt::endl; +++ s << " - " << it.key() << endl; ++ } ++ ++- s << QString(72, QLatin1Char('*')) << Qt::endl << Qt::endl; +++ s << QString(72, QLatin1Char('*')) << endl << endl; ++ } ++ ++ } ++Index: pyside2/sources/shiboken2/ApiExtractor/include.cpp ++=================================================================== ++--- pyside2.orig/sources/shiboken2/ApiExtractor/include.cpp +++++ pyside2/sources/shiboken2/ApiExtractor/include.cpp ++@@ -49,7 +49,7 @@ ++ QTextStream& operator<<(QTextStream& out, const Include& include) ++ { ++ if (include.isValid()) ++- out << include.toString() << Qt::endl; +++ out << include.toString() << endl; ++ return out; ++ } ++ ++Index: pyside2/sources/shiboken2/generator/generator.cpp ++=================================================================== ++--- pyside2.orig/sources/shiboken2/generator/generator.cpp +++++ pyside2/sources/shiboken2/generator/generator.cpp ++@@ -570,7 +570,7 @@ ++ ++ s << indentor << line.remove(0, limit); ++ } ++- s << Qt::endl; +++ s << endl; ++ } ++ return s; ++ } ++Index: pyside2/sources/shiboken2/generator/main.cpp ++=================================================================== ++--- pyside2.orig/sources/shiboken2/generator/main.cpp +++++ pyside2/sources/shiboken2/generator/main.cpp ++@@ -74,11 +74,11 @@ ++ if (od.second.isEmpty()) { ++ s << ", "; ++ } else { ++- s << Qt::endl; +++ s << endl; ++ const auto lines = od.second.splitRef(QLatin1Char('\n')); ++ for (const auto &line : lines) ++- s << " " << line << Qt::endl; ++- s << Qt::endl; +++ s << " " << line << endl; +++ s << endl; ++ } ++ } ++ } ++@@ -344,7 +344,7 @@ ++ for (const GeneratorPtr &generator : generators) { ++ const OptionDescriptions options = generator->options(); ++ if (!options.isEmpty()) { ++- s << Qt::endl << generator->name() << " options:\n\n"; +++ s << endl << generator->name() << " options:\n\n"; ++ printOptions(s, generator->options()); ++ } ++ } ++@@ -371,7 +371,7 @@ ++ const CommandArgumentMap::iterator it = args.find(option); ++ if (it != args.end()) { ++ const QStringList includePathListList = ++- it.value().split(pathSplitter, Qt::SkipEmptyParts); +++ it.value().split(pathSplitter, QString::SkipEmptyParts); ++ args.erase(it); ++ for (const QString &s : includePathListList) { ++ auto path = QFile::encodeName(QDir::cleanPath(s)); ++Index: pyside2/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp ++=================================================================== ++--- pyside2.orig/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp +++++ pyside2/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp ++@@ -172,7 +172,7 @@ ++ static QTextStream &ensureEndl(QTextStream &s) ++ { ++ if (lastChar(s) != QLatin1Char('\n')) ++- s << Qt::endl; +++ s << endl; ++ return s; ++ } ++ ++@@ -502,10 +502,10 @@ ++ ++ if (!m_inlineImages.isEmpty()) { ++ // Write out inline image definitions stored in handleInlineImageTag(). ++- m_output << Qt::endl; +++ m_output << endl; ++ for (const InlineImage &img : qAsConst(m_inlineImages)) ++- m_output << ".. |" << img.tag << "| image:: " << img.href << Qt::endl; ++- m_output << Qt::endl; +++ m_output << ".. |" << img.tag << "| image:: " << img.href << endl; +++ m_output << endl; ++ m_inlineImages.clear(); ++ } ++ ++@@ -608,11 +608,11 @@ ++ else ++ type = types[typeIdx]; ++ } else if (token == QXmlStreamReader::EndElement) { ++- m_output << Pad(type, headingSize) << Qt::endl << Qt::endl; +++ m_output << Pad(type, headingSize) << endl << endl; ++ } else if (token == QXmlStreamReader::Characters) { ++- m_output << Qt::endl << Qt::endl; +++ m_output << endl << endl; ++ headingSize = writeEscapedRstText(m_output, reader.text().trimmed()); ++- m_output << Qt::endl; +++ m_output << endl; ++ } ++ } ++ ++@@ -628,7 +628,7 @@ ++ else if (result.startsWith(QLatin1String("**Note:**"))) ++ result.replace(0, 9, QLatin1String(".. note:: ")); ++ ++- m_output << INDENT << result << Qt::endl << Qt::endl; +++ m_output << INDENT << result << endl << endl; ++ } else if (token == QXmlStreamReader::Characters) { ++ const QStringRef text = reader.text(); ++ const QChar end = lastChar(m_output); ++@@ -726,7 +726,7 @@ ++ handleLinkEnd(m_seeAlsoContext.data()); ++ m_seeAlsoContext.reset(); ++ } ++- m_output << Qt::endl << Qt::endl; +++ m_output << endl << endl; ++ break; ++ default: ++ break; ++@@ -747,7 +747,7 @@ ++ for (const QStringRef &line : lines) { ++ if (!line.trimmed().isEmpty()) ++ str << indent << line; ++- str << Qt::endl; +++ str << endl; ++ } ++ } ++ ++@@ -811,7 +811,7 @@ ++ m_output << INDENT << "\n"; ++ else ++ formatSnippet(m_output, INDENT, code); ++- m_output << Qt::endl; +++ m_output << endl; ++ } ++ } ++ void QtXmlToSphinx::handleDotsTag(QXmlStreamReader& reader) ++@@ -930,16 +930,16 @@ ++ switch (listType) { ++ case BulletList: ++ case OrderedList: { ++- m_output << Qt::endl; +++ m_output << endl; ++ const char *separator = listType == BulletList ? "* " : "#. "; ++ const char *indent = listType == BulletList ? " " : " "; ++ for (const TableCell &cell : m_currentTable.constFirst()) { ++ const QVector itemLines = cell.data.splitRef(QLatin1Char('\n')); ++- m_output << INDENT << separator << itemLines.constFirst() << Qt::endl; +++ m_output << INDENT << separator << itemLines.constFirst() << endl; ++ for (int i = 1, max = itemLines.count(); i < max; ++i) ++- m_output << INDENT << indent << itemLines[i] << Qt::endl; +++ m_output << INDENT << indent << itemLines[i] << endl; ++ } ++- m_output << Qt::endl; +++ m_output << endl; ++ } ++ break; ++ case EnumeratedList: ++@@ -1144,7 +1144,7 @@ ++ return; ++ const QString href = reader.attributes().value(QLatin1String("href")).toString(); ++ if (copyImage(href)) ++- m_output << INDENT << ".. image:: " << href << Qt::endl << Qt::endl; +++ m_output << INDENT << ".. image:: " << href << endl << endl; ++ } ++ ++ void QtXmlToSphinx::handleInlineImageTag(QXmlStreamReader& reader) ++@@ -1174,13 +1174,13 @@ ++ QXmlStreamReader::TokenType token = reader.tokenType(); ++ if (token == QXmlStreamReader::StartElement) { ++ QString format = reader.attributes().value(QLatin1String("format")).toString(); ++- m_output << INDENT << ".. raw:: " << format.toLower() << Qt::endl << Qt::endl; +++ m_output << INDENT << ".. raw:: " << format.toLower() << endl << endl; ++ } else if (token == QXmlStreamReader::Characters) { ++ const QVector lst(reader.text().split(QLatin1Char('\n'))); ++ for (const QStringRef &row : lst) ++- m_output << INDENT << INDENT << row << Qt::endl; +++ m_output << INDENT << INDENT << row << endl; ++ } else if (token == QXmlStreamReader::EndElement) { ++- m_output << Qt::endl << Qt::endl; +++ m_output << endl << endl; ++ } ++ } ++ ++@@ -1193,9 +1193,9 @@ ++ } else if (token == QXmlStreamReader::Characters) { ++ const QVector lst(reader.text().split(QLatin1Char('\n'))); ++ for (const QStringRef &row : lst) ++- m_output << INDENT << INDENT << row << Qt::endl; +++ m_output << INDENT << INDENT << row << endl; ++ } else if (token == QXmlStreamReader::EndElement) { ++- m_output << Qt::endl << Qt::endl; +++ m_output << endl << endl; ++ INDENT.indent--; ++ } ++ } ++@@ -1235,7 +1235,7 @@ ++ ? writeEscapedRstText(m_output, title) ++ : writeEscapedRstText(m_output, fullTitle); ++ ++- m_output << Qt::endl << Pad('*', size) << Qt::endl << Qt::endl; +++ m_output << endl << Pad('*', size) << endl << endl; ++ } ++ ++ void QtXmlToSphinx::handleTargetTag(QXmlStreamReader &reader) ++@@ -1299,7 +1299,7 @@ ++ m_output << INDENT << "\n"; ++ else ++ formatCode(m_output, code, INDENT); ++- m_output << Qt::endl; +++ m_output << endl; ++ } ++ } ++ ++@@ -1435,7 +1435,7 @@ ++ c = '-'; ++ s << Pad(c, colWidths.at(col)) << '+'; ++ } ++- s << Qt::endl; +++ s << endl; ++ ++ ++ // Print the table cells ++@@ -1452,7 +1452,7 @@ ++ else ++ s << ' '; ++ if (rowLine < rowLines.count()) ++- s << qSetFieldWidth(colWidths[j]) << Qt::left << rowLines.at(rowLine) << qSetFieldWidth(0); +++ s << qSetFieldWidth(colWidths[j]) << left << rowLines.at(rowLine) << qSetFieldWidth(0); ++ else ++ s << Pad(' ', colWidths.at(j)); ++ } ++@@ -1461,7 +1461,7 @@ ++ s << "|\n"; ++ } ++ } ++- s << INDENT << horizontalLine << Qt::endl << Qt::endl; +++ s << INDENT << horizontalLine << endl << endl; ++ } ++ ++ static QString getFuncName(const AbstractMetaFunction* cppFunc) { ++@@ -1562,11 +1562,11 @@ ++ s << INDENT ++ << (typesystemIndentation > 0 && typesystemIndentation < line.size() ++ ? line.right(line.size() - typesystemIndentation) : line) ++- << Qt::endl; +++ << endl; ++ } ++ } ++ ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ static void writeInheritedByList(QTextStream& s, const AbstractMetaClass* metaClass, const AbstractMetaClassList& allClasses) ++@@ -1584,7 +1584,7 @@ ++ QStringList classes; ++ for (AbstractMetaClass *c : qAsConst(res)) ++ classes << QLatin1String(":ref:`") + getClassTargetFullName(c, false) + QLatin1Char('`'); ++- s << classes.join(QLatin1String(", ")) << Qt::endl << Qt::endl; +++ s << classes.join(QLatin1String(", ")) << endl << endl; ++ } ++ ++ // Extract the section from a WebXML (class) documentation and remove it ++@@ -1625,15 +1625,15 @@ ++ s << ".. _" << className << ":" << "\n\n"; ++ s << ".. currentmodule:: " << metaClass->package() << "\n\n\n"; ++ ++- s << className << Qt::endl; ++- s << Pad('*', className.count()) << Qt::endl << Qt::endl; +++ s << className << endl; +++ s << Pad('*', className.count()) << endl << endl; ++ ++ auto documentation = metaClass->documentation(); ++ Documentation brief; ++ if (extractBrief(&documentation, &brief)) ++ writeFormattedText(s, brief, metaClass); ++ ++- s << ".. inheritance-diagram:: " << getClassTargetFullName(metaClass, true) << Qt::endl +++ s << ".. inheritance-diagram:: " << getClassTargetFullName(metaClass, true) << endl ++ << " :parts: 2\n\n"; // TODO: This would be a parameter in the future... ++ ++ ++@@ -1740,17 +1740,17 @@ ++ void QtDocGenerator::writeFunctionBlock(QTextStream& s, const QString& title, QStringList& functions) ++ { ++ if (!functions.isEmpty()) { ++- s << title << Qt::endl ++- << QString(title.size(), QLatin1Char('^')) << Qt::endl; +++ s << title << endl +++ << QString(title.size(), QLatin1Char('^')) << endl; ++ ++ std::sort(functions.begin(), functions.end()); ++ ++ s << ".. container:: function_list\n\n"; ++ Indentation indentation(INDENT); ++ for (const QString &func : qAsConst(functions)) ++- s << INDENT << '*' << ' ' << func << Qt::endl; +++ s << INDENT << '*' << ' ' << func << endl; ++ ++- s << Qt::endl << Qt::endl; +++ s << endl << endl; ++ } ++ } ++ ++@@ -1760,7 +1760,7 @@ ++ ++ const AbstractMetaEnumList &enums = cppClass->enums(); ++ for (AbstractMetaEnum *en : enums) { ++- s << section_title << getClassTargetFullName(cppClass) << '.' << en->name() << Qt::endl << Qt::endl; +++ s << section_title << getClassTargetFullName(cppClass) << '.' << en->name() << endl << endl; ++ writeFormattedText(s, en->documentation(), cppClass); ++ const auto version = versionOf(en->typeEntry()); ++ if (!version.isNull()) ++@@ -1775,7 +1775,7 @@ ++ ++ const AbstractMetaFieldList &fields = cppClass->fields(); ++ for (AbstractMetaField *field : fields) { ++- s << section_title << getClassTargetFullName(cppClass) << "." << field->name() << Qt::endl << Qt::endl; +++ s << section_title << getClassTargetFullName(cppClass) << "." << field->name() << endl << endl; ++ //TODO: request for member ‘documentation’ is ambiguous ++ writeFormattedText(s, field->AbstractMetaAttributes::documentation(), cppClass); ++ } ++@@ -1819,14 +1819,14 @@ ++ } ++ } ++ ++- s << Qt::endl; +++ s << endl; ++ ++ for (QHash::const_iterator it = arg_map.cbegin(), end = arg_map.cend(); it != end; ++it) { ++ Indentation indentation(INDENT, 2); ++ writeParameterType(s, cppClass, it.value()); ++ } ++ ++- s << Qt::endl; +++ s << endl; ++ ++ for (AbstractMetaFunction *func : qAsConst(lst)) ++ writeFormattedText(s, func->documentation(), cppClass); ++@@ -1917,7 +1917,7 @@ ++ if (row.trimmed().size() == 0) { ++ if (currentRow == 0) ++ continue; ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ if (currentRow == 0) { ++@@ -1931,7 +1931,7 @@ ++ break; ++ } ++ } ++- s << row.midRef(offset) << Qt::endl; +++ s << row.midRef(offset) << endl; ++ currentRow++; ++ } ++ ++@@ -1971,7 +1971,7 @@ ++ } ++ } ++ ++- s << Qt::endl; +++ s << endl; ++ ++ // TODO: Deprecate the use of doc string on glue code. ++ // This is pre "add-function" and "inject-documentation" tags. ++@@ -2046,13 +2046,13 @@ ++ void QtDocGenerator::writeParameterType(QTextStream& s, const AbstractMetaClass* cppClass, const AbstractMetaArgument* arg) ++ { ++ s << INDENT << ":param " << arg->name() << ": " ++- << translateToPythonType(arg->type(), cppClass) << Qt::endl; +++ << translateToPythonType(arg->type(), cppClass) << endl; ++ } ++ ++ void QtDocGenerator::writeFunctionParametersType(QTextStream &s, const AbstractMetaClass *cppClass, ++ const AbstractMetaFunction *func) ++ { ++- s << Qt::endl; +++ s << endl; ++ const AbstractMetaArgumentList &funcArgs = func->arguments(); ++ for (AbstractMetaArgument *arg : funcArgs) { ++ ++@@ -2078,9 +2078,9 @@ ++ ++ if (retType.isEmpty()) ++ retType = translateToPythonType(func->type(), cppClass); ++- s << INDENT << ":rtype: " << retType << Qt::endl; +++ s << INDENT << ":rtype: " << retType << endl; ++ } ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ void QtDocGenerator::writeFunction(QTextStream& s, const AbstractMetaClass* cppClass, ++@@ -2134,7 +2134,7 @@ ++ std::sort(it.value().begin(), it.value().end()); ++ ++ if (i) ++- ss << Qt::endl; +++ ss << endl; ++ ++ ss << "**" << it.key() << "**\n\n"; ++ i += 2; // a letter title is equivalent to two entries in space ++@@ -2184,11 +2184,11 @@ ++ FileOut output(outputDir + QLatin1String("/index.rst")); ++ QTextStream& s = output.stream; ++ ++- s << ".. module:: " << it.key() << Qt::endl << Qt::endl; +++ s << ".. module:: " << it.key() << endl << endl; ++ ++ const QString &title = it.key(); ++- s << title << Qt::endl; ++- s << Pad('*', title.length()) << Qt::endl << Qt::endl; +++ s << title << endl; +++ s << Pad('*', title.length()) << endl << endl; ++ ++ /* Avoid showing "Detailed Description for *every* class in toc tree */ ++ Indentation indentation(INDENT); ++@@ -2230,8 +2230,8 @@ ++ Indentation deeperIndentation(INDENT); ++ s << INDENT << ":maxdepth: 1\n\n"; ++ for (const QString &className : qAsConst(it.value())) ++- s << INDENT << className << Qt::endl; ++- s << Qt::endl << Qt::endl; +++ s << INDENT << className << endl; +++ s << endl << endl; ++ } ++ ++ s << "Detailed Description\n--------------------\n\n"; ++Index: pyside2/sources/shiboken2/generator/shiboken2/cppgenerator.cpp ++=================================================================== ++--- pyside2.orig/sources/shiboken2/generator/shiboken2/cppgenerator.cpp +++++ pyside2/sources/shiboken2/generator/shiboken2/cppgenerator.cpp ++@@ -297,7 +297,7 @@ ++ const AbstractMetaClass *metaClass = classContext.metaClass(); ++ ++ // write license comment ++- s << licenseComment() << Qt::endl; +++ s << licenseComment() << endl; ++ ++ if (!avoidProtectedHack() && !metaClass->isNamespace() && !metaClass->hasPrivateDestructor()) { ++ s << "//workaround to access protected functions\n"; ++@@ -339,7 +339,7 @@ ++ headerfile.replace(QLatin1String(".cpp"), QLatin1String(".h")); ++ s << "\n// main header\n" << "#include \"" << headerfile << "\"\n"; ++ ++- s << Qt::endl << "// inner classes\n"; +++ s << endl << "// inner classes\n"; ++ const AbstractMetaClassList &innerClasses = metaClass->innerClasses(); ++ for (AbstractMetaClass *innerClass : innerClasses) { ++ GeneratorContext innerClassContext = contextForClass(innerClass); ++@@ -361,8 +361,8 @@ ++ includes.append(cppEnum->typeEntry()->extraIncludes()); ++ std::sort(includes.begin(), includes.end()); ++ for (const Include &inc : qAsConst(includes)) ++- s << inc.toString() << Qt::endl; ++- s << Qt::endl; +++ s << inc.toString() << endl; +++ s << endl; ++ ++ s << "\n#include \n#include \n"; ++ ++@@ -381,7 +381,7 @@ ++ } ++ } ++ ++- s << Qt::endl << Qt::endl << typeNameFunc << Qt::endl; +++ s << endl << endl << typeNameFunc << endl; ++ ++ // Create string literal for smart pointer getter method. ++ if (classContext.forSmartPointer()) { ++@@ -397,13 +397,13 @@ ++ writeClassCodeSnips(s, metaClass->typeEntry()->codeSnips(), ++ TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode, ++ classContext); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ // python conversion rules ++ if (metaClass->typeEntry()->hasTargetConversionRule()) { ++ s << "// Python Conversion\n"; ++- s << metaClass->typeEntry()->conversionRule() << Qt::endl; +++ s << metaClass->typeEntry()->conversionRule() << endl; ++ } ++ ++ if (classContext.useWrapper()) { ++@@ -555,7 +555,7 @@ ++ ++ // Write methods definition ++ s << "static PyMethodDef " << className << "_methods[] = {\n"; ++- s << methodsDefinitions << Qt::endl; +++ s << methodsDefinitions << endl; ++ if (metaClass->typeEntry()->isValue() || metaClass->typeEntry()->isSmartPointer()) { ++ s << INDENT << "{\"__copy__\", reinterpret_cast(" << className << "___copy__)" ++ << ", METH_NOARGS},\n"; ++@@ -582,9 +582,9 @@ ++ writeCppSelfDefinition(s, classContext); ++ if (f->allowThread()) { ++ s << INDENT << "int result;\n"; ++- s << INDENT << BEGIN_ALLOW_THREADS << Qt::endl; +++ s << INDENT << BEGIN_ALLOW_THREADS << endl; ++ s << INDENT << "result = !" << CPP_SELF_VAR << "->isNull();\n"; ++- s << INDENT << END_ALLOW_THREADS << Qt::endl; +++ s << INDENT << END_ALLOW_THREADS << endl; ++ s << INDENT << "return result;\n"; ++ } else { ++ s << INDENT << "return !" << CPP_SELF_VAR << "->isNull();\n"; ++@@ -637,10 +637,10 @@ ++ writeGetterFunction(s, metaField, classContext); ++ if (canGenerateFieldSetter(metaField)) ++ writeSetterFunction(s, metaField, classContext); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++- s << "// Getters and Setters for " << metaClass->name() << Qt::endl; +++ s << "// Getters and Setters for " << metaClass->name() << endl; ++ s << "static PyGetSetDef " << cpythonGettersSettersDefinitionName(metaClass) << "[] = {\n"; ++ for (const AbstractMetaField *metaField : fields) { ++ if (metaField->isStatic()) ++@@ -668,7 +668,7 @@ ++ writeTpClearFunction(s, metaClass); ++ ++ writeClassDefinition(s, metaClass, classContext); ++- s << Qt::endl; +++ s << endl; ++ ++ if (metaClass->isPolymorphic() && metaClass->baseClass()) ++ writeTypeDiscoveryFunction(s, metaClass); ++@@ -682,10 +682,10 @@ ++ if (hasFlags) { ++ writeFlagsMethods(s, cppEnum); ++ writeFlagsNumberMethodsDefinition(s, cppEnum); ++- s << Qt::endl; +++ s << endl; ++ } ++ } ++- s << Qt::endl; +++ s << endl; ++ ++ writeConverterFunctions(s, metaClass, classContext); ++ writeClassRegister(s, metaClass, classContext, signatureStream); ++@@ -695,7 +695,7 @@ ++ writeClassCodeSnips(s, metaClass->typeEntry()->codeSnips(), ++ TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode, ++ classContext); ++- s << Qt::endl; +++ s << endl; ++ } ++ } ++ ++@@ -837,7 +837,7 @@ ++ errorMsg += func->signature(); ++ errorMsg = msgCouldNotFindMinimalConstructor(errorMsg, func->type()->cppSignature()); ++ qCWarning(lcShiboken).noquote().nospace() << errorMsg; ++- s << Qt::endl << INDENT << "#error " << errorMsg << Qt::endl; +++ s << endl << INDENT << "#error " << errorMsg << endl; ++ } ++ } else { ++ defaultReturnExpr.setType(DefaultValue::Void); ++@@ -848,7 +848,7 @@ ++ << QString::fromLatin1("Pure virtual method '%1::%2' must be implement but was "\ ++ "completely removed on type system.") ++ .arg(func->ownerClass()->name(), func->minimalSignature()); ++- s << INDENT << returnStatement(defaultReturnExpr.returnValue()) << Qt::endl; +++ s << INDENT << returnStatement(defaultReturnExpr.returnValue()) << endl; ++ s << "}\n\n"; ++ return; ++ } ++@@ -858,7 +858,7 @@ ++ CodeSnipList snips = func->injectedCodeSnips(); ++ const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast(); ++ writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionDeclaration, TypeSystem::NativeCode, func, lastArg); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ // PYSIDE-803: Build a boolean cache for unused overrides. ++@@ -898,7 +898,7 @@ ++ s << INDENT << "if (PyErr_Occurred())\n"; ++ { ++ Indentation indentation(INDENT); ++- s << INDENT << returnStatement(defaultReturnExpr.returnValue()) << Qt::endl; +++ s << INDENT << returnStatement(defaultReturnExpr.returnValue()) << endl; ++ } ++ ++ s << INDENT << "Shiboken::AutoDecRef " << PYTHON_OVERRIDE_VAR << "(Shiboken::BindingManager::instance().getOverride(this, \""; ++@@ -912,7 +912,7 @@ ++ snips = func->injectedCodeSnips(); ++ const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast(); ++ writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::ShellCode, func, lastArg); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ if (func->isAbstract()) { ++@@ -987,7 +987,7 @@ ++ } ++ ++ s << "Py_BuildValue(\"(" << getFormatUnitString(func, false) << ")\",\n"; ++- s << argConversions.join(QLatin1String(",\n")) << Qt::endl; +++ s << argConversions.join(QLatin1String(",\n")) << endl; ++ s << INDENT << "));\n"; ++ } ++ ++@@ -1005,7 +1005,7 @@ ++ } ++ } ++ } ++- s << Qt::endl; +++ s << endl; ++ ++ CodeSnipList snips; ++ if (func->hasInjectedCode()) { ++@@ -1016,7 +1016,7 @@ ++ ++ const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast(); ++ writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode, func, lastArg); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ if (!injectedCodeCallsPythonOverride(func)) { ++@@ -1029,7 +1029,7 @@ ++ { ++ Indentation indent(INDENT); ++ s << INDENT << "PyErr_Print();\n"; ++- s << INDENT << returnStatement(defaultReturnExpr.returnValue()) << Qt::endl; +++ s << INDENT << returnStatement(defaultReturnExpr.returnValue()) << endl; ++ } ++ s << INDENT << "}\n"; ++ ++@@ -1051,7 +1051,7 @@ ++ "\"Invalid return value in function %s, expected %s, got %s.\", \""; ++ s << func->ownerClass()->name() << '.' << funcName << "\", " << getVirtualFunctionReturnTypeName(func); ++ s << ", Py_TYPE(" << PYTHON_RETURN_VAR << ")->tp_name);\n"; ++- s << INDENT << returnStatement(defaultReturnExpr.returnValue()) << Qt::endl; +++ s << INDENT << returnStatement(defaultReturnExpr.returnValue()) << endl; ++ } ++ s << INDENT << "}\n"; ++ ++@@ -1072,7 +1072,7 @@ ++ "\"Invalid return value in function %s, expected %s, got %s.\", \""; ++ s << func->ownerClass()->name() << '.' << funcName << "\", " << getVirtualFunctionReturnTypeName(func); ++ s << ", Py_TYPE(" << PYTHON_RETURN_VAR << ")->tp_name);\n"; ++- s << INDENT << returnStatement(defaultReturnExpr.returnValue()) << Qt::endl; +++ s << INDENT << returnStatement(defaultReturnExpr.returnValue()) << endl; ++ } ++ s << INDENT << "}\n"; ++ ++@@ -1115,7 +1115,7 @@ ++ } ++ ++ if (func->hasInjectedCode()) { ++- s << Qt::endl; +++ s << endl; ++ const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast(); ++ writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode, func, lastArg); ++ } ++@@ -1243,7 +1243,7 @@ ++ } ++ c << ";\n"; ++ writeCppToPythonFunction(s, code, typeName, typeName); ++- s << Qt::endl; +++ s << endl; ++ ++ if (enumType->isFlags()) ++ return; ++@@ -1323,7 +1323,7 @@ ++ const QString pyTypeCheck = QLatin1String("PyObject_TypeCheck(pyIn, reinterpret_cast(") ++ + cpythonType + QLatin1String("))"); ++ writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, pyTypeCheck, QString(), true); ++- s << Qt::endl; +++ s << endl; ++ ++ // C++ pointer to a Python wrapper, keeping identity. ++ s << "// C++ to Python pointer conversion - tries to find the Python wrapper for the C++ object (keeps object identity).\n"; ++@@ -1360,12 +1360,12 @@ ++ ++ // The conversions for an Object Type end here. ++ if (!metaClass->typeEntry()->isValue() && !metaClass->typeEntry()->isSmartPointer()) { ++- s << Qt::endl; +++ s << endl; ++ return; ++ } ++ ++ // Always copies C++ value (not pointer, and not reference) to a new Python wrapper. ++- s << Qt::endl << "// C++ to Python copy conversion.\n"; +++ s << endl << "// C++ to Python copy conversion.\n"; ++ if (!classContext.forSmartPointer()) ++ targetTypeName = metaClass->name(); ++ else ++@@ -1387,7 +1387,7 @@ ++ << ", new ::" << computedWrapperName << "(*reinterpret_cast(cppIn)), true, true);"; ++ writeCppToPythonFunction(s, code, sourceTypeName, targetTypeName); ++- s << Qt::endl; +++ s << endl; ++ ++ // Python to C++ copy conversion. ++ s << "// Python to C++ copy conversion.\n"; ++@@ -1412,7 +1412,7 @@ ++ ++ // "Is convertible" function for the Python object to C++ value copy conversion. ++ writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, pyTypeCheck); ++- s << Qt::endl; +++ s << endl; ++ ++ // User provided implicit conversions. ++ CustomConversion *customConversion = metaClass->typeEntry()->customConversion(); ++@@ -1507,7 +1507,7 @@ ++ s << "// Python to C++ conversions for type '" << customConversion->ownerType()->qualifiedCppName() << "'.\n"; ++ for (CustomConversion::TargetToNativeConversion *toNative : toCppConversions) ++ writePythonToCppConversionFunctions(s, toNative, customConversion->ownerType()); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClass *metaClass, ++@@ -1517,32 +1517,32 @@ ++ return; ++ s << INDENT << "// Register Converter\n"; ++ s << INDENT << "SbkConverter *converter = Shiboken::Conversions::createConverter("; ++- s << cpythonTypeName(metaClass) << ',' << Qt::endl; +++ s << cpythonTypeName(metaClass) << ',' << endl; ++ { ++ Indentation indent(INDENT); ++ QString sourceTypeName = metaClass->name(); ++ QString targetTypeName = sourceTypeName + QLatin1String("_PTR"); ++- s << INDENT << pythonToCppFunctionName(sourceTypeName, targetTypeName) << ',' << Qt::endl; ++- s << INDENT << convertibleToCppFunctionName(sourceTypeName, targetTypeName) << ',' << Qt::endl; +++ s << INDENT << pythonToCppFunctionName(sourceTypeName, targetTypeName) << ',' << endl; +++ s << INDENT << convertibleToCppFunctionName(sourceTypeName, targetTypeName) << ',' << endl; ++ std::swap(targetTypeName, sourceTypeName); ++ s << INDENT << cppToPythonFunctionName(sourceTypeName, targetTypeName); ++ if (metaClass->typeEntry()->isValue() || metaClass->typeEntry()->isSmartPointer()) { ++- s << ',' << Qt::endl; +++ s << ',' << endl; ++ sourceTypeName = metaClass->name() + QLatin1String("_COPY"); ++ s << INDENT << cppToPythonFunctionName(sourceTypeName, targetTypeName); ++ } ++ } ++ s << ");\n"; ++ ++- s << Qt::endl; +++ s << endl; ++ ++ QStringList cppSignature; ++ if (!classContext.forSmartPointer()) { ++ cppSignature = metaClass->qualifiedCppName().split(QLatin1String("::"), ++- Qt::SkipEmptyParts); +++ QString::SkipEmptyParts); ++ } else { ++ cppSignature = classContext.preciseType()->cppSignature().split(QLatin1String("::"), ++- Qt::SkipEmptyParts); +++ QString::SkipEmptyParts); ++ } ++ while (!cppSignature.isEmpty()) { ++ QString signature = cppSignature.join(QLatin1String("::")); ++@@ -1566,7 +1566,7 @@ ++ s << classContext.wrapperName() << ").name());\n"; ++ } ++ ++- s << Qt::endl; +++ s << endl; ++ ++ if (!metaClass->typeEntry()->isValue() && !metaClass->typeEntry()->isSmartPointer()) ++ return; ++@@ -1662,7 +1662,7 @@ ++ ++ s << qualifiedCppName << " >()))\n"; ++ Indentation indent(INDENT); ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl << endl; ++ } ++ // Declare pointer for the underlying C++ object. ++ s << INDENT << "::"; ++@@ -1766,7 +1766,7 @@ ++ s << INDENT << "\"'" << metaClass->qualifiedCppName(); ++ } ++ s << "' represents a C++ abstract class and cannot be instantiated\");\n"; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ s << INDENT<< "}\n\n"; ++ } ++@@ -1785,24 +1785,24 @@ ++ ++ writeMethodWrapperPreamble(s, overloadData, classContext); ++ ++- s << Qt::endl; +++ s << endl; ++ ++ if (overloadData.maxArgs() > 0) ++ writeOverloadedFunctionDecisor(s, overloadData); ++ ++ writeFunctionCalls(s, overloadData, classContext); ++- s << Qt::endl; +++ s << endl; ++ ++ s << INDENT << "if (PyErr_Occurred() || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< ::" << metaClass->qualifiedCppName() << " >(), cptr)) {\n"; ++ { ++ Indentation indent(INDENT); ++ s << INDENT << "delete cptr;\n"; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ s << INDENT << "}\n"; ++ if (overloadData.maxArgs() > 0) { ++ s << INDENT << "if (!cptr) goto " << cpythonFunctionName(rfunc) << "_TypeError;\n"; ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ s << INDENT << "Shiboken::Object::setValidCpp(sbkSelf, true);\n"; ++@@ -1824,13 +1824,13 @@ ++ ++ // Create metaObject and register signal/slot ++ if (metaClass->isQObject() && usePySideExtensions()) { ++- s << Qt::endl << INDENT << "// QObject setup\n"; +++ s << endl << INDENT << "// QObject setup\n"; ++ s << INDENT << "PySide::Signal::updateSourceObject(self);\n"; ++ s << INDENT << "metaObject = cptr->metaObject(); // <- init python qt properties\n"; ++ s << INDENT << "if (kwds && !PySide::fillQtProperties(self, metaObject, kwds, argNames, " << argNamesSet.count() << "))\n"; ++ { ++ Indentation indentation(INDENT); ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ } ++ ++@@ -1853,7 +1853,7 @@ ++ const CodeSnipList &injectedCodeSnips = func->injectedCodeSnips(); ++ for (const CodeSnip &cs : injectedCodeSnips) { ++ if (cs.position == TypeSystem::CodeSnipPositionEnd) { ++- s << INDENT << "case " << metaClass->functions().indexOf(func) << ':' << Qt::endl; +++ s << INDENT << "case " << metaClass->functions().indexOf(func) << ':' << endl; ++ s << INDENT << "{\n"; ++ { ++ Indentation indent(INDENT); ++@@ -1867,8 +1867,8 @@ ++ s << "}\n"; ++ } ++ ++- s << Qt::endl; ++- s << Qt::endl << INDENT << "return 1;\n"; +++ s << endl; +++ s << endl << INDENT << "return 1;\n"; ++ if (overloadData.maxArgs() > 0) ++ writeErrorSection(s, overloadData); ++ s<< "}\n\n"; ++@@ -1893,7 +1893,7 @@ ++ ++ writeMethodWrapperPreamble(s, overloadData, classContext); ++ ++- s << Qt::endl; +++ s << endl; ++ ++ /* ++ * This code is intended for shift operations only: ++@@ -1956,9 +1956,9 @@ ++ writeFunctionCalls(s, overloadData, classContext); ++ ++ if (callExtendedReverseOperator) ++- s << Qt::endl << INDENT << "} // End of \"if (!" << PYTHON_RETURN_VAR << ")\"\n"; +++ s << endl << INDENT << "} // End of \"if (!" << PYTHON_RETURN_VAR << ")\"\n"; ++ ++- s << Qt::endl; +++ s << endl; ++ ++ writeFunctionReturnErrorCheckSection(s, hasReturnValue && !rfunc->isInplaceOperator()); ++ ++@@ -1990,9 +1990,9 @@ ++ ++ s << INDENT << "PyObject *"; ++ s << PYTHON_ARGS << "[] = {" ++- << QString(maxArgs, QLatin1Char('0')).split(QLatin1String(""), Qt::SkipEmptyParts).join(QLatin1String(", ")) +++ << QString(maxArgs, QLatin1Char('0')).split(QLatin1String(""), QString::SkipEmptyParts).join(QLatin1String(", ")) ++ << "};\n"; ++- s << Qt::endl; +++ s << endl; ++ ++ if (overloadData.hasVarargs()) { ++ maxArgs--; ++@@ -2003,7 +2003,7 @@ ++ s << INDENT << "Shiboken::AutoDecRef auto_nonvarargs(nonvarargs);\n"; ++ s << INDENT << PYTHON_ARGS << '[' << maxArgs << "] = PyTuple_GetSlice(args, " << maxArgs << ", numArgs);\n"; ++ s << INDENT << "Shiboken::AutoDecRef auto_varargs(" << PYTHON_ARGS << "[" << maxArgs << "]);\n"; ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ bool usesNamedArguments = overloadData.hasArgumentWithDefaultValue(); ++@@ -2016,7 +2016,7 @@ ++ { ++ Indentation indent(INDENT); ++ s << INDENT << "PyErr_SetString(PyExc_TypeError, \"" << fullPythonFunctionName(rfunc) << "(): too many arguments\");\n"; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ s << INDENT << '}'; ++ } ++@@ -2029,7 +2029,7 @@ ++ { ++ Indentation indent(INDENT); ++ s << INDENT << "PyErr_SetString(PyExc_TypeError, \"" << fullPythonFunctionName(rfunc) << "(): not enough arguments\");\n"; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ s << INDENT << '}'; ++ } ++@@ -2047,7 +2047,7 @@ ++ Indentation indent(INDENT); ++ s << INDENT << "goto " << cpythonFunctionName(rfunc) << "_TypeError;"; ++ } ++- s << Qt::endl << Qt::endl; +++ s << endl << endl; ++ ++ QString funcName; ++ if (rfunc->isOperatorOverload()) ++@@ -2066,9 +2066,9 @@ ++ s << "))\n"; ++ { ++ Indentation indent(INDENT); ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ void CppGenerator::writeCppSelfConversion(QTextStream &s, const GeneratorContext &context, ++@@ -2160,7 +2160,7 @@ ++ void CppGenerator::writeErrorSection(QTextStream &s, OverloadData &overloadData) ++ { ++ const AbstractMetaFunction *rfunc = overloadData.referenceFunction(); ++- s << Qt::endl << INDENT << cpythonFunctionName(rfunc) << "_TypeError:\n"; +++ s << endl << INDENT << cpythonFunctionName(rfunc) << "_TypeError:\n"; ++ Indentation indentation(INDENT); ++ QString funcName = fullPythonFunctionName(rfunc); ++ ++@@ -2180,7 +2180,7 @@ ++ Indentation indent(INDENT); ++ if (hasReturnValue) ++ s << INDENT << "Py_XDECREF(" << PYTHON_RETURN_VAR << ");\n"; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ s << INDENT << "}\n"; ++ } ++@@ -2189,7 +2189,7 @@ ++ { ++ s << INDENT << "if (!Shiboken::Object::isValid(" << pyObj << "))\n"; ++ Indentation indent(INDENT); ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ ++ static QString pythonToCppConverterForArgumentName(const QString &argumentName) ++@@ -2455,7 +2455,7 @@ ++ ++ if (!defaultValue.isEmpty()) ++ s << INDENT << '}'; ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ static void addConversionRuleCodeSnippet(CodeSnipList &snippetList, QString &rule, ++@@ -2518,10 +2518,10 @@ ++ s << "static "; ++ if (const auto *decl = func->declaringClass()) ++ s << decl->name() << "::"; ++- s << func->minimalSignature() << Qt::endl; +++ s << func->minimalSignature() << endl; ++ } ++ writeOverloadedFunctionDecisorEngine(s, &overloadData); ++- s << Qt::endl; +++ s << endl; ++ ++ // Ensure that the direct overload that called this reverse ++ // is called. ++@@ -2537,7 +2537,7 @@ ++ ++ s << INDENT << "// Function signature not found.\n"; ++ s << INDENT << "if (overloadId == -1) goto " << cpythonFunctionName(overloadData.referenceFunction()) << "_TypeError;\n"; ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream &s, const OverloadData *parentOverloadData) ++@@ -2568,7 +2568,7 @@ ++ // Functions without arguments are identified right away. ++ if (maxArgs == 0) { ++ s << INDENT << "overloadId = " << parentOverloadData->headOverloadData()->overloads().indexOf(referenceFunction); ++- s << "; // " << referenceFunction->minimalSignature() << Qt::endl; +++ s << "; // " << referenceFunction->minimalSignature() << endl; ++ return; ++ ++ } ++@@ -2584,7 +2584,7 @@ ++ if (isLastArgument || (signatureFound && !hasDefaultCall)) { ++ const AbstractMetaFunction *func = parentOverloadData->referenceFunction(); ++ s << INDENT << "overloadId = " << parentOverloadData->headOverloadData()->overloads().indexOf(func); ++- s << "; // " << func->minimalSignature() << Qt::endl; +++ s << "; // " << func->minimalSignature() << endl; ++ return; ++ } ++ } ++@@ -2610,7 +2610,7 @@ ++ } ++ } ++ s << INDENT << "overloadId = " << parentOverloadData->headOverloadData()->overloads().indexOf(func); ++- s << "; // " << func->minimalSignature() << Qt::endl; +++ s << "; // " << func->minimalSignature() << endl; ++ } ++ s << INDENT << '}'; ++ } ++@@ -2691,7 +2691,7 @@ ++ Indentation indent(INDENT); ++ QString separator; ++ QTextStream sep(&separator); ++- sep << Qt::endl << INDENT << "&& "; +++ sep << endl << INDENT << "&& "; ++ s << typeChecks.join(separator); ++ } ++ s << ") {\n"; ++@@ -2701,7 +2701,7 @@ ++ } ++ s << INDENT << "}"; ++ } ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ void CppGenerator::writeFunctionCalls(QTextStream &s, const OverloadData &overloadData, ++@@ -2717,7 +2717,7 @@ ++ } else { ++ for (int i = 0; i < overloads.count(); i++) { ++ const AbstractMetaFunction *func = overloads.at(i); ++- s << INDENT << "case " << i << ": // " << func->signature() << Qt::endl; +++ s << INDENT << "case " << i << ": // " << func->signature() << endl; ++ s << INDENT << "{\n"; ++ { ++ Indentation indent(INDENT); ++@@ -2752,7 +2752,7 @@ ++ s << INDENT << "PyErr_Format(PyExc_TypeError, \"%s is a private method.\", \"" ++ << func->signature().replace(QLatin1String("::"), QLatin1String(".")) ++ << "\");\n"; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ return; ++ } ++ ++@@ -2795,7 +2795,7 @@ ++ writeArgumentConversion(s, argType, argName, pyArgName, func->implementingClass(), defaultValue, func->isUserAdded()); ++ } ++ ++- s << Qt::endl; +++ s << endl; ++ ++ int numRemovedArgs = OverloadData::numberOfRemovedArguments(func); ++ ++@@ -2950,7 +2950,7 @@ ++ if (conversion.isEmpty()) ++ conversion = QLatin1Char('*') + cpythonWrapperCPtr(sourceType->typeEntry(), QLatin1String("pyIn")); ++ if (!preConversion.isEmpty()) ++- c << INDENT << preConversion << Qt::endl; +++ c << INDENT << preConversion << endl; ++ const QString fullTypeName = getFullTypeName(targetType->typeEntry()); ++ c << INDENT << "*reinterpret_cast<" << fullTypeName << " *>(cppOut) = " ++ << fullTypeName << '(' << conversion << ");"; ++@@ -2962,7 +2962,7 @@ ++ if (typeCheck.isEmpty()) ++ typeCheck = QString::fromLatin1("PyObject_TypeCheck(pyIn, %1)").arg(sourcePyType); ++ writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, typeCheck); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ void CppGenerator::writePythonToCppConversionFunctions(QTextStream &s, ++@@ -3070,15 +3070,15 @@ ++ else ++ typeCheck = QString::fromLatin1("%1pyIn)").arg(typeCheck); ++ writeIsPythonConvertibleToCppFunction(s, typeName, typeName, typeCheck); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ void CppGenerator::writeAddPythonToCppConversion(QTextStream &s, const QString &converterVar, const QString &pythonToCppFunc, const QString &isConvertibleFunc) ++ { ++- s << INDENT << "Shiboken::Conversions::addPythonToCppValueConversion(" << converterVar << ',' << Qt::endl; +++ s << INDENT << "Shiboken::Conversions::addPythonToCppValueConversion(" << converterVar << ',' << endl; ++ { ++ Indentation indent(INDENT); ++- s << INDENT << pythonToCppFunc << ',' << Qt::endl; +++ s << INDENT << pythonToCppFunc << ',' << endl; ++ s << INDENT << isConvertibleFunc; ++ } ++ s << ");\n"; ++@@ -3109,8 +3109,8 @@ ++ s << INDENT << "if (value && " << pyArgName << ") {\n"; ++ { ++ Indentation indent(INDENT); ++- s << INDENT << pyErrString.arg(arg->name()) << Qt::endl; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << pyErrString.arg(arg->name()) << endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ s << INDENT << "}\n"; ++ s << INDENT << "if (value) {\n"; ++@@ -3185,7 +3185,7 @@ ++ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *func, ++ const GeneratorContext &context, int maxArgs) ++ { ++- s << INDENT << "// " << func->minimalSignature() << (func->isReverseOperator() ? " [reverse operator]": "") << Qt::endl; +++ s << INDENT << "// " << func->minimalSignature() << (func->isReverseOperator() ? " [reverse operator]": "") << endl; ++ if (func->isConstructor()) { ++ const CodeSnipList &snips = func->injectedCodeSnips(); ++ for (const CodeSnip &cs : snips) { ++@@ -3205,7 +3205,7 @@ ++ Indentation indent(INDENT); ++ s << INDENT << "PyErr_SetString(PyExc_NotImplementedError, \"pure virtual method '"; ++ s << func->ownerClass()->name() << '.' << func->name() << "()' not implemented.\");\n"; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ s << INDENT << "}\n"; ++ } ++@@ -3232,7 +3232,7 @@ ++ } ++ ++ writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::TargetLangCode, func, lastArg); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ writeConversionRule(s, func, TypeSystem::NativeCode); ++@@ -3324,7 +3324,7 @@ ++ std::swap(firstArg, secondArg); ++ ++ if (((op == QLatin1String("++")) || (op == QLatin1String("--"))) && !func->isReverseOperator()) { ++- s << Qt::endl << INDENT << "for (int i=0; i < " << secondArg << "; i++, " << firstArg << op << ");\n"; +++ s << endl << INDENT << "for (int i=0; i < " << secondArg << "; i++, " << firstArg << op << ");\n"; ++ mc << firstArg; ++ } else { ++ mc << firstArg << ' ' << op << ' ' << secondArg; ++@@ -3354,7 +3354,7 @@ ++ << ctorCall << ";\n" ++ << INDENT ++ << "PySide::setNextQObjectMemoryAddr(0);" ++- << Qt::endl; +++ << endl; ++ } ++ uva << INDENT << "} else {\n"; ++ { ++@@ -3458,12 +3458,12 @@ ++ << INDENT << "threadSaver.save();\n"; ++ } ++ } else if (allowThread) { ++- s << INDENT << BEGIN_ALLOW_THREADS << Qt::endl; +++ s << INDENT << BEGIN_ALLOW_THREADS << endl; ++ } ++ s << INDENT; ++ if (isCtor) { ++ s << (useVAddr.isEmpty() ? ++- QString::fromLatin1("cptr = %1;").arg(methodCall) : useVAddr) << Qt::endl; +++ QString::fromLatin1("cptr = %1;").arg(methodCall) : useVAddr) << endl; ++ } else if (func->type() && !func->isInplaceOperator()) { ++ bool writeReturnType = true; ++ if (avoidProtectedHack()) { ++@@ -3524,7 +3524,7 @@ ++ } ++ ++ if (func->hasInjectedCode() && !func->isConstructor()) { ++- s << Qt::endl; +++ s << endl; ++ writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::TargetLangCode, func, lastArg); ++ } ++ ++@@ -3549,12 +3549,12 @@ ++ hasReturnPolicy = true; ++ ++ if (!ownership_mods.isEmpty()) { ++- s << Qt::endl << INDENT << "// Ownership transferences.\n"; +++ s << endl << INDENT << "// Ownership transferences.\n"; ++ for (const ArgumentModification &arg_mod : qAsConst(ownership_mods)) { ++ const AbstractMetaClass *wrappedClass = nullptr; ++ QString pyArgName = argumentNameFromIndex(func, arg_mod.index, &wrappedClass); ++ if (!wrappedClass) { ++- s << "#error Invalid ownership modification for argument " << arg_mod.index << '(' << pyArgName << ")\n" << Qt::endl; +++ s << "#error Invalid ownership modification for argument " << arg_mod.index << '(' << pyArgName << ")\n" << endl; ++ break; ++ } ++ ++@@ -3577,7 +3577,7 @@ ++ } else { ++ s << "invalidate(" << pyArgName << ");"; ++ } ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ } else if (!refcount_mods.isEmpty()) { ++@@ -3597,7 +3597,7 @@ ++ } else { ++ pyArgName = argumentNameFromIndex(func, arg_mod.index, &wrappedClass); ++ if (pyArgName.isEmpty()) { ++- s << "#error Invalid reference count modification for argument " << arg_mod.index << Qt::endl << Qt::endl; +++ s << "#error Invalid reference count modification for argument " << arg_mod.index << endl << endl; ++ break; ++ } ++ } ++@@ -3668,9 +3668,9 @@ ++ for (const QString &ancestor : ancestors) ++ s << INDENT << "offsets.insert(int(" << ancestor << "));\n"; ++ ++- s << Qt::endl; +++ s << endl; ++ s << INDENT << "offsets.erase(0);\n"; ++- s << Qt::endl; +++ s << endl; ++ ++ s << INDENT << "std::copy(offsets.cbegin(), offsets.cend(), mi_offsets);\n"; ++ } ++@@ -3738,7 +3738,7 @@ ++ { ++ Indentation indent(INDENT); ++ QString typeName = fixedCppTypeName(enumType); ++- s << INDENT << "SbkConverter *converter = Shiboken::Conversions::createConverter(" << enumPythonType << ',' << Qt::endl; +++ s << INDENT << "SbkConverter *converter = Shiboken::Conversions::createConverter(" << enumPythonType << ',' << endl; ++ { ++ Indentation indent(INDENT); ++ s << INDENT << cppToPythonFunctionName(typeName, typeName) << ");\n"; ++@@ -3823,7 +3823,7 @@ ++ void CppGenerator::writeExtendedConverterInitialization(QTextStream &s, const TypeEntry *externalType, ++ const QVector& conversions) ++ { ++- s << INDENT << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << Qt::endl; +++ s << INDENT << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl; ++ for (const AbstractMetaClass *sourceClass : conversions) { ++ const QString converterVar = QLatin1String("reinterpret_cast(") ++ + cppApiVariableName(externalType->targetLangPackage()) + QLatin1Char('[') ++@@ -4008,7 +4008,7 @@ ++ if (metaClass == miClass) ++ writeMultipleInheritanceInitializerFunction(s, metaClass); ++ writeSpecialCastFunction(s, metaClass); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ s << "// Class Definition -----------------------------------------------\n"; ++@@ -4037,7 +4037,7 @@ ++ s << "{\n"; ++ s << INDENT << "return " << typePtr << ";\n"; ++ s << "}\n"; ++- s << Qt::endl; +++ s << endl; ++ s << "static PyType_Slot " << className << "_slots[] = {\n"; ++ s << INDENT << "{Py_tp_base, nullptr}, // inserted by introduceWrapperType\n"; ++ s << INDENT << pyTypeSlotEntry("Py_tp_dealloc", tp_dealloc) ++@@ -4080,8 +4080,8 @@ ++ s << INDENT << tp_flags << ",\n"; ++ s << INDENT << className << "_slots\n"; ++ s << "};\n"; ++- s << Qt::endl; ++- s << "} //extern \"C\"" << Qt::endl; +++ s << endl; +++ s << "} //extern \"C\"" << endl; ++ } ++ ++ void CppGenerator::writeMappingMethods(QTextStream &s, ++@@ -4314,7 +4314,7 @@ ++ writeFunctionReturnErrorCheckSection(s); ++ s << INDENT << "return " << PYTHON_RETURN_VAR << ";\n"; ++ s << "}\n"; ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ void CppGenerator::writeGetterFunction(QTextStream &s, ++@@ -4453,7 +4453,7 @@ ++ s << cppField << ";\n"; ++ s << INDENT << PYTHON_TO_CPP_VAR << "(pyIn, &cppOut_ptr)"; ++ } ++- s << ";\n" << Qt::endl; +++ s << ";\n" << endl; ++ ++ if (isPointerToWrapperType(fieldType)) { ++ s << INDENT << "Shiboken::Object::keepReference(reinterpret_cast(self), \""; ++@@ -4476,7 +4476,7 @@ ++ s << INDENT << "PyObject *" << PYTHON_RETURN_VAR << "{};\n"; ++ s << INDENT << "PythonToCppFunc " << PYTHON_TO_CPP_VAR << ";\n"; ++ writeUnusedVariableCast(s, QLatin1String(PYTHON_TO_CPP_VAR)); ++- s << Qt::endl; +++ s << endl; ++ ++ s << INDENT << "switch (op) {\n"; ++ { ++@@ -4486,7 +4486,7 @@ ++ const AbstractMetaFunction *rfunc = overloads[0]; ++ ++ QString operatorId = ShibokenGenerator::pythonRichCompareOperatorId(rfunc); ++- s << INDENT << "case " << operatorId << ':' << Qt::endl; +++ s << INDENT << "case " << operatorId << ':' << endl; ++ ++ Indentation indent(INDENT); ++ ++@@ -4521,7 +4521,7 @@ ++ s << ") {\n"; ++ { ++ Indentation indent(INDENT); ++- s << INDENT << "// " << func->signature() << Qt::endl; +++ s << INDENT << "// " << func->signature() << endl; ++ writeArgumentConversion(s, argType, QLatin1String(CPP_ARG0), ++ QLatin1String(PYTHON_ARG), metaClass, ++ QString(), func->isUserAdded()); ++@@ -4581,7 +4581,7 @@ ++ } ++ s << INDENT << baseName << "_RichComparison_TypeError:\n"; ++ s << INDENT << "PyErr_SetString(PyExc_NotImplementedError, \"operator not implemented.\");\n"; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl << endl; ++ s<< "}\n\n"; ++ } ++ ++@@ -4625,7 +4625,7 @@ ++ writeMethodDefinitionEntry(s, overloads); ++ s << '}'; ++ } ++- s << ',' << Qt::endl; +++ s << ',' << endl; ++ } ++ ++ void CppGenerator::writeSignatureInfo(QTextStream &s, const AbstractMetaFunctionList &overloads) ++@@ -4656,7 +4656,7 @@ ++ s << funcName << '(' << args.join(QLatin1Char(',')) << ')'; ++ if (f->type()) ++ s << "->" << f->type()->pythonSignature(); ++- s << Qt::endl; +++ s << endl; ++ } ++ } ++ ++@@ -4716,7 +4716,7 @@ ++ ++ s << INDENT << enumVarTypeObj << " = Shiboken::Enum::"; ++ s << ((enclosingClass || hasUpperEnclosingClass) ? "createScopedEnum" : "createGlobalEnum"); ++- s << '(' << enclosingObjectVariable << ',' << Qt::endl; +++ s << '(' << enclosingObjectVariable << ',' << endl; ++ { ++ Indentation indent(INDENT); ++ s << INDENT << '"' << cppEnum->name() << "\",\n"; ++@@ -4724,13 +4724,13 @@ ++ s << INDENT << '"' << (cppEnum->enclosingClass() ? (cppEnum->enclosingClass()->qualifiedCppName() + QLatin1String("::")) : QString()); ++ s << cppEnum->name() << '"'; ++ if (flags) ++- s << ',' << Qt::endl << INDENT << cpythonTypeNameExt(flags); +++ s << ',' << endl << INDENT << cpythonTypeNameExt(flags); ++ s << ");\n"; ++ } ++ s << INDENT << "if (!" << cpythonTypeNameExt(cppEnum->typeEntry()) << ")\n"; ++ { ++ Indentation indent(INDENT); ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl << endl; ++ } ++ } ++ ++@@ -4763,7 +4763,7 @@ ++ << "))->tp_dict, \"" << mangleName(enumValue->name()) << "\", anonEnumItem) < 0)\n"; ++ { ++ Indentation indent(INDENT); ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ s << INDENT << "Py_DECREF(anonEnumItem);\n"; ++ } ++@@ -4773,27 +4773,27 @@ ++ s << enumValueText << ") < 0)\n"; ++ { ++ Indentation indent(INDENT); ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ } ++ break; ++ case CEnum: { ++ s << INDENT << "if (!Shiboken::Enum::"; ++ s << ((enclosingClass || hasUpperEnclosingClass) ? "createScopedEnumItem" : "createGlobalEnumItem"); ++- s << '(' << enumVarTypeObj << ',' << Qt::endl; +++ s << '(' << enumVarTypeObj << ',' << endl; ++ Indentation indent(INDENT); ++ s << INDENT << enclosingObjectVariable << ", \"" << mangleName(enumValue->name()) << "\", "; ++ s << enumValueText << "))\n"; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ break; ++ case EnumClass: { ++ s << INDENT << "if (!Shiboken::Enum::createScopedEnumItem(" ++- << enumVarTypeObj << ',' << Qt::endl; +++ << enumVarTypeObj << ',' << endl; ++ Indentation indent(INDENT); ++ s << INDENT << enumVarTypeObj<< ", \"" << mangleName(enumValue->name()) << "\", " ++ << enumValueText << "))\n" ++- << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ break; ++ } ++@@ -4804,7 +4804,7 @@ ++ s << INDENT << "// End of '" << cppEnum->name() << "' enum"; ++ if (cppEnum->typeEntry()->flags()) ++ s << "/flags"; ++- s << '.' << Qt::endl << Qt::endl; +++ s << '.' << endl << endl; ++ } ++ ++ void CppGenerator::writeSignalInitialization(QTextStream &s, const AbstractMetaClass *metaClass) ++@@ -4872,7 +4872,7 @@ ++ writeFlagsToLong(s, cppEnum); ++ writeFlagsNonZero(s, cppEnum); ++ ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream &s, const AbstractMetaEnum *cppEnum) ++@@ -5011,7 +5011,7 @@ ++ const AbstractMetaClassList baseClasses = getBaseClasses(metaClass); ++ if (metaClass->baseClassNames().size() > 1) { ++ s << INDENT << "PyObject *" << pyTypeBasesVariable ++- << " = PyTuple_Pack(" << baseClasses.size() << ',' << Qt::endl; +++ << " = PyTuple_Pack(" << baseClasses.size() << ',' << endl; ++ Indentation indent(INDENT); ++ for (int i = 0, size = baseClasses.size(); i < size; ++i) { ++ if (i) ++@@ -5085,7 +5085,7 @@ ++ ++ // 8:baseTypes ++ if (metaClass->baseClassNames().size() > 1) ++- s << INDENT << pyTypeBasesVariable << ',' << Qt::endl; +++ s << INDENT << pyTypeBasesVariable << ',' << endl; ++ else ++ s << INDENT << "0,\n"; ++ ++@@ -5101,25 +5101,25 @@ ++ s << INDENT << wrapperFlags.join(" | "); ++ } ++ s << INDENT << ");\n"; ++- s << INDENT << Qt::endl; +++ s << INDENT << endl; ++ ++ if (!classContext.forSmartPointer()) ++- s << INDENT << cpythonTypeNameExt(classTypeEntry) << Qt::endl; +++ s << INDENT << cpythonTypeNameExt(classTypeEntry) << endl; ++ else ++- s << INDENT << cpythonTypeNameExt(classContext.preciseType()) << Qt::endl; +++ s << INDENT << cpythonTypeNameExt(classContext.preciseType()) << endl; ++ s << INDENT << " = reinterpret_cast(" << pyTypeName << ");\n"; ++- s << Qt::endl; +++ s << endl; ++ ++ // Register conversions for the type. ++ writeConverterRegister(s, metaClass, classContext); ++- s << Qt::endl; +++ s << endl; ++ ++ // class inject-code target/beginning ++ if (!classTypeEntry->codeSnips().isEmpty()) { ++ writeClassCodeSnips(s, classTypeEntry->codeSnips(), ++ TypeSystem::CodeSnipPositionBeginning, TypeSystem::TargetLangCode, ++ classContext); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ // Fill multiple inheritance data, if needed. ++@@ -5165,11 +5165,11 @@ ++ writeToPythonConversion(s, field->type(), metaClass, metaClass->qualifiedCppName() + QLatin1String("::") + field->name()); ++ s << ");\n"; ++ } ++- s << Qt::endl; +++ s << endl; ++ ++ // class inject-code target/end ++ if (!classTypeEntry->codeSnips().isEmpty()) { ++- s << Qt::endl; +++ s << endl; ++ writeClassCodeSnips(s, classTypeEntry->codeSnips(), ++ TypeSystem::CodeSnipPositionEnd, TypeSystem::TargetLangCode, ++ classContext); ++@@ -5628,7 +5628,7 @@ ++ QTextStream &s = file.stream; ++ ++ // write license comment ++- s << licenseComment() << Qt::endl; +++ s << licenseComment() << endl; ++ ++ s << "#include \n"; ++ s << "#include \n"; ++@@ -5640,10 +5640,10 @@ ++ s << "#include \n"; ++ } ++ ++- s << "#include \"" << getModuleHeaderFileName() << '"' << Qt::endl << Qt::endl; +++ s << "#include \"" << getModuleHeaderFileName() << '"' << endl << endl; ++ for (const Include &include : qAsConst(includes)) ++ s << include; ++- s << Qt::endl; +++ s << endl; ++ ++ // Global enums ++ AbstractMetaEnumList globalEnums = this->globalEnums(); ++@@ -5659,14 +5659,14 @@ ++ Q_ASSERT(moduleEntry); ++ ++ //Extra includes ++- s << Qt::endl << "// Extra includes\n"; +++ s << endl << "// Extra includes\n"; ++ QVector extraIncludes = moduleEntry->extraIncludes(); ++ for (AbstractMetaEnum *cppEnum : qAsConst(globalEnums)) ++ extraIncludes.append(cppEnum->typeEntry()->extraIncludes()); ++ std::sort(extraIncludes.begin(), extraIncludes.end()); ++ for (const Include &inc : qAsConst(extraIncludes)) ++ s << inc; ++- s << Qt::endl; +++ s << endl; ++ ++ s << "// Current module's type array.\n"; ++ s << "PyTypeObject **" << cppApiVariableName() << " = nullptr;\n"; ++@@ -5682,7 +5682,7 @@ ++ // module inject-code native/beginning ++ if (!snips.isEmpty()) { ++ writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ // cleanup staticMetaObject attribute ++@@ -5707,7 +5707,7 @@ ++ ++ s << "// Global functions "; ++ s << "------------------------------------------------------------\n"; ++- s << globalFunctionImpl << Qt::endl; +++ s << globalFunctionImpl << endl; ++ ++ s << "static PyMethodDef " << moduleName() << "_methods[] = {\n"; ++ s << globalFunctionDecl; ++@@ -5715,7 +5715,7 @@ ++ ++ s << "// Classes initialization functions "; ++ s << "------------------------------------------------------------\n"; ++- s << classInitDecl << Qt::endl; +++ s << classInitDecl << endl; ++ ++ if (!globalEnums.isEmpty()) { ++ QString converterImpl; ++@@ -5727,14 +5727,14 @@ ++ if (cppEnum->isAnonymous() || cppEnum->isPrivate()) ++ continue; ++ writeEnumConverterFunctions(s, cppEnum); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ if (!converterImpl.isEmpty()) { ++ s << "// Enum converters "; ++ s << "------------------------------------------------------------\n"; ++ s << "namespace Shiboken\n{\n"; ++- s << converterImpl << Qt::endl; +++ s << converterImpl << endl; ++ s << "} // namespace Shiboken\n\n"; ++ } ++ } ++@@ -5746,16 +5746,16 @@ ++ s << "PyTypeObject **" << cppApiVariableName(requiredModule) << ";\n"; ++ s << "SbkConverter **" << convertersVariableName(requiredModule) << ";\n"; ++ } ++- s << Qt::endl; +++ s << endl; ++ ++ s << "// Module initialization "; ++ s << "------------------------------------------------------------\n"; ++ ExtendedConverterData extendedConverters = getExtendedConverters(); ++ if (!extendedConverters.isEmpty()) { ++- s << Qt::endl << "// Extended Converters.\n\n"; +++ s << endl << "// Extended Converters.\n\n"; ++ for (ExtendedConverterData::const_iterator it = extendedConverters.cbegin(), end = extendedConverters.cend(); it != end; ++it) { ++ const TypeEntry *externalType = it.key(); ++- s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << Qt::endl; +++ s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl; ++ for (const AbstractMetaClass *sourceClass : it.value()) { ++ AbstractMetaType *sourceType = buildAbstractMetaTypeFromAbstractMetaClass(sourceClass); ++ AbstractMetaType *targetType = buildAbstractMetaTypeFromTypeEntry(externalType); ++@@ -5766,13 +5766,13 @@ ++ ++ const QVector &typeConversions = getPrimitiveCustomConversions(); ++ if (!typeConversions.isEmpty()) { ++- s << Qt::endl << "// Primitive Type converters.\n\n"; +++ s << endl << "// Primitive Type converters.\n\n"; ++ for (const CustomConversion *conversion : typeConversions) { ++ s << "// C++ to Python conversion for type '" << conversion->ownerType()->qualifiedCppName() << "'.\n"; ++ writeCppToPythonFunction(s, conversion); ++ writeCustomConverterFunctions(s, conversion); ++ } ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ const QVector &containers = instantiatedContainers(); ++@@ -5782,7 +5782,7 @@ ++ s << "// C++ to Python conversion for type '" << container->cppSignature() << "'.\n"; ++ writeContainerConverterFunctions(s, container); ++ } ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ s << "#if defined _WIN32 || defined __CYGWIN__\n"; ++@@ -5816,7 +5816,7 @@ ++ // module inject-code target/beginning ++ if (!snips.isEmpty()) { ++ writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::TargetLangCode); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ for (const QString &requiredModule : requiredModules) { ++@@ -5863,26 +5863,26 @@ ++ s << classPythonDefines; ++ ++ if (!typeConversions.isEmpty()) { ++- s << Qt::endl; +++ s << endl; ++ for (const CustomConversion *conversion : typeConversions) { ++ writePrimitiveConverterInitialization(s, conversion); ++- s << Qt::endl; +++ s << endl; ++ } ++ } ++ ++ if (!containers.isEmpty()) { ++- s << Qt::endl; +++ s << endl; ++ for (const AbstractMetaType *container : containers) { ++ writeContainerConverterInitialization(s, container); ++- s << Qt::endl; +++ s << endl; ++ } ++ } ++ ++ if (!extendedConverters.isEmpty()) { ++- s << Qt::endl; +++ s << endl; ++ for (ExtendedConverterData::const_iterator it = extendedConverters.cbegin(), end = extendedConverters.cend(); it != end; ++it) { ++ writeExtendedConverterInitialization(s, it.key(), it.value()); ++- s << Qt::endl; +++ s << endl; ++ } ++ } ++ ++@@ -5897,7 +5897,7 @@ ++ if (!referencedType) ++ continue; ++ QString converter = converterObject(referencedType); ++- QStringList cppSignature = pte->qualifiedCppName().split(QLatin1String("::"), Qt::SkipEmptyParts); +++ QStringList cppSignature = pte->qualifiedCppName().split(QLatin1String("::"), QString::SkipEmptyParts); ++ while (!cppSignature.isEmpty()) { ++ QString signature = cppSignature.join(QLatin1String("::")); ++ s << INDENT << "Shiboken::Conversions::registerConverterName(" << converter << ", \"" << signature << "\");\n"; ++@@ -5905,12 +5905,12 @@ ++ } ++ } ++ ++- s << Qt::endl; +++ s << endl; ++ if (maxTypeIndex) ++ s << INDENT << "Shiboken::Module::registerTypes(module, " << cppApiVariableName() << ");\n"; ++ s << INDENT << "Shiboken::Module::registerTypeConverters(module, " << convertersVariableName() << ");\n"; ++ ++- s << Qt::endl << INDENT << "if (PyErr_Occurred()) {\n"; +++ s << endl << INDENT << "if (PyErr_Occurred()) {\n"; ++ { ++ Indentation indentation(INDENT); ++ s << INDENT << "PyErr_Print();\n"; ++@@ -5921,13 +5921,13 @@ ++ // module inject-code target/end ++ if (!snips.isEmpty()) { ++ writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::TargetLangCode); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ // module inject-code native/end ++ if (!snips.isEmpty()) { ++ writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ if (usePySideExtensions()) { ++@@ -5944,7 +5944,7 @@ ++ s << INDENT << "FinishSignatureInitialization(module, " << moduleName() ++ << "_SignatureStrings);\n"; ++ ++- s << Qt::endl; +++ s << endl; ++ s << "SBK_MODULE_INIT_FUNCTION_END\n"; ++ ++ return file.done() != FileOut::Failure; ++@@ -6132,7 +6132,7 @@ ++ { ++ Indentation indent(INDENT); ++ s << INDENT << "PyErr_SetString(PyExc_IndexError, \"" << errorMsg << "\");\n"; ++- s << INDENT << returnStatement(m_currentErrorCode) << Qt::endl; +++ s << INDENT << returnStatement(m_currentErrorCode) << endl; ++ } ++ s << INDENT << "}\n"; ++ } ++Index: pyside2/sources/shiboken2/generator/shiboken2/headergenerator.cpp ++=================================================================== ++--- pyside2.orig/sources/shiboken2/generator/shiboken2/headergenerator.cpp +++++ pyside2/sources/shiboken2/generator/shiboken2/headergenerator.cpp ++@@ -119,7 +119,7 @@ ++ s << "#define protected public\n\n"; ++ ++ //Includes ++- s << metaClass->typeEntry()->include() << Qt::endl; +++ s << metaClass->typeEntry()->include() << endl; ++ ++ if (classContext.useWrapper() && usePySideExtensions() && metaClass->isQObject()) ++ s << "namespace PySide { class DynamicQMetaObject; }\n\n"; ++@@ -416,7 +416,7 @@ ++ for (const AbstractMetaType *metaType : instantiatedSmartPtrs) { ++ QString indexName = getTypeIndexVariableName(metaType); ++ _writeTypeIndexValue(macrosStream, indexName, smartPointerCountIndex); ++- macrosStream << ", // " << metaType->cppSignature() << Qt::endl; +++ macrosStream << ", // " << metaType->cppSignature() << endl; ++ // Add a the same value for const pointees (shared_ptr). ++ const auto ptrName = metaType->typeEntry()->entryName(); ++ int pos = indexName.indexOf(ptrName, 0, Qt::CaseInsensitive); ++@@ -460,7 +460,7 @@ ++ const QVector &containers = instantiatedContainers(); ++ for (const AbstractMetaType *container : containers) { ++ _writeTypeIndexValue(macrosStream, getTypeIndexVariableName(container), pCount); ++- macrosStream << ", // " << container->cppSignature() << Qt::endl; +++ macrosStream << ", // " << container->cppSignature() << endl; ++ pCount++; ++ } ++ ++@@ -528,10 +528,10 @@ ++ FileOut file(moduleHeaderFileName); ++ QTextStream &s = file.stream; ++ // write license comment ++- s << licenseComment() << Qt::endl << Qt::endl; +++ s << licenseComment() << endl << endl; ++ ++- s << "#ifndef " << includeShield << Qt::endl; ++- s << "#define " << includeShield << Qt::endl << Qt::endl; +++ s << "#ifndef " << includeShield << endl; +++ s << "#define " << includeShield << endl << endl; ++ if (!avoidProtectedHack()) { ++ s << "//workaround to access protected functions\n"; ++ s << "#define protected public\n\n"; ++@@ -545,7 +545,7 @@ ++ s << "// Module Includes\n"; ++ for (const QString &requiredModule : qAsConst(requiredTargetImports)) ++ s << "#include <" << getModuleHeaderFileName(requiredModule) << ">\n"; ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ s << "// Bound library includes\n"; ++@@ -557,7 +557,7 @@ ++ const PrimitiveTypeEntryList &primitiveTypeList = primitiveTypes(); ++ for (const PrimitiveTypeEntry *ptype : primitiveTypeList) ++ s << ptype->include(); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++ if (!containerTypes().isEmpty()) { ++@@ -565,24 +565,24 @@ ++ const ContainerTypeEntryList &containerTypeList = containerTypes(); ++ for (const ContainerTypeEntry *ctype : containerTypeList) ++ s << ctype->include(); ++- s << Qt::endl; +++ s << endl; ++ } ++ ++- s << macros << Qt::endl; +++ s << macros << endl; ++ ++ if (!protectedEnumSurrogates.isEmpty()) { ++ s << "// Protected enum surrogates\n"; ++- s << protectedEnumSurrogates << Qt::endl; +++ s << protectedEnumSurrogates << endl; ++ } ++ ++ s << "namespace Shiboken\n{\n\n"; ++ ++ s << "// PyType functions, to get the PyObjectType for a type T\n"; ++- s << sbkTypeFunctions << Qt::endl; +++ s << sbkTypeFunctions << endl; ++ ++ s << "} // namespace Shiboken\n\n"; ++ ++- s << "#endif // " << includeShield << Qt::endl << Qt::endl; +++ s << "#endif // " << includeShield << endl << endl; ++ ++ return file.done() != FileOut::Failure; ++ } ++Index: pyside2/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp ++=================================================================== ++--- pyside2.orig/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp +++++ pyside2/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp ++@@ -97,7 +97,7 @@ ++ ++ static inline QStringList splitClassScope(const AbstractMetaClass *scope) ++ { ++- return scope->qualifiedCppName().split(QLatin1String("::"), Qt::SkipEmptyParts); +++ return scope->qualifiedCppName().split(QLatin1String("::"), QString::SkipEmptyParts); ++ } ++ ++ static QString resolveScopePrefix(const AbstractMetaClass *scope, const QString &value) ++@@ -2827,7 +2827,7 @@ ++ } else { ++ const QString message = msgCouldNotFindMinimalConstructor(QLatin1String(__FUNCTION__), type->qualifiedCppName()); ++ qCWarning(lcShiboken()).noquote() << message; ++- s << ";\n#error " << message << Qt::endl; +++ s << ";\n#error " << message << endl; ++ } ++ } ++ ++Index: pyside2/sources/shiboken2/ApiExtractor/typedatabase.cpp ++=================================================================== ++--- pyside2.orig/sources/shiboken2/ApiExtractor/typedatabase.cpp +++++ pyside2/sources/shiboken2/ApiExtractor/typedatabase.cpp ++@@ -891,7 +891,7 @@ ++ if (m_name != cppName) ++ d << "\", cppName=\"" << cppName << '"'; ++ d << ", type=" << m_type << ", codeGeneration=0x" ++- << Qt::hex << m_codeGeneration << Qt::dec +++ << hex << m_codeGeneration << dec ++ << ", target=\"" << targetLangName() << '"'; ++ FORMAT_NONEMPTY_STRING("package", m_targetLangPackage) ++ FORMAT_BOOL("stream", m_stream) ++Index: pyside2/sources/shiboken2/ApiExtractor/typesystem.cpp ++=================================================================== ++--- pyside2.orig/sources/shiboken2/ApiExtractor/typesystem.cpp +++++ pyside2/sources/shiboken2/ApiExtractor/typesystem.cpp ++@@ -433,7 +433,7 @@ ++ ++ void Modification::formatDebug(QDebug &d) const ++ { ++- d << "modifiers=" << Qt::hex << Qt::showbase << modifiers << Qt::noshowbase << Qt::dec; +++ d << "modifiers=" << hex << showbase << modifiers << noshowbase << dec; ++ if (removal) ++ d << ", removal"; ++ if (!renamedToName.isEmpty()) ++Index: pyside2/examples/scriptableapplication/mainwindow.cpp ++=================================================================== ++--- pyside2.orig/examples/scriptableapplication/mainwindow.cpp +++++ pyside2/examples/scriptableapplication/mainwindow.cpp ++@@ -114,7 +114,7 @@ ++ ++ void MainWindow::slotRunScript() ++ { ++- const QStringList script = m_scriptEdit->toPlainText().trimmed().split(QLatin1Char('\n'), Qt::SkipEmptyParts); +++ const QStringList script = m_scriptEdit->toPlainText().trimmed().split(QLatin1Char('\n'), QString::SkipEmptyParts); ++ if (!script.isEmpty()) ++ runScript(script); ++ } diff --cc debian/patches/python3.9.patch index 0000000,0000000..becfdc9 new file mode 100644 --- /dev/null +++ b/debian/patches/python3.9.patch @@@ -1,0 -1,0 +1,214 @@@ ++From: Christian Tismer ++Date: Thu, 18 Jun 2020 14:11:14 +0200 ++Subject: support Python 3.9 ++ ++Thanks Cristian for adding cosmetic changes which should already ++have been applied in Python 3.8 or earlier. ++ ++(cherry picked from commit 401f4ff22833f2be900d9a6d8887e7dae7b07011) ++--- ++ build_scripts/config.py | 3 ++- ++ build_scripts/wheel_override.py | 2 +- ++ sources/pyside2/libpyside/pysidesignal.cpp | 12 +++++++-- ++ sources/shiboken2/libshiboken/basewrapper.cpp | 2 ++ ++ sources/shiboken2/libshiboken/pep384impl.cpp | 4 +-- ++ sources/shiboken2/libshiboken/pep384impl.h | 30 ++++++++++++---------- ++ sources/shiboken2/libshiboken/threadstatesaver.cpp | 4 +++ ++ .../samplebinding/pointerprimitivetype_test.py | 5 +--- ++ 8 files changed, 39 insertions(+), 23 deletions(-) ++ ++diff --git a/build_scripts/config.py b/build_scripts/config.py ++index 4ec2af3..29bed2e 100644 ++--- a/build_scripts/config.py +++++ b/build_scripts/config.py ++@@ -92,6 +92,7 @@ class Config(object): ++ 'Programming Language :: Python :: 3.6', ++ 'Programming Language :: Python :: 3.7', ++ 'Programming Language :: Python :: 3.8', +++ 'Programming Language :: Python :: 3.9', ++ ] ++ ++ self.setup_script_dir = None ++@@ -134,7 +135,7 @@ class Config(object): ++ setup_kwargs['zip_safe'] = False ++ setup_kwargs['cmdclass'] = cmd_class_dict ++ setup_kwargs['version'] = package_version ++- setup_kwargs['python_requires'] = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <3.9" +++ setup_kwargs['python_requires'] = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <3.10" ++ ++ ++ if quiet: ++diff --git a/build_scripts/wheel_override.py b/build_scripts/wheel_override.py ++index 03c9c92..2982874 100644 ++--- a/build_scripts/wheel_override.py +++++ b/build_scripts/wheel_override.py ++@@ -89,7 +89,7 @@ class PysideBuildWheel(_bdist_wheel): ++ # create a properly named package. ++ limited_api_enabled = OPTION["LIMITED_API"] and sys.version_info[0] >= 3 ++ if limited_api_enabled: ++- self.py_limited_api = "cp35.cp36.cp37.cp38" +++ self.py_limited_api = "cp35.cp36.cp37.cp38.cp39" ++ ++ _bdist_wheel.finalize_options(self) ++ ++diff --git a/sources/pyside2/libpyside/pysidesignal.cpp b/sources/pyside2/libpyside/pysidesignal.cpp ++index 39ed1a6..b2ef835 100644 ++--- a/sources/pyside2/libpyside/pysidesignal.cpp +++++ b/sources/pyside2/libpyside/pysidesignal.cpp ++@@ -361,7 +361,7 @@ PyObject *signalInstanceConnect(PyObject *self, PyObject *args, PyObject *kwds) ++ ++ if (isMethod || isFunction) { ++ PyObject *function = isMethod ? PyMethod_GET_FUNCTION(slot) : slot; ++- PyCodeObject *objCode = reinterpret_cast(PyFunction_GET_CODE(function)); +++ auto *objCode = reinterpret_cast(PyFunction_GET_CODE(function)); ++ useSelf = isMethod; ++ slotArgs = PepCode_GET_FLAGS(objCode) & CO_VARARGS ? -1 : PepCode_GET_ARGCOUNT(objCode); ++ if (useSelf) ++@@ -568,7 +568,11 @@ PyObject *signalCall(PyObject *self, PyObject *args, PyObject *kw) ++ Shiboken::AutoDecRef homonymousMethod(getDescriptor(signal->homonymousMethod, 0, 0)); ++ if (PyCFunction_Check(homonymousMethod) ++ && (PyCFunction_GET_FLAGS(homonymousMethod.object()) & METH_STATIC)) { +++#if PY_VERSION_HEX >= 0x03090000 +++ return PyObject_Call(homonymousMethod, args, kw); +++#else ++ return PyCFunction_Call(homonymousMethod, args, kw); +++#endif ++ } ++ ++ // Assumes homonymousMethod is not a static method. ++@@ -586,7 +590,11 @@ PyObject *signalInstanceCall(PyObject *self, PyObject *args, PyObject *kw) ++ ++ descrgetfunc getDescriptor = Py_TYPE(PySideSignal->d->homonymousMethod)->tp_descr_get; ++ Shiboken::AutoDecRef homonymousMethod(getDescriptor(PySideSignal->d->homonymousMethod, PySideSignal->d->source, 0)); +++#if PY_VERSION_HEX >= 0x03090000 +++ return PyObject_Call(homonymousMethod, args, kw); +++#else ++ return PyCFunction_Call(homonymousMethod, args, kw); +++#endif ++ } ++ ++ static PyObject *metaSignalCheck(PyObject * /* klass */, PyObject *arg) ++@@ -928,7 +936,7 @@ QString getCallbackSignature(const char *signal, QObject *receiver, PyObject *ca ++ ++ if (isMethod || isFunction) { ++ PyObject *function = isMethod ? PyMethod_GET_FUNCTION(callback) : callback; ++- auto objCode = reinterpret_cast(PyFunction_GET_CODE(function)); +++ auto objCode = reinterpret_cast(PyFunction_GET_CODE(function)); ++ functionName = Shiboken::String::toCString(PepFunction_GetName(function)); ++ useSelf = isMethod; ++ numArgs = PepCode_GET_FLAGS(objCode) & CO_VARARGS ? -1 : PepCode_GET_ARGCOUNT(objCode); ++diff --git a/sources/shiboken2/libshiboken/basewrapper.cpp b/sources/shiboken2/libshiboken/basewrapper.cpp ++index 443d25c..570b1ec 100644 ++--- a/sources/shiboken2/libshiboken/basewrapper.cpp +++++ b/sources/shiboken2/libshiboken/basewrapper.cpp ++@@ -775,7 +775,9 @@ void init() ++ ++ Conversions::init(); ++ +++#if PY_VERSION_HEX < 0x03070000 ++ PyEval_InitThreads(); +++#endif ++ ++ //Init private data ++ Pep384_Init(); ++diff --git a/sources/shiboken2/libshiboken/pep384impl.cpp b/sources/shiboken2/libshiboken/pep384impl.cpp ++index f07cac6..1821e0b 100644 ++--- a/sources/shiboken2/libshiboken/pep384impl.cpp +++++ b/sources/shiboken2/libshiboken/pep384impl.cpp ++@@ -307,9 +307,9 @@ Pep_GetVerboseFlag() ++ #ifdef Py_LIMITED_API ++ ++ int ++-PepCode_Get(PyCodeObject *co, const char *name) +++PepCode_Get(PepCodeObject *co, const char *name) ++ { ++- PyObject *ob = (PyObject *)co; +++ PyObject *ob = reinterpret_cast(co); ++ PyObject *ob_ret; ++ int ret = -1; ++ ++diff --git a/sources/shiboken2/libshiboken/pep384impl.h b/sources/shiboken2/libshiboken/pep384impl.h ++index 541b0e7..3d000dd 100644 ++--- a/sources/shiboken2/libshiboken/pep384impl.h +++++ b/sources/shiboken2/libshiboken/pep384impl.h ++@@ -327,7 +327,7 @@ LIBSHIBOKEN_API PyObject *PyRun_String(const char *, int, PyObject *, PyObject * ++ // But this is no problem as we check it's validity for every version. ++ ++ #define PYTHON_BUFFER_VERSION_COMPATIBLE (PY_VERSION_HEX >= 0x03030000 && \ ++- PY_VERSION_HEX < 0x0308FFFF) +++ PY_VERSION_HEX < 0x0309FFFF) ++ #if !PYTHON_BUFFER_VERSION_COMPATIBLE ++ # error Please check the buffer compatibility for this python version! ++ #endif ++@@ -411,23 +411,27 @@ LIBSHIBOKEN_API PyObject *PyMethod_Self(PyObject *); ++ /* Bytecode object */ ++ ++ // we have to grab the code object from python ++-typedef struct _code PyCodeObject; +++typedef struct _code PepCodeObject; ++ ++-LIBSHIBOKEN_API int PepCode_Get(PyCodeObject *co, const char *name); +++LIBSHIBOKEN_API int PepCode_Get(PepCodeObject *co, const char *name); ++ ++-#define PepCode_GET_FLAGS(o) PepCode_Get(o, "co_flags") ++-#define PepCode_GET_ARGCOUNT(o) PepCode_Get(o, "co_argcount") +++# define PepCode_GET_FLAGS(o) PepCode_Get(o, "co_flags") +++# define PepCode_GET_ARGCOUNT(o) PepCode_Get(o, "co_argcount") ++ ++ /* Masks for co_flags above */ ++-#define CO_OPTIMIZED 0x0001 ++-#define CO_NEWLOCALS 0x0002 ++-#define CO_VARARGS 0x0004 ++-#define CO_VARKEYWORDS 0x0008 ++-#define CO_NESTED 0x0010 ++-#define CO_GENERATOR 0x0020 +++# define CO_OPTIMIZED 0x0001 +++# define CO_NEWLOCALS 0x0002 +++# define CO_VARARGS 0x0004 +++# define CO_VARKEYWORDS 0x0008 +++# define CO_NESTED 0x0010 +++# define CO_GENERATOR 0x0020 +++ ++ #else ++-#define PepCode_GET_FLAGS(o) ((o)->co_flags) ++-#define PepCode_GET_ARGCOUNT(o) ((o)->co_argcount) +++ +++# define PepCodeObject PyCodeObject +++# define PepCode_GET_FLAGS(o) ((o)->co_flags) +++# define PepCode_GET_ARGCOUNT(o) ((o)->co_argcount) +++ ++ #endif ++ ++ /***************************************************************************** ++diff --git a/sources/shiboken2/libshiboken/threadstatesaver.cpp b/sources/shiboken2/libshiboken/threadstatesaver.cpp ++index 0d19528..085535f 100644 ++--- a/sources/shiboken2/libshiboken/threadstatesaver.cpp +++++ b/sources/shiboken2/libshiboken/threadstatesaver.cpp ++@@ -51,7 +51,11 @@ ThreadStateSaver::~ThreadStateSaver() ++ ++ void ThreadStateSaver::save() ++ { +++#if PY_VERSION_HEX >= 0x0309000 +++ if (Py_IsInitialized()) +++#else ++ if (PyEval_ThreadsInitialized()) +++#endif ++ m_threadState = PyEval_SaveThread(); ++ } ++ ++diff --git a/sources/shiboken2/tests/samplebinding/pointerprimitivetype_test.py b/sources/shiboken2/tests/samplebinding/pointerprimitivetype_test.py ++index 532f222..9ce641f 100644 ++--- a/sources/shiboken2/tests/samplebinding/pointerprimitivetype_test.py +++++ b/sources/shiboken2/tests/samplebinding/pointerprimitivetype_test.py ++@@ -70,10 +70,7 @@ class PointerPrimitiveTypeTest(unittest.TestCase): ++ self.assertTrue(found) ++ ann = sig.parameters["data"].annotation ++ self.assertEqual(ann.__args__, (int,)) ++- # un-specify this class (forget "int") by setting the _special ++- # flag, so we can check using issubclass (undocumented feature). ++- ann._special = True ++- self.assertTrue(issubclass(ann, typing.Iterable)) +++ self.assertTrue(issubclass(ann.__origin__, typing.Iterable)) ++ ++ def testReturnVarSignature(self): ++ # signature="getMargins(int*,int*,int*,int*)const"> diff --cc debian/patches/series index 0000000,0000000..6b5f0d9 new file mode 100644 --- /dev/null +++ b/debian/patches/series @@@ -1,0 -1,0 +1,5 @@@ ++fix-spelling-errors.patch ++update-patchelf.patch ++blacklist-failing-tests.patch ++ftbfs-old-qt.patch ++python3.9.patch diff --cc debian/patches/update-patchelf.patch index 0000000,0000000..b7798d2 new file mode 100644 --- /dev/null +++ b/debian/patches/update-patchelf.patch @@@ -1,0 -1,0 +1,3117 @@@ ++From: Debian Qt/KDE Maintainers ++Date: Tue, 5 Nov 2019 10:39:14 +0100 ++Subject: update-patchelf ++MIME-Version: 1.0 ++Content-Type: text/plain; charset="utf-8" ++Content-Transfer-Encoding: 8bit ++ ++Update patchelf to current git version ++ ++The current version fixes a bug which broke the ability to strip ++binaries with debug symbols: ++https://github.com/NixOS/patchelf/pull/117 ++ ++With the former version of patchelf, I would get "not enough room for ++program headers, try linking with -N" when trying to strip the binaries. ++ ++This patch brings patchelf in sync with the commit ++27ffe8ae871e7a186018d66020ef3f6162c12c69 of patchelf's git ++repository. ++ ++Also update patchelf's build process to match the logic in upstream's ++automake files (thanks to Frédéric Bonnard for the patch to properly use ++getconf PAGESIZE). ++ ++Bug: https://bugreports.qt.io/browse/PYSIDE-740 ++Last-Update: 2018-07-09 ++--- ++ build_scripts/main.py | 13 +- ++ sources/patchelf/elf.h | 1064 +++++++++++++++++++++++++++++++--------- ++ sources/patchelf/patchelf.cc | 1101 +++++++++++++++++++++++++++++++----------- ++ 3 files changed, 1673 insertions(+), 505 deletions(-) ++ ++diff --git a/build_scripts/main.py b/build_scripts/main.py ++index 674048e..e638724 100644 ++--- a/build_scripts/main.py +++++ b/build_scripts/main.py ++@@ -873,7 +873,18 @@ class PysideBuild(_build): ++ return ++ log.info("Building patchelf...") ++ module_src_dir = os.path.join(self.sources_dir, "patchelf") ++- build_cmd = ["g++", "{}/patchelf.cc".format(module_src_dir), "-o", "patchelf"] +++ import subprocess +++ pagesize = subprocess.check_output("getconf PAGESIZE", shell=True).decode('utf-8').rstrip() +++ build_cmd = [ +++ "g++", +++ "-std=c++11", +++ "-DPAGESIZE=%s" % (pagesize), +++ '-DPACKAGE_STRING="patchelf"', +++ "-D_FILE_OFFSET_BITS=64", +++ "{}/patchelf.cc".format(module_src_dir), +++ "-o", +++ "patchelf", +++ ] ++ if run_process(build_cmd) != 0: ++ raise DistutilsSetupError("Error building patchelf") ++ self._patchelf_path = os.path.join(self.script_dir, "patchelf") ++diff --git a/sources/patchelf/elf.h b/sources/patchelf/elf.h ++index b897f5b..87cb141 100644 ++--- a/sources/patchelf/elf.h +++++ b/sources/patchelf/elf.h ++@@ -1,6 +1,5 @@ ++ /* This file defines standard ELF types, structures, and macros. ++- Copyright (C) 1995-2003,2004,2005,2006,2007,2008 ++- Free Software Foundation, Inc. +++ Copyright (C) 1995-2014 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++@@ -14,13 +13,16 @@ ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++- License along with the GNU C Library; if not, write to the Free ++- Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++- 02111-1307 USA. */ +++ License along with the GNU C Library; if not, see +++ . */ ++ ++ #ifndef _ELF_H ++ #define _ELF_H 1 ++ +++/* #include */ +++ +++/* __BEGIN_DECLS */ +++ ++ /* Standard ELF types. */ ++ ++ #include ++@@ -138,7 +140,8 @@ typedef struct ++ #define ELFOSABI_SYSV 0 /* Alias. */ ++ #define ELFOSABI_HPUX 1 /* HP-UX */ ++ #define ELFOSABI_NETBSD 2 /* NetBSD. */ ++-#define ELFOSABI_LINUX 3 /* Linux. */ +++#define ELFOSABI_GNU 3 /* Object uses GNU ELF extensions. */ +++#define ELFOSABI_LINUX ELFOSABI_GNU /* Compatibility alias. */ ++ #define ELFOSABI_SOLARIS 6 /* Sun Solaris. */ ++ #define ELFOSABI_AIX 7 /* IBM AIX. */ ++ #define ELFOSABI_IRIX 8 /* SGI Irix. */ ++@@ -146,6 +149,7 @@ typedef struct ++ #define ELFOSABI_TRU64 10 /* Compaq TRU64 UNIX. */ ++ #define ELFOSABI_MODESTO 11 /* Novell Modesto. */ ++ #define ELFOSABI_OPENBSD 12 /* OpenBSD. */ +++#define ELFOSABI_ARM_AEABI 64 /* ARM EABI */ ++ #define ELFOSABI_ARM 97 /* ARM */ ++ #define ELFOSABI_STANDALONE 255 /* Standalone (embedded) application */ ++ ++@@ -245,7 +249,11 @@ typedef struct ++ #define EM_OPENRISC 92 /* OpenRISC 32-bit embedded processor */ ++ #define EM_ARC_A5 93 /* ARC Cores Tangent-A5 */ ++ #define EM_XTENSA 94 /* Tensilica Xtensa Architecture */ ++-#define EM_NUM 95 +++#define EM_AARCH64 183 /* ARM AARCH64 */ +++#define EM_TILEPRO 188 /* Tilera TILEPro */ +++#define EM_MICROBLAZE 189 /* Xilinx MicroBlaze */ +++#define EM_TILEGX 191 /* Tilera TILE-Gx */ +++#define EM_NUM 192 ++ ++ /* If it is necessary to assign new unofficial EM_* values, please ++ pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the ++@@ -440,6 +448,7 @@ typedef struct ++ #define STB_WEAK 2 /* Weak symbol */ ++ #define STB_NUM 3 /* Number of defined types. */ ++ #define STB_LOOS 10 /* Start of OS-specific */ +++#define STB_GNU_UNIQUE 10 /* Unique symbol. */ ++ #define STB_HIOS 12 /* End of OS-specific */ ++ #define STB_LOPROC 13 /* Start of processor-specific */ ++ #define STB_HIPROC 15 /* End of processor-specific */ ++@@ -455,6 +464,7 @@ typedef struct ++ #define STT_TLS 6 /* Symbol is thread-local data object*/ ++ #define STT_NUM 7 /* Number of defined types. */ ++ #define STT_LOOS 10 /* Start of OS-specific */ +++#define STT_GNU_IFUNC 10 /* Symbol is indirect code object */ ++ #define STT_HIOS 12 /* End of OS-specific */ ++ #define STT_LOPROC 13 /* Start of processor-specific */ ++ #define STT_HIPROC 15 /* End of processor-specific */ ++@@ -552,6 +562,12 @@ typedef struct ++ Elf64_Xword p_align; /* Segment alignment */ ++ } Elf64_Phdr; ++ +++/* Special value for e_phnum. This indicates that the real number of +++ program headers is too large to fit into e_phnum. Instead the real +++ value is in the field sh_info of section 0. */ +++ +++#define PN_XNUM 0xffff +++ ++ /* Legal values for p_type (segment type). */ ++ ++ #define PT_NULL 0 /* Program header table entry unused */ ++@@ -601,10 +617,30 @@ typedef struct ++ #define NT_LWPSTATUS 16 /* Contains copy of lwpstatus struct */ ++ #define NT_LWPSINFO 17 /* Contains copy of lwpinfo struct */ ++ #define NT_PRFPXREG 20 /* Contains copy of fprxregset struct */ +++#define NT_SIGINFO 0x53494749 /* Contains copy of siginfo_t, +++ size might increase */ +++#define NT_FILE 0x46494c45 /* Contains information about mapped +++ files */ ++ #define NT_PRXFPREG 0x46e62b7f /* Contains copy of user_fxsr_struct */ ++ #define NT_PPC_VMX 0x100 /* PowerPC Altivec/VMX registers */ ++ #define NT_PPC_SPE 0x101 /* PowerPC SPE/EVR registers */ +++#define NT_PPC_VSX 0x102 /* PowerPC VSX registers */ ++ #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ +++#define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ +++#define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ +++#define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ +++#define NT_S390_TIMER 0x301 /* s390 timer register */ +++#define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +++#define NT_S390_TODPREG 0x303 /* s390 TOD programmable register */ +++#define NT_S390_CTRS 0x304 /* s390 control registers */ +++#define NT_S390_PREFIX 0x305 /* s390 prefix register */ +++#define NT_S390_LAST_BREAK 0x306 /* s390 breaking event address */ +++#define NT_S390_SYSTEM_CALL 0x307 /* s390 system call restart data */ +++#define NT_S390_TDB 0x308 /* s390 transaction diagnostic block */ +++#define NT_ARM_VFP 0x400 /* ARM VFP/NEON registers */ +++#define NT_ARM_TLS 0x401 /* ARM TLS register */ +++#define NT_ARM_HW_BREAK 0x402 /* ARM hardware breakpoint registers */ +++#define NT_ARM_HW_WATCH 0x403 /* ARM hardware watchpoint registers */ ++ ++ /* Legal values for the note segment descriptor types for object files. */ ++ ++@@ -768,6 +804,15 @@ typedef struct ++ #define DF_1_ENDFILTEE 0x00004000 /* Filtee terminates filters search. */ ++ #define DF_1_DISPRELDNE 0x00008000 /* Disp reloc applied at build time. */ ++ #define DF_1_DISPRELPND 0x00010000 /* Disp reloc applied at run-time. */ +++#define DF_1_NODIRECT 0x00020000 /* Object has no-direct binding. */ +++#define DF_1_IGNMULDEF 0x00040000 +++#define DF_1_NOKSYMS 0x00080000 +++#define DF_1_NOHDR 0x00100000 +++#define DF_1_EDITED 0x00200000 /* Object is modified after built. */ +++#define DF_1_NORELOC 0x00400000 +++#define DF_1_SYMINTPOSE 0x00800000 /* Object has individual interposers. */ +++#define DF_1_GLOBAUDIT 0x01000000 /* Global auditing required. */ +++#define DF_1_SINGLETON 0x02000000 /* Singleton symbols are used. */ ++ ++ /* Flags for the feature selection in DT_FEATURE_1. */ ++ #define DTF_1_PARINIT 0x00000001 ++@@ -927,59 +972,7 @@ typedef struct ++ } a_un; ++ } Elf64_auxv_t; ++ ++-/* Legal values for a_type (entry type). */ ++- ++-#define AT_NULL 0 /* End of vector */ ++-#define AT_IGNORE 1 /* Entry should be ignored */ ++-#define AT_EXECFD 2 /* File descriptor of program */ ++-#define AT_PHDR 3 /* Program headers for program */ ++-#define AT_PHENT 4 /* Size of program header entry */ ++-#define AT_PHNUM 5 /* Number of program headers */ ++-#define AT_PAGESZ 6 /* System page size */ ++-#define AT_BASE 7 /* Base address of interpreter */ ++-#define AT_FLAGS 8 /* Flags */ ++-#define AT_ENTRY 9 /* Entry point of program */ ++-#define AT_NOTELF 10 /* Program is not ELF */ ++-#define AT_UID 11 /* Real uid */ ++-#define AT_EUID 12 /* Effective uid */ ++-#define AT_GID 13 /* Real gid */ ++-#define AT_EGID 14 /* Effective gid */ ++-#define AT_CLKTCK 17 /* Frequency of times() */ ++- ++-/* Some more special a_type values describing the hardware. */ ++-#define AT_PLATFORM 15 /* String identifying platform. */ ++-#define AT_HWCAP 16 /* Machine dependent hints about ++- processor capabilities. */ ++- ++-/* This entry gives some information about the FPU initialization ++- performed by the kernel. */ ++-#define AT_FPUCW 18 /* Used FPU control word. */ ++- ++-/* Cache block sizes. */ ++-#define AT_DCACHEBSIZE 19 /* Data cache block size. */ ++-#define AT_ICACHEBSIZE 20 /* Instruction cache block size. */ ++-#define AT_UCACHEBSIZE 21 /* Unified cache block size. */ ++- ++-/* A special ignored value for PPC, used by the kernel to control the ++- interpretation of the AUXV. Must be > 16. */ ++-#define AT_IGNOREPPC 22 /* Entry should be ignored. */ ++- ++-#define AT_SECURE 23 /* Boolean, was exec setuid-like? */ ++- ++-#define AT_EXECFN 31 /* Filename of executable. */ ++- ++-/* Pointer to the global system page used for system calls and other ++- nice things. */ ++-#define AT_SYSINFO 32 ++-#define AT_SYSINFO_EHDR 33 ++- ++-/* Shapes of the caches. Bits 0-3 contains associativity; bits 4-7 contains ++- log2 of line size; mask those to get cache size. */ ++-#define AT_L1I_CACHESHAPE 34 ++-#define AT_L1D_CACHESHAPE 35 ++-#define AT_L2_CACHESHAPE 36 ++-#define AT_L3_CACHESHAPE 37 ++- +++/* #include */ ++ /* Note section contents. Each entry in the note section begins with ++ a header of a fixed form. */ ++ ++@@ -1042,6 +1035,9 @@ typedef struct ++ The descriptor consists of any nonzero number of bytes. */ ++ #define NT_GNU_BUILD_ID 3 ++ +++/* Version note generated by GNU gold containing a version string. */ +++#define NT_GNU_GOLD_VERSION 4 +++ ++ ++ /* Move records. */ ++ typedef struct ++@@ -1102,8 +1098,29 @@ typedef struct ++ #define R_68K_GLOB_DAT 20 /* Create GOT entry */ ++ #define R_68K_JMP_SLOT 21 /* Create PLT entry */ ++ #define R_68K_RELATIVE 22 /* Adjust by program base */ +++#define R_68K_TLS_GD32 25 /* 32 bit GOT offset for GD */ +++#define R_68K_TLS_GD16 26 /* 16 bit GOT offset for GD */ +++#define R_68K_TLS_GD8 27 /* 8 bit GOT offset for GD */ +++#define R_68K_TLS_LDM32 28 /* 32 bit GOT offset for LDM */ +++#define R_68K_TLS_LDM16 29 /* 16 bit GOT offset for LDM */ +++#define R_68K_TLS_LDM8 30 /* 8 bit GOT offset for LDM */ +++#define R_68K_TLS_LDO32 31 /* 32 bit module-relative offset */ +++#define R_68K_TLS_LDO16 32 /* 16 bit module-relative offset */ +++#define R_68K_TLS_LDO8 33 /* 8 bit module-relative offset */ +++#define R_68K_TLS_IE32 34 /* 32 bit GOT offset for IE */ +++#define R_68K_TLS_IE16 35 /* 16 bit GOT offset for IE */ +++#define R_68K_TLS_IE8 36 /* 8 bit GOT offset for IE */ +++#define R_68K_TLS_LE32 37 /* 32 bit offset relative to +++ static TLS block */ +++#define R_68K_TLS_LE16 38 /* 16 bit offset relative to +++ static TLS block */ +++#define R_68K_TLS_LE8 39 /* 8 bit offset relative to +++ static TLS block */ +++#define R_68K_TLS_DTPMOD32 40 /* 32 bit module number */ +++#define R_68K_TLS_DTPREL32 41 /* 32 bit module-relative offset */ +++#define R_68K_TLS_TPREL32 42 /* 32 bit TP-relative offset */ ++ /* Keep this the last entry. */ ++-#define R_68K_NUM 23 +++#define R_68K_NUM 43 ++ ++ /* Intel 80386 specific definitions. */ ++ ++@@ -1157,7 +1174,7 @@ typedef struct ++ #define R_386_TLS_DTPMOD32 35 /* ID of module containing symbol */ ++ #define R_386_TLS_DTPOFF32 36 /* Offset in TLS block */ ++ #define R_386_TLS_TPOFF32 37 /* Negated offset in static TLS block */ ++-/* 38? */ +++#define R_386_SIZE32 38 /* 32-bit symbol size */ ++ #define R_386_TLS_GOTDESC 39 /* GOT offset for TLS descriptor. */ ++ #define R_386_TLS_DESC_CALL 40 /* Marker of call through TLS ++ descriptor for ++@@ -1166,8 +1183,9 @@ typedef struct ++ pointer to code and to ++ argument, returning the TLS ++ offset for the symbol. */ +++#define R_386_IRELATIVE 42 /* Adjust indirectly by program base */ ++ /* Keep this the last entry. */ ++-#define R_386_NUM 42 +++#define R_386_NUM 43 ++ ++ /* SUN SPARC specific definitions. */ ++ ++@@ -1235,6 +1253,7 @@ typedef struct ++ #define R_SPARC_PC_LM22 39 /* Low miggle 22 bits of ... */ ++ #define R_SPARC_WDISP16 40 /* PC relative 16 bit shifted */ ++ #define R_SPARC_WDISP19 41 /* PC relative 19 bit shifted */ +++#define R_SPARC_GLOB_JMP 42 /* was part of v9 ABI but was removed */ ++ #define R_SPARC_7 43 /* Direct 7 bit */ ++ #define R_SPARC_5 44 /* Direct 5 bit */ ++ #define R_SPARC_6 45 /* Direct 6 bit */ ++@@ -1272,118 +1291,124 @@ typedef struct ++ #define R_SPARC_TLS_DTPOFF64 77 ++ #define R_SPARC_TLS_TPOFF32 78 ++ #define R_SPARC_TLS_TPOFF64 79 +++#define R_SPARC_GOTDATA_HIX22 80 +++#define R_SPARC_GOTDATA_LOX10 81 +++#define R_SPARC_GOTDATA_OP_HIX22 82 +++#define R_SPARC_GOTDATA_OP_LOX10 83 +++#define R_SPARC_GOTDATA_OP 84 +++#define R_SPARC_H34 85 +++#define R_SPARC_SIZE32 86 +++#define R_SPARC_SIZE64 87 +++#define R_SPARC_WDISP10 88 +++#define R_SPARC_JMP_IREL 248 +++#define R_SPARC_IRELATIVE 249 +++#define R_SPARC_GNU_VTINHERIT 250 +++#define R_SPARC_GNU_VTENTRY 251 +++#define R_SPARC_REV32 252 ++ /* Keep this the last entry. */ ++-#define R_SPARC_NUM 80 +++#define R_SPARC_NUM 253 ++ ++ /* For Sparc64, legal values for d_tag of Elf64_Dyn. */ ++ ++-#define DT_SPARC_REGISTER 0x70000001 ++-#define DT_SPARC_NUM 2 ++- ++-/* Bits present in AT_HWCAP on SPARC. */ ++- ++-#define HWCAP_SPARC_FLUSH 1 /* The CPU supports flush insn. */ ++-#define HWCAP_SPARC_STBAR 2 ++-#define HWCAP_SPARC_SWAP 4 ++-#define HWCAP_SPARC_MULDIV 8 ++-#define HWCAP_SPARC_V9 16 /* The CPU is v9, so v8plus is ok. */ ++-#define HWCAP_SPARC_ULTRA3 32 ++-#define HWCAP_SPARC_BLKINIT 64 /* Sun4v with block-init/load-twin. */ ++-#define HWCAP_SPARC_N2 128 +++#define DT_SPARC_REGISTER 0x70000001 +++#define DT_SPARC_NUM 2 ++ ++ /* MIPS R3000 specific definitions. */ ++ ++ /* Legal values for e_flags field of Elf32_Ehdr. */ ++ ++-#define EF_MIPS_NOREORDER 1 /* A .noreorder directive was used */ ++-#define EF_MIPS_PIC 2 /* Contains PIC code */ ++-#define EF_MIPS_CPIC 4 /* Uses PIC calling sequence */ ++-#define EF_MIPS_XGOT 8 ++-#define EF_MIPS_64BIT_WHIRL 16 ++-#define EF_MIPS_ABI2 32 ++-#define EF_MIPS_ABI_ON32 64 ++-#define EF_MIPS_ARCH 0xf0000000 /* MIPS architecture level */ +++#define EF_MIPS_NOREORDER 1 /* A .noreorder directive was used. */ +++#define EF_MIPS_PIC 2 /* Contains PIC code. */ +++#define EF_MIPS_CPIC 4 /* Uses PIC calling sequence. */ +++#define EF_MIPS_XGOT 8 +++#define EF_MIPS_64BIT_WHIRL 16 +++#define EF_MIPS_ABI2 32 +++#define EF_MIPS_ABI_ON32 64 +++#define EF_MIPS_NAN2008 1024 /* Uses IEEE 754-2008 NaN encoding. */ +++#define EF_MIPS_ARCH 0xf0000000 /* MIPS architecture level. */ ++ ++ /* Legal values for MIPS architecture level. */ ++ ++-#define EF_MIPS_ARCH_1 0x00000000 /* -mips1 code. */ ++-#define EF_MIPS_ARCH_2 0x10000000 /* -mips2 code. */ ++-#define EF_MIPS_ARCH_3 0x20000000 /* -mips3 code. */ ++-#define EF_MIPS_ARCH_4 0x30000000 /* -mips4 code. */ ++-#define EF_MIPS_ARCH_5 0x40000000 /* -mips5 code. */ ++-#define EF_MIPS_ARCH_32 0x60000000 /* MIPS32 code. */ ++-#define EF_MIPS_ARCH_64 0x70000000 /* MIPS64 code. */ ++- ++-/* The following are non-official names and should not be used. */ ++- ++-#define E_MIPS_ARCH_1 0x00000000 /* -mips1 code. */ ++-#define E_MIPS_ARCH_2 0x10000000 /* -mips2 code. */ ++-#define E_MIPS_ARCH_3 0x20000000 /* -mips3 code. */ ++-#define E_MIPS_ARCH_4 0x30000000 /* -mips4 code. */ ++-#define E_MIPS_ARCH_5 0x40000000 /* -mips5 code. */ ++-#define E_MIPS_ARCH_32 0x60000000 /* MIPS32 code. */ ++-#define E_MIPS_ARCH_64 0x70000000 /* MIPS64 code. */ +++#define EF_MIPS_ARCH_1 0x00000000 /* -mips1 code. */ +++#define EF_MIPS_ARCH_2 0x10000000 /* -mips2 code. */ +++#define EF_MIPS_ARCH_3 0x20000000 /* -mips3 code. */ +++#define EF_MIPS_ARCH_4 0x30000000 /* -mips4 code. */ +++#define EF_MIPS_ARCH_5 0x40000000 /* -mips5 code. */ +++#define EF_MIPS_ARCH_32 0x50000000 /* MIPS32 code. */ +++#define EF_MIPS_ARCH_64 0x60000000 /* MIPS64 code. */ +++#define EF_MIPS_ARCH_32R2 0x70000000 /* MIPS32r2 code. */ +++#define EF_MIPS_ARCH_64R2 0x80000000 /* MIPS64r2 code. */ +++ +++/* The following are unofficial names and should not be used. */ +++ +++#define E_MIPS_ARCH_1 EF_MIPS_ARCH_1 +++#define E_MIPS_ARCH_2 EF_MIPS_ARCH_2 +++#define E_MIPS_ARCH_3 EF_MIPS_ARCH_3 +++#define E_MIPS_ARCH_4 EF_MIPS_ARCH_4 +++#define E_MIPS_ARCH_5 EF_MIPS_ARCH_5 +++#define E_MIPS_ARCH_32 EF_MIPS_ARCH_32 +++#define E_MIPS_ARCH_64 EF_MIPS_ARCH_64 ++ ++ /* Special section indices. */ ++ ++-#define SHN_MIPS_ACOMMON 0xff00 /* Allocated common symbols */ ++-#define SHN_MIPS_TEXT 0xff01 /* Allocated test symbols. */ ++-#define SHN_MIPS_DATA 0xff02 /* Allocated data symbols. */ ++-#define SHN_MIPS_SCOMMON 0xff03 /* Small common symbols */ ++-#define SHN_MIPS_SUNDEFINED 0xff04 /* Small undefined symbols */ +++#define SHN_MIPS_ACOMMON 0xff00 /* Allocated common symbols. */ +++#define SHN_MIPS_TEXT 0xff01 /* Allocated test symbols. */ +++#define SHN_MIPS_DATA 0xff02 /* Allocated data symbols. */ +++#define SHN_MIPS_SCOMMON 0xff03 /* Small common symbols. */ +++#define SHN_MIPS_SUNDEFINED 0xff04 /* Small undefined symbols. */ ++ ++ /* Legal values for sh_type field of Elf32_Shdr. */ ++ ++-#define SHT_MIPS_LIBLIST 0x70000000 /* Shared objects used in link */ ++-#define SHT_MIPS_MSYM 0x70000001 ++-#define SHT_MIPS_CONFLICT 0x70000002 /* Conflicting symbols */ ++-#define SHT_MIPS_GPTAB 0x70000003 /* Global data area sizes */ ++-#define SHT_MIPS_UCODE 0x70000004 /* Reserved for SGI/MIPS compilers */ ++-#define SHT_MIPS_DEBUG 0x70000005 /* MIPS ECOFF debugging information*/ ++-#define SHT_MIPS_REGINFO 0x70000006 /* Register usage information */ ++-#define SHT_MIPS_PACKAGE 0x70000007 ++-#define SHT_MIPS_PACKSYM 0x70000008 ++-#define SHT_MIPS_RELD 0x70000009 ++-#define SHT_MIPS_IFACE 0x7000000b ++-#define SHT_MIPS_CONTENT 0x7000000c ++-#define SHT_MIPS_OPTIONS 0x7000000d /* Miscellaneous options. */ ++-#define SHT_MIPS_SHDR 0x70000010 ++-#define SHT_MIPS_FDESC 0x70000011 ++-#define SHT_MIPS_EXTSYM 0x70000012 ++-#define SHT_MIPS_DENSE 0x70000013 ++-#define SHT_MIPS_PDESC 0x70000014 ++-#define SHT_MIPS_LOCSYM 0x70000015 ++-#define SHT_MIPS_AUXSYM 0x70000016 ++-#define SHT_MIPS_OPTSYM 0x70000017 ++-#define SHT_MIPS_LOCSTR 0x70000018 ++-#define SHT_MIPS_LINE 0x70000019 ++-#define SHT_MIPS_RFDESC 0x7000001a ++-#define SHT_MIPS_DELTASYM 0x7000001b ++-#define SHT_MIPS_DELTAINST 0x7000001c ++-#define SHT_MIPS_DELTACLASS 0x7000001d ++-#define SHT_MIPS_DWARF 0x7000001e /* DWARF debugging information. */ ++-#define SHT_MIPS_DELTADECL 0x7000001f ++-#define SHT_MIPS_SYMBOL_LIB 0x70000020 ++-#define SHT_MIPS_EVENTS 0x70000021 /* Event section. */ ++-#define SHT_MIPS_TRANSLATE 0x70000022 ++-#define SHT_MIPS_PIXIE 0x70000023 ++-#define SHT_MIPS_XLATE 0x70000024 ++-#define SHT_MIPS_XLATE_DEBUG 0x70000025 ++-#define SHT_MIPS_WHIRL 0x70000026 ++-#define SHT_MIPS_EH_REGION 0x70000027 ++-#define SHT_MIPS_XLATE_OLD 0x70000028 ++-#define SHT_MIPS_PDR_EXCEPTION 0x70000029 +++#define SHT_MIPS_LIBLIST 0x70000000 /* Shared objects used in link. */ +++#define SHT_MIPS_MSYM 0x70000001 +++#define SHT_MIPS_CONFLICT 0x70000002 /* Conflicting symbols. */ +++#define SHT_MIPS_GPTAB 0x70000003 /* Global data area sizes. */ +++#define SHT_MIPS_UCODE 0x70000004 /* Reserved for SGI/MIPS compilers */ +++#define SHT_MIPS_DEBUG 0x70000005 /* MIPS ECOFF debugging info. */ +++#define SHT_MIPS_REGINFO 0x70000006 /* Register usage information. */ +++#define SHT_MIPS_PACKAGE 0x70000007 +++#define SHT_MIPS_PACKSYM 0x70000008 +++#define SHT_MIPS_RELD 0x70000009 +++#define SHT_MIPS_IFACE 0x7000000b +++#define SHT_MIPS_CONTENT 0x7000000c +++#define SHT_MIPS_OPTIONS 0x7000000d /* Miscellaneous options. */ +++#define SHT_MIPS_SHDR 0x70000010 +++#define SHT_MIPS_FDESC 0x70000011 +++#define SHT_MIPS_EXTSYM 0x70000012 +++#define SHT_MIPS_DENSE 0x70000013 +++#define SHT_MIPS_PDESC 0x70000014 +++#define SHT_MIPS_LOCSYM 0x70000015 +++#define SHT_MIPS_AUXSYM 0x70000016 +++#define SHT_MIPS_OPTSYM 0x70000017 +++#define SHT_MIPS_LOCSTR 0x70000018 +++#define SHT_MIPS_LINE 0x70000019 +++#define SHT_MIPS_RFDESC 0x7000001a +++#define SHT_MIPS_DELTASYM 0x7000001b +++#define SHT_MIPS_DELTAINST 0x7000001c +++#define SHT_MIPS_DELTACLASS 0x7000001d +++#define SHT_MIPS_DWARF 0x7000001e /* DWARF debugging information. */ +++#define SHT_MIPS_DELTADECL 0x7000001f +++#define SHT_MIPS_SYMBOL_LIB 0x70000020 +++#define SHT_MIPS_EVENTS 0x70000021 /* Event section. */ +++#define SHT_MIPS_TRANSLATE 0x70000022 +++#define SHT_MIPS_PIXIE 0x70000023 +++#define SHT_MIPS_XLATE 0x70000024 +++#define SHT_MIPS_XLATE_DEBUG 0x70000025 +++#define SHT_MIPS_WHIRL 0x70000026 +++#define SHT_MIPS_EH_REGION 0x70000027 +++#define SHT_MIPS_XLATE_OLD 0x70000028 +++#define SHT_MIPS_PDR_EXCEPTION 0x70000029 ++ ++ /* Legal values for sh_flags field of Elf32_Shdr. */ ++ ++-#define SHF_MIPS_GPREL 0x10000000 /* Must be part of global data area */ ++-#define SHF_MIPS_MERGE 0x20000000 ++-#define SHF_MIPS_ADDR 0x40000000 ++-#define SHF_MIPS_STRINGS 0x80000000 ++-#define SHF_MIPS_NOSTRIP 0x08000000 ++-#define SHF_MIPS_LOCAL 0x04000000 ++-#define SHF_MIPS_NAMES 0x02000000 ++-#define SHF_MIPS_NODUPE 0x01000000 +++#define SHF_MIPS_GPREL 0x10000000 /* Must be in global data area. */ +++#define SHF_MIPS_MERGE 0x20000000 +++#define SHF_MIPS_ADDR 0x40000000 +++#define SHF_MIPS_STRINGS 0x80000000 +++#define SHF_MIPS_NOSTRIP 0x08000000 +++#define SHF_MIPS_LOCAL 0x04000000 +++#define SHF_MIPS_NAMES 0x02000000 +++#define SHF_MIPS_NODUPE 0x01000000 ++ ++ ++ /* Symbol tables. */ ++@@ -1405,23 +1430,23 @@ typedef union ++ { ++ struct ++ { ++- Elf32_Word gt_current_g_value; /* -G value used for compilation */ ++- Elf32_Word gt_unused; /* Not used */ ++- } gt_header; /* First entry in section */ +++ Elf32_Word gt_current_g_value; /* -G value used for compilation. */ +++ Elf32_Word gt_unused; /* Not used. */ +++ } gt_header; /* First entry in section. */ ++ struct ++ { ++- Elf32_Word gt_g_value; /* If this value were used for -G */ ++- Elf32_Word gt_bytes; /* This many bytes would be used */ ++- } gt_entry; /* Subsequent entries in section */ +++ Elf32_Word gt_g_value; /* If this value were used for -G. */ +++ Elf32_Word gt_bytes; /* This many bytes would be used. */ +++ } gt_entry; /* Subsequent entries in section. */ ++ } Elf32_gptab; ++ ++ /* Entry found in sections of type SHT_MIPS_REGINFO. */ ++ ++ typedef struct ++ { ++- Elf32_Word ri_gprmask; /* General registers used */ ++- Elf32_Word ri_cprmask[4]; /* Coprocessor registers used */ ++- Elf32_Sword ri_gp_value; /* $gp register value */ +++ Elf32_Word ri_gprmask; /* General registers used. */ +++ Elf32_Word ri_cprmask[4]; /* Coprocessor registers used. */ +++ Elf32_Sword ri_gp_value; /* $gp register value. */ ++ } Elf32_RegInfo; ++ ++ /* Entries found in sections of type SHT_MIPS_OPTIONS. */ ++@@ -2013,9 +2038,6 @@ typedef Elf32_Addr Elf32_Conflict; ++ #define R_PPC_GOT_DTPREL16_HI 93 /* half16* (sym+add)@got@dtprel@h */ ++ #define R_PPC_GOT_DTPREL16_HA 94 /* half16* (sym+add)@got@dtprel@ha */ ++ ++-/* Keep this the last entry. */ ++-#define R_PPC_NUM 95 ++- ++ /* The remaining relocs are from the Embedded ELF ABI, and are not ++ in the SVR4 ELF ABI. */ ++ #define R_PPC_EMB_NADDR32 101 ++@@ -2043,11 +2065,14 @@ typedef Elf32_Addr Elf32_Conflict; ++ #define R_PPC_DIAB_RELSDA_HI 184 /* like EMB_RELSDA, but high 16 bit */ ++ #define R_PPC_DIAB_RELSDA_HA 185 /* like EMB_RELSDA, adjusted high 16 */ ++ +++/* GNU extension to support local ifunc. */ +++#define R_PPC_IRELATIVE 248 +++ ++ /* GNU relocs used in PIC code sequences. */ ++-#define R_PPC_REL16 249 /* word32 (sym-.) */ ++-#define R_PPC_REL16_LO 250 /* half16 (sym-.)@l */ ++-#define R_PPC_REL16_HI 251 /* half16 (sym-.)@h */ ++-#define R_PPC_REL16_HA 252 /* half16 (sym-.)@ha */ +++#define R_PPC_REL16 249 /* half16 (sym+add-.) */ +++#define R_PPC_REL16_LO 250 /* half16 (sym+add-.)@l */ +++#define R_PPC_REL16_HI 251 /* half16 (sym+add-.)@h */ +++#define R_PPC_REL16_HA 252 /* half16 (sym+add-.)@ha */ ++ ++ /* This is a phony reloc to handle any old fashioned TOC16 references ++ that may still be in object files. */ ++@@ -2168,76 +2193,261 @@ typedef Elf32_Addr Elf32_Conflict; ++ #define R_PPC64_DTPREL16_HIGHERA 104 /* half16 (sym+add)@dtprel@highera */ ++ #define R_PPC64_DTPREL16_HIGHEST 105 /* half16 (sym+add)@dtprel@highest */ ++ #define R_PPC64_DTPREL16_HIGHESTA 106 /* half16 (sym+add)@dtprel@highesta */ ++- ++-/* Keep this the last entry. */ ++-#define R_PPC64_NUM 107 +++#define R_PPC64_TLSGD 107 /* none (sym+add)@tlsgd */ +++#define R_PPC64_TLSLD 108 /* none (sym+add)@tlsld */ +++#define R_PPC64_TOCSAVE 109 /* none */ +++ +++/* Added when HA and HI relocs were changed to report overflows. */ +++#define R_PPC64_ADDR16_HIGH 110 +++#define R_PPC64_ADDR16_HIGHA 111 +++#define R_PPC64_TPREL16_HIGH 112 +++#define R_PPC64_TPREL16_HIGHA 113 +++#define R_PPC64_DTPREL16_HIGH 114 +++#define R_PPC64_DTPREL16_HIGHA 115 +++ +++/* GNU extension to support local ifunc. */ +++#define R_PPC64_JMP_IREL 247 +++#define R_PPC64_IRELATIVE 248 +++#define R_PPC64_REL16 249 /* half16 (sym+add-.) */ +++#define R_PPC64_REL16_LO 250 /* half16 (sym+add-.)@l */ +++#define R_PPC64_REL16_HI 251 /* half16 (sym+add-.)@h */ +++#define R_PPC64_REL16_HA 252 /* half16 (sym+add-.)@ha */ +++ +++/* e_flags bits specifying ABI. +++ 1 for original function descriptor using ABI, +++ 2 for revised ABI without function descriptors, +++ 0 for unspecified or not using any features affected by the differences. */ +++#define EF_PPC64_ABI 3 ++ ++ /* PowerPC64 specific values for the Dyn d_tag field. */ ++ #define DT_PPC64_GLINK (DT_LOPROC + 0) ++ #define DT_PPC64_OPD (DT_LOPROC + 1) ++ #define DT_PPC64_OPDSZ (DT_LOPROC + 2) +++#define DT_PPC64_OPT (DT_LOPROC + 3) ++ #define DT_PPC64_NUM 3 ++ +++/* PowerPC64 specific values for the DT_PPC64_OPT Dyn entry. */ +++#define PPC64_OPT_TLS 1 +++#define PPC64_OPT_MULTI_TOC 2 +++ +++/* PowerPC64 specific values for the Elf64_Sym st_other field. */ +++#define STO_PPC64_LOCAL_BIT 5 +++#define STO_PPC64_LOCAL_MASK (7 << STO_PPC64_LOCAL_BIT) +++#define PPC64_LOCAL_ENTRY_OFFSET(other) \ +++ (((1 << (((other) & STO_PPC64_LOCAL_MASK) >> STO_PPC64_LOCAL_BIT)) >> 2) << 2) +++ ++ ++ /* ARM specific declarations */ ++ ++ /* Processor specific flags for the ELF header e_flags field. */ ++-#define EF_ARM_RELEXEC 0x01 ++-#define EF_ARM_HASENTRY 0x02 ++-#define EF_ARM_INTERWORK 0x04 ++-#define EF_ARM_APCS_26 0x08 ++-#define EF_ARM_APCS_FLOAT 0x10 ++-#define EF_ARM_PIC 0x20 ++-#define EF_ARM_ALIGN8 0x40 /* 8-bit structure alignment is in use */ ++-#define EF_ARM_NEW_ABI 0x80 ++-#define EF_ARM_OLD_ABI 0x100 +++#define EF_ARM_RELEXEC 0x01 +++#define EF_ARM_HASENTRY 0x02 +++#define EF_ARM_INTERWORK 0x04 +++#define EF_ARM_APCS_26 0x08 +++#define EF_ARM_APCS_FLOAT 0x10 +++#define EF_ARM_PIC 0x20 +++#define EF_ARM_ALIGN8 0x40 /* 8-bit structure alignment is in use */ +++#define EF_ARM_NEW_ABI 0x80 +++#define EF_ARM_OLD_ABI 0x100 +++#define EF_ARM_SOFT_FLOAT 0x200 +++#define EF_ARM_VFP_FLOAT 0x400 +++#define EF_ARM_MAVERICK_FLOAT 0x800 +++ +++#define EF_ARM_ABI_FLOAT_SOFT 0x200 /* NB conflicts with EF_ARM_SOFT_FLOAT */ +++#define EF_ARM_ABI_FLOAT_HARD 0x400 /* NB conflicts with EF_ARM_VFP_FLOAT */ +++ ++ ++ /* Other constants defined in the ARM ELF spec. version B-01. */ ++ /* NB. These conflict with values defined above. */ ++ #define EF_ARM_SYMSARESORTED 0x04 ++-#define EF_ARM_DYNSYMSUSESEGIDX 0x08 +++#define EF_ARM_DYNSYMSUSESEGIDX 0x08 ++ #define EF_ARM_MAPSYMSFIRST 0x10 ++ #define EF_ARM_EABIMASK 0XFF000000 ++ ++-#define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK) ++-#define EF_ARM_EABI_UNKNOWN 0x00000000 ++-#define EF_ARM_EABI_VER1 0x01000000 ++-#define EF_ARM_EABI_VER2 0x02000000 +++/* Constants defined in AAELF. */ +++#define EF_ARM_BE8 0x00800000 +++#define EF_ARM_LE8 0x00400000 +++ +++#define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK) +++#define EF_ARM_EABI_UNKNOWN 0x00000000 +++#define EF_ARM_EABI_VER1 0x01000000 +++#define EF_ARM_EABI_VER2 0x02000000 +++#define EF_ARM_EABI_VER3 0x03000000 +++#define EF_ARM_EABI_VER4 0x04000000 +++#define EF_ARM_EABI_VER5 0x05000000 ++ ++-/* Additional symbol types for Thumb */ ++-#define STT_ARM_TFUNC 0xd +++/* Additional symbol types for Thumb. */ +++#define STT_ARM_TFUNC STT_LOPROC /* A Thumb function. */ +++#define STT_ARM_16BIT STT_HIPROC /* A Thumb label. */ ++ ++ /* ARM-specific values for sh_flags */ ++-#define SHF_ARM_ENTRYSECT 0x10000000 /* Section contains an entry point */ ++-#define SHF_ARM_COMDEF 0x80000000 /* Section may be multiply defined ++- in the input to a link step */ +++#define SHF_ARM_ENTRYSECT 0x10000000 /* Section contains an entry point */ +++#define SHF_ARM_COMDEF 0x80000000 /* Section may be multiply defined +++ in the input to a link step. */ ++ ++ /* ARM-specific program header flags */ ++-#define PF_ARM_SB 0x10000000 /* Segment contains the location ++- addressed by the static base */ +++#define PF_ARM_SB 0x10000000 /* Segment contains the location +++ addressed by the static base. */ +++#define PF_ARM_PI 0x20000000 /* Position-independent segment. */ +++#define PF_ARM_ABS 0x40000000 /* Absolute segment. */ ++ ++ /* Processor specific values for the Phdr p_type field. */ ++-#define PT_ARM_EXIDX 0x70000001 /* .ARM.exidx segment */ +++#define PT_ARM_EXIDX (PT_LOPROC + 1) /* ARM unwind segment. */ +++ +++/* Processor specific values for the Shdr sh_type field. */ +++#define SHT_ARM_EXIDX (SHT_LOPROC + 1) /* ARM unwind section. */ +++#define SHT_ARM_PREEMPTMAP (SHT_LOPROC + 2) /* Preemption details. */ +++#define SHT_ARM_ATTRIBUTES (SHT_LOPROC + 3) /* ARM attributes section. */ +++ +++ +++/* AArch64 relocs. */ +++ +++#define R_AARCH64_NONE 0 /* No relocation. */ +++#define R_AARCH64_ABS64 257 /* Direct 64 bit. */ +++#define R_AARCH64_ABS32 258 /* Direct 32 bit. */ +++#define R_AARCH64_ABS16 259 /* Direct 16-bit. */ +++#define R_AARCH64_PREL64 260 /* PC-relative 64-bit. */ +++#define R_AARCH64_PREL32 261 /* PC-relative 32-bit. */ +++#define R_AARCH64_PREL16 262 /* PC-relative 16-bit. */ +++#define R_AARCH64_MOVW_UABS_G0 263 /* Dir. MOVZ imm. from bits 15:0. */ +++#define R_AARCH64_MOVW_UABS_G0_NC 264 /* Likewise for MOVK; no check. */ +++#define R_AARCH64_MOVW_UABS_G1 265 /* Dir. MOVZ imm. from bits 31:16. */ +++#define R_AARCH64_MOVW_UABS_G1_NC 266 /* Likewise for MOVK; no check. */ +++#define R_AARCH64_MOVW_UABS_G2 267 /* Dir. MOVZ imm. from bits 47:32. */ +++#define R_AARCH64_MOVW_UABS_G2_NC 268 /* Likewise for MOVK; no check. */ +++#define R_AARCH64_MOVW_UABS_G3 269 /* Dir. MOV{K,Z} imm. from 63:48. */ +++#define R_AARCH64_MOVW_SABS_G0 270 /* Dir. MOV{N,Z} imm. from 15:0. */ +++#define R_AARCH64_MOVW_SABS_G1 271 /* Dir. MOV{N,Z} imm. from 31:16. */ +++#define R_AARCH64_MOVW_SABS_G2 272 /* Dir. MOV{N,Z} imm. from 47:32. */ +++#define R_AARCH64_LD_PREL_LO19 273 /* PC-rel. LD imm. from bits 20:2. */ +++#define R_AARCH64_ADR_PREL_LO21 274 /* PC-rel. ADR imm. from bits 20:0. */ +++#define R_AARCH64_ADR_PREL_PG_HI21 275 /* Page-rel. ADRP imm. from 32:12. */ +++#define R_AARCH64_ADR_PREL_PG_HI21_NC 276 /* Likewise; no overflow check. */ +++#define R_AARCH64_ADD_ABS_LO12_NC 277 /* Dir. ADD imm. from bits 11:0. */ +++#define R_AARCH64_LDST8_ABS_LO12_NC 278 /* Likewise for LD/ST; no check. */ +++#define R_AARCH64_TSTBR14 279 /* PC-rel. TBZ/TBNZ imm. from 15:2. */ +++#define R_AARCH64_CONDBR19 280 /* PC-rel. cond. br. imm. from 20:2. */ +++#define R_AARCH64_JUMP26 282 /* PC-rel. B imm. from bits 27:2. */ +++#define R_AARCH64_CALL26 283 /* Likewise for CALL. */ +++#define R_AARCH64_LDST16_ABS_LO12_NC 284 /* Dir. ADD imm. from bits 11:1. */ +++#define R_AARCH64_LDST32_ABS_LO12_NC 285 /* Likewise for bits 11:2. */ +++#define R_AARCH64_LDST64_ABS_LO12_NC 286 /* Likewise for bits 11:3. */ +++#define R_AARCH64_MOVW_PREL_G0 287 /* PC-rel. MOV{N,Z} imm. from 15:0. */ +++#define R_AARCH64_MOVW_PREL_G0_NC 288 /* Likewise for MOVK; no check. */ +++#define R_AARCH64_MOVW_PREL_G1 289 /* PC-rel. MOV{N,Z} imm. from 31:16. */ +++#define R_AARCH64_MOVW_PREL_G1_NC 290 /* Likewise for MOVK; no check. */ +++#define R_AARCH64_MOVW_PREL_G2 291 /* PC-rel. MOV{N,Z} imm. from 47:32. */ +++#define R_AARCH64_MOVW_PREL_G2_NC 292 /* Likewise for MOVK; no check. */ +++#define R_AARCH64_MOVW_PREL_G3 293 /* PC-rel. MOV{N,Z} imm. from 63:48. */ +++#define R_AARCH64_LDST128_ABS_LO12_NC 299 /* Dir. ADD imm. from bits 11:4. */ +++#define R_AARCH64_MOVW_GOTOFF_G0 300 /* GOT-rel. off. MOV{N,Z} imm. 15:0. */ +++#define R_AARCH64_MOVW_GOTOFF_G0_NC 301 /* Likewise for MOVK; no check. */ +++#define R_AARCH64_MOVW_GOTOFF_G1 302 /* GOT-rel. o. MOV{N,Z} imm. 31:16. */ +++#define R_AARCH64_MOVW_GOTOFF_G1_NC 303 /* Likewise for MOVK; no check. */ +++#define R_AARCH64_MOVW_GOTOFF_G2 304 /* GOT-rel. o. MOV{N,Z} imm. 47:32. */ +++#define R_AARCH64_MOVW_GOTOFF_G2_NC 305 /* Likewise for MOVK; no check. */ +++#define R_AARCH64_MOVW_GOTOFF_G3 306 /* GOT-rel. o. MOV{N,Z} imm. 63:48. */ +++#define R_AARCH64_GOTREL64 307 /* GOT-relative 64-bit. */ +++#define R_AARCH64_GOTREL32 308 /* GOT-relative 32-bit. */ +++#define R_AARCH64_GOT_LD_PREL19 309 /* PC-rel. GOT off. load imm. 20:2. */ +++#define R_AARCH64_LD64_GOTOFF_LO15 310 /* GOT-rel. off. LD/ST imm. 14:3. */ +++#define R_AARCH64_ADR_GOT_PAGE 311 /* P-page-rel. GOT off. ADRP 32:12. */ +++#define R_AARCH64_LD64_GOT_LO12_NC 312 /* Dir. GOT off. LD/ST imm. 11:3. */ +++#define R_AARCH64_LD64_GOTPAGE_LO15 313 /* GOT-page-rel. GOT off. LD/ST 14:3 */ +++#define R_AARCH64_TLSGD_ADR_PREL21 512 /* PC-relative ADR imm. 20:0. */ +++#define R_AARCH64_TLSGD_ADR_PAGE21 513 /* page-rel. ADRP imm. 32:12. */ +++#define R_AARCH64_TLSGD_ADD_LO12_NC 514 /* direct ADD imm. from 11:0. */ +++#define R_AARCH64_TLSGD_MOVW_G1 515 /* GOT-rel. MOV{N,Z} 31:16. */ +++#define R_AARCH64_TLSGD_MOVW_G0_NC 516 /* GOT-rel. MOVK imm. 15:0. */ +++#define R_AARCH64_TLSLD_ADR_PREL21 517 /* Like 512; local dynamic model. */ +++#define R_AARCH64_TLSLD_ADR_PAGE21 518 /* Like 513; local dynamic model. */ +++#define R_AARCH64_TLSLD_ADD_LO12_NC 519 /* Like 514; local dynamic model. */ +++#define R_AARCH64_TLSLD_MOVW_G1 520 /* Like 515; local dynamic model. */ +++#define R_AARCH64_TLSLD_MOVW_G0_NC 521 /* Like 516; local dynamic model. */ +++#define R_AARCH64_TLSLD_LD_PREL19 522 /* TLS PC-rel. load imm. 20:2. */ +++#define R_AARCH64_TLSLD_MOVW_DTPREL_G2 523 /* TLS DTP-rel. MOV{N,Z} 47:32. */ +++#define R_AARCH64_TLSLD_MOVW_DTPREL_G1 524 /* TLS DTP-rel. MOV{N,Z} 31:16. */ +++#define R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC 525 /* Likewise; MOVK; no check. */ +++#define R_AARCH64_TLSLD_MOVW_DTPREL_G0 526 /* TLS DTP-rel. MOV{N,Z} 15:0. */ +++#define R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC 527 /* Likewise; MOVK; no check. */ +++#define R_AARCH64_TLSLD_ADD_DTPREL_HI12 528 /* DTP-rel. ADD imm. from 23:12. */ +++#define R_AARCH64_TLSLD_ADD_DTPREL_LO12 529 /* DTP-rel. ADD imm. from 11:0. */ +++#define R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC 530 /* Likewise; no ovfl. check. */ +++#define R_AARCH64_TLSLD_LDST8_DTPREL_LO12 531 /* DTP-rel. LD/ST imm. 11:0. */ +++#define R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC 532 /* Likewise; no check. */ +++#define R_AARCH64_TLSLD_LDST16_DTPREL_LO12 533 /* DTP-rel. LD/ST imm. 11:1. */ +++#define R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC 534 /* Likewise; no check. */ +++#define R_AARCH64_TLSLD_LDST32_DTPREL_LO12 535 /* DTP-rel. LD/ST imm. 11:2. */ +++#define R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC 536 /* Likewise; no check. */ +++#define R_AARCH64_TLSLD_LDST64_DTPREL_LO12 537 /* DTP-rel. LD/ST imm. 11:3. */ +++#define R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC 538 /* Likewise; no check. */ +++#define R_AARCH64_TLSIE_MOVW_GOTTPREL_G1 539 /* GOT-rel. MOV{N,Z} 31:16. */ +++#define R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC 540 /* GOT-rel. MOVK 15:0. */ +++#define R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 541 /* Page-rel. ADRP 32:12. */ +++#define R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC 542 /* Direct LD off. 11:3. */ +++#define R_AARCH64_TLSIE_LD_GOTTPREL_PREL19 543 /* PC-rel. load imm. 20:2. */ +++#define R_AARCH64_TLSLE_MOVW_TPREL_G2 544 /* TLS TP-rel. MOV{N,Z} 47:32. */ +++#define R_AARCH64_TLSLE_MOVW_TPREL_G1 545 /* TLS TP-rel. MOV{N,Z} 31:16. */ +++#define R_AARCH64_TLSLE_MOVW_TPREL_G1_NC 546 /* Likewise; MOVK; no check. */ +++#define R_AARCH64_TLSLE_MOVW_TPREL_G0 547 /* TLS TP-rel. MOV{N,Z} 15:0. */ +++#define R_AARCH64_TLSLE_MOVW_TPREL_G0_NC 548 /* Likewise; MOVK; no check. */ +++#define R_AARCH64_TLSLE_ADD_TPREL_HI12 549 /* TP-rel. ADD imm. 23:12. */ +++#define R_AARCH64_TLSLE_ADD_TPREL_LO12 550 /* TP-rel. ADD imm. 11:0. */ +++#define R_AARCH64_TLSLE_ADD_TPREL_LO12_NC 551 /* Likewise; no ovfl. check. */ +++#define R_AARCH64_TLSLE_LDST8_TPREL_LO12 552 /* TP-rel. LD/ST off. 11:0. */ +++#define R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC 553 /* Likewise; no ovfl. check. */ +++#define R_AARCH64_TLSLE_LDST16_TPREL_LO12 554 /* TP-rel. LD/ST off. 11:1. */ +++#define R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC 555 /* Likewise; no check. */ +++#define R_AARCH64_TLSLE_LDST32_TPREL_LO12 556 /* TP-rel. LD/ST off. 11:2. */ +++#define R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC 557 /* Likewise; no check. */ +++#define R_AARCH64_TLSLE_LDST64_TPREL_LO12 558 /* TP-rel. LD/ST off. 11:3. */ +++#define R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC 559 /* Likewise; no check. */ +++#define R_AARCH64_TLSDESC_LD_PREL19 560 /* PC-rel. load immediate 20:2. */ +++#define R_AARCH64_TLSDESC_ADR_PREL21 561 /* PC-rel. ADR immediate 20:0. */ +++#define R_AARCH64_TLSDESC_ADR_PAGE21 562 /* Page-rel. ADRP imm. 32:12. */ +++#define R_AARCH64_TLSDESC_LD64_LO12 563 /* Direct LD off. from 11:3. */ +++#define R_AARCH64_TLSDESC_ADD_LO12 564 /* Direct ADD imm. from 11:0. */ +++#define R_AARCH64_TLSDESC_OFF_G1 565 /* GOT-rel. MOV{N,Z} imm. 31:16. */ +++#define R_AARCH64_TLSDESC_OFF_G0_NC 566 /* GOT-rel. MOVK imm. 15:0; no ck. */ +++#define R_AARCH64_TLSDESC_LDR 567 /* Relax LDR. */ +++#define R_AARCH64_TLSDESC_ADD 568 /* Relax ADD. */ +++#define R_AARCH64_TLSDESC_CALL 569 /* Relax BLR. */ +++#define R_AARCH64_TLSLE_LDST128_TPREL_LO12 570 /* TP-rel. LD/ST off. 11:4. */ +++#define R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC 571 /* Likewise; no check. */ +++#define R_AARCH64_TLSLD_LDST128_DTPREL_LO12 572 /* DTP-rel. LD/ST imm. 11:4. */ +++#define R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC 573 /* Likewise; no check. */ +++#define R_AARCH64_COPY 1024 /* Copy symbol at runtime. */ +++#define R_AARCH64_GLOB_DAT 1025 /* Create GOT entry. */ +++#define R_AARCH64_JUMP_SLOT 1026 /* Create PLT entry. */ +++#define R_AARCH64_RELATIVE 1027 /* Adjust by program base. */ +++#define R_AARCH64_TLS_DTPMOD64 1028 /* Module number, 64 bit. */ +++#define R_AARCH64_TLS_DTPREL64 1029 /* Module-relative offset, 64 bit. */ +++#define R_AARCH64_TLS_TPREL64 1030 /* TP-relative offset, 64 bit. */ +++#define R_AARCH64_TLSDESC 1031 /* TLS Descriptor. */ +++#define R_AARCH64_IRELATIVE 1032 /* STT_GNU_IFUNC relocation. */ ++ ++ /* ARM relocs. */ ++ ++ #define R_ARM_NONE 0 /* No reloc */ ++-#define R_ARM_PC24 1 /* PC relative 26 bit branch */ +++#define R_ARM_PC24 1 /* Deprecated PC relative 26 +++ bit branch. */ ++ #define R_ARM_ABS32 2 /* Direct 32 bit */ ++ #define R_ARM_REL32 3 /* PC relative 32 bit */ ++ #define R_ARM_PC13 4 ++ #define R_ARM_ABS16 5 /* Direct 16 bit */ ++ #define R_ARM_ABS12 6 /* Direct 12 bit */ ++-#define R_ARM_THM_ABS5 7 +++#define R_ARM_THM_ABS5 7 /* Direct & 0x7C (LDR, STR). */ ++ #define R_ARM_ABS8 8 /* Direct 8 bit */ ++ #define R_ARM_SBREL32 9 ++-#define R_ARM_THM_PC22 10 ++-#define R_ARM_THM_PC8 11 +++#define R_ARM_THM_PC22 10 /* PC relative 24 bit (Thumb32 BL). */ +++#define R_ARM_THM_PC8 11 /* PC relative & 0x3FC +++ (Thumb16 LDR, ADD, ADR). */ ++ #define R_ARM_AMP_VCALL9 12 ++-#define R_ARM_SWI24 13 ++-#define R_ARM_THM_SWI8 14 ++-#define R_ARM_XPC25 15 ++-#define R_ARM_THM_XPC22 16 +++#define R_ARM_SWI24 13 /* Obsolete static relocation. */ +++#define R_ARM_TLS_DESC 13 /* Dynamic relocation. */ +++#define R_ARM_THM_SWI8 14 /* Reserved. */ +++#define R_ARM_XPC25 15 /* Reserved. */ +++#define R_ARM_THM_XPC22 16 /* Reserved. */ ++ #define R_ARM_TLS_DTPMOD32 17 /* ID of module containing symbol */ ++ #define R_ARM_TLS_DTPOFF32 18 /* Offset in TLS block */ ++ #define R_ARM_TLS_TPOFF32 19 /* Offset in static TLS block */ ++@@ -2248,17 +2458,109 @@ typedef Elf32_Addr Elf32_Conflict; ++ #define R_ARM_GOTOFF 24 /* 32 bit offset to GOT */ ++ #define R_ARM_GOTPC 25 /* 32 bit PC relative offset to GOT */ ++ #define R_ARM_GOT32 26 /* 32 bit GOT entry */ ++-#define R_ARM_PLT32 27 /* 32 bit PLT address */ ++-#define R_ARM_ALU_PCREL_7_0 32 ++-#define R_ARM_ALU_PCREL_15_8 33 ++-#define R_ARM_ALU_PCREL_23_15 34 ++-#define R_ARM_LDR_SBREL_11_0 35 ++-#define R_ARM_ALU_SBREL_19_12 36 ++-#define R_ARM_ALU_SBREL_27_20 37 +++#define R_ARM_PLT32 27 /* Deprecated, 32 bit PLT address. */ +++#define R_ARM_CALL 28 /* PC relative 24 bit (BL, BLX). */ +++#define R_ARM_JUMP24 29 /* PC relative 24 bit +++ (B, BL). */ +++#define R_ARM_THM_JUMP24 30 /* PC relative 24 bit (Thumb32 B.W). */ +++#define R_ARM_BASE_ABS 31 /* Adjust by program base. */ +++#define R_ARM_ALU_PCREL_7_0 32 /* Obsolete. */ +++#define R_ARM_ALU_PCREL_15_8 33 /* Obsolete. */ +++#define R_ARM_ALU_PCREL_23_15 34 /* Obsolete. */ +++#define R_ARM_LDR_SBREL_11_0 35 /* Deprecated, prog. base relative. */ +++#define R_ARM_ALU_SBREL_19_12 36 /* Deprecated, prog. base relative. */ +++#define R_ARM_ALU_SBREL_27_20 37 /* Deprecated, prog. base relative. */ +++#define R_ARM_TARGET1 38 +++#define R_ARM_SBREL31 39 /* Program base relative. */ +++#define R_ARM_V4BX 40 +++#define R_ARM_TARGET2 41 +++#define R_ARM_PREL31 42 /* 32 bit PC relative. */ +++#define R_ARM_MOVW_ABS_NC 43 /* Direct 16-bit (MOVW). */ +++#define R_ARM_MOVT_ABS 44 /* Direct high 16-bit (MOVT). */ +++#define R_ARM_MOVW_PREL_NC 45 /* PC relative 16-bit (MOVW). */ +++#define R_ARM_MOVT_PREL 46 /* PC relative (MOVT). */ +++#define R_ARM_THM_MOVW_ABS_NC 47 /* Direct 16 bit (Thumb32 MOVW). */ +++#define R_ARM_THM_MOVT_ABS 48 /* Direct high 16 bit +++ (Thumb32 MOVT). */ +++#define R_ARM_THM_MOVW_PREL_NC 49 /* PC relative 16 bit +++ (Thumb32 MOVW). */ +++#define R_ARM_THM_MOVT_PREL 50 /* PC relative high 16 bit +++ (Thumb32 MOVT). */ +++#define R_ARM_THM_JUMP19 51 /* PC relative 20 bit +++ (Thumb32 B.W). */ +++#define R_ARM_THM_JUMP6 52 /* PC relative X & 0x7E +++ (Thumb16 CBZ, CBNZ). */ +++#define R_ARM_THM_ALU_PREL_11_0 53 /* PC relative 12 bit +++ (Thumb32 ADR.W). */ +++#define R_ARM_THM_PC12 54 /* PC relative 12 bit +++ (Thumb32 LDR{D,SB,H,SH}). */ +++#define R_ARM_ABS32_NOI 55 /* Direct 32-bit. */ +++#define R_ARM_REL32_NOI 56 /* PC relative 32-bit. */ +++#define R_ARM_ALU_PC_G0_NC 57 /* PC relative (ADD, SUB). */ +++#define R_ARM_ALU_PC_G0 58 /* PC relative (ADD, SUB). */ +++#define R_ARM_ALU_PC_G1_NC 59 /* PC relative (ADD, SUB). */ +++#define R_ARM_ALU_PC_G1 60 /* PC relative (ADD, SUB). */ +++#define R_ARM_ALU_PC_G2 61 /* PC relative (ADD, SUB). */ +++#define R_ARM_LDR_PC_G1 62 /* PC relative (LDR,STR,LDRB,STRB). */ +++#define R_ARM_LDR_PC_G2 63 /* PC relative (LDR,STR,LDRB,STRB). */ +++#define R_ARM_LDRS_PC_G0 64 /* PC relative (STR{D,H}, +++ LDR{D,SB,H,SH}). */ +++#define R_ARM_LDRS_PC_G1 65 /* PC relative (STR{D,H}, +++ LDR{D,SB,H,SH}). */ +++#define R_ARM_LDRS_PC_G2 66 /* PC relative (STR{D,H}, +++ LDR{D,SB,H,SH}). */ +++#define R_ARM_LDC_PC_G0 67 /* PC relative (LDC, STC). */ +++#define R_ARM_LDC_PC_G1 68 /* PC relative (LDC, STC). */ +++#define R_ARM_LDC_PC_G2 69 /* PC relative (LDC, STC). */ +++#define R_ARM_ALU_SB_G0_NC 70 /* Program base relative (ADD,SUB). */ +++#define R_ARM_ALU_SB_G0 71 /* Program base relative (ADD,SUB). */ +++#define R_ARM_ALU_SB_G1_NC 72 /* Program base relative (ADD,SUB). */ +++#define R_ARM_ALU_SB_G1 73 /* Program base relative (ADD,SUB). */ +++#define R_ARM_ALU_SB_G2 74 /* Program base relative (ADD,SUB). */ +++#define R_ARM_LDR_SB_G0 75 /* Program base relative (LDR, +++ STR, LDRB, STRB). */ +++#define R_ARM_LDR_SB_G1 76 /* Program base relative +++ (LDR, STR, LDRB, STRB). */ +++#define R_ARM_LDR_SB_G2 77 /* Program base relative +++ (LDR, STR, LDRB, STRB). */ +++#define R_ARM_LDRS_SB_G0 78 /* Program base relative +++ (LDR, STR, LDRB, STRB). */ +++#define R_ARM_LDRS_SB_G1 79 /* Program base relative +++ (LDR, STR, LDRB, STRB). */ +++#define R_ARM_LDRS_SB_G2 80 /* Program base relative +++ (LDR, STR, LDRB, STRB). */ +++#define R_ARM_LDC_SB_G0 81 /* Program base relative (LDC,STC). */ +++#define R_ARM_LDC_SB_G1 82 /* Program base relative (LDC,STC). */ +++#define R_ARM_LDC_SB_G2 83 /* Program base relative (LDC,STC). */ +++#define R_ARM_MOVW_BREL_NC 84 /* Program base relative 16 +++ bit (MOVW). */ +++#define R_ARM_MOVT_BREL 85 /* Program base relative high +++ 16 bit (MOVT). */ +++#define R_ARM_MOVW_BREL 86 /* Program base relative 16 +++ bit (MOVW). */ +++#define R_ARM_THM_MOVW_BREL_NC 87 /* Program base relative 16 +++ bit (Thumb32 MOVW). */ +++#define R_ARM_THM_MOVT_BREL 88 /* Program base relative high +++ 16 bit (Thumb32 MOVT). */ +++#define R_ARM_THM_MOVW_BREL 89 /* Program base relative 16 +++ bit (Thumb32 MOVW). */ +++#define R_ARM_TLS_GOTDESC 90 +++#define R_ARM_TLS_CALL 91 +++#define R_ARM_TLS_DESCSEQ 92 /* TLS relaxation. */ +++#define R_ARM_THM_TLS_CALL 93 +++#define R_ARM_PLT32_ABS 94 +++#define R_ARM_GOT_ABS 95 /* GOT entry. */ +++#define R_ARM_GOT_PREL 96 /* PC relative GOT entry. */ +++#define R_ARM_GOT_BREL12 97 /* GOT entry relative to GOT +++ origin (LDR). */ +++#define R_ARM_GOTOFF12 98 /* 12 bit, GOT entry relative +++ to GOT origin (LDR, STR). */ +++#define R_ARM_GOTRELAX 99 ++ #define R_ARM_GNU_VTENTRY 100 ++ #define R_ARM_GNU_VTINHERIT 101 ++-#define R_ARM_THM_PC11 102 /* thumb unconditional branch */ ++-#define R_ARM_THM_PC9 103 /* thumb conditional branch */ +++#define R_ARM_THM_PC11 102 /* PC relative & 0xFFE (Thumb16 B). */ +++#define R_ARM_THM_PC9 103 /* PC relative & 0x1FE +++ (Thumb16 B/B). */ ++ #define R_ARM_TLS_GD32 104 /* PC-rel 32 bit for global dynamic ++ thread local data */ ++ #define R_ARM_TLS_LDM32 105 /* PC-rel 32 bit for local dynamic ++@@ -2269,6 +2571,19 @@ typedef Elf32_Addr Elf32_Conflict; ++ static TLS block offset */ ++ #define R_ARM_TLS_LE32 108 /* 32 bit offset relative to static ++ TLS block */ +++#define R_ARM_TLS_LDO12 109 /* 12 bit relative to TLS +++ block (LDR, STR). */ +++#define R_ARM_TLS_LE12 110 /* 12 bit relative to static +++ TLS block (LDR, STR). */ +++#define R_ARM_TLS_IE12GP 111 /* 12 bit GOT entry relative +++ to GOT origin (LDR). */ +++#define R_ARM_ME_TOO 128 /* Obsolete. */ +++#define R_ARM_THM_TLS_DESCSEQ 129 +++#define R_ARM_THM_TLS_DESCSEQ16 129 +++#define R_ARM_THM_TLS_DESCSEQ32 130 +++#define R_ARM_THM_GOT_BREL12 131 /* GOT entry relative to GOT +++ origin, 12 bit (Thumb32 LDR). */ +++#define R_ARM_IRELATIVE 160 ++ #define R_ARM_RXPC25 249 ++ #define R_ARM_RSBREL32 250 ++ #define R_ARM_THM_RPC22 251 ++@@ -2393,6 +2708,30 @@ typedef Elf32_Addr Elf32_Conflict; ++ ++ /* SH specific declarations */ ++ +++/* Processor specific flags for the ELF header e_flags field. */ +++#define EF_SH_MACH_MASK 0x1f +++#define EF_SH_UNKNOWN 0x0 +++#define EF_SH1 0x1 +++#define EF_SH2 0x2 +++#define EF_SH3 0x3 +++#define EF_SH_DSP 0x4 +++#define EF_SH3_DSP 0x5 +++#define EF_SH4AL_DSP 0x6 +++#define EF_SH3E 0x8 +++#define EF_SH4 0x9 +++#define EF_SH2E 0xb +++#define EF_SH4A 0xc +++#define EF_SH2A 0xd +++#define EF_SH4_NOFPU 0x10 +++#define EF_SH4A_NOFPU 0x11 +++#define EF_SH4_NOMMU_NOFPU 0x12 +++#define EF_SH2A_NOFPU 0x13 +++#define EF_SH3_NOMMU 0x14 +++#define EF_SH2A_SH4_NOFPU 0x15 +++#define EF_SH2A_SH3_NOFPU 0x16 +++#define EF_SH2A_SH4 0x17 +++#define EF_SH2A_SH3E 0x18 +++ ++ /* SH relocs. */ ++ #define R_SH_NONE 0 ++ #define R_SH_DIR32 1 ++@@ -2434,6 +2773,12 @@ typedef Elf32_Addr Elf32_Conflict; ++ /* Keep this the last entry. */ ++ #define R_SH_NUM 256 ++ +++/* S/390 specific definitions. */ +++ +++/* Valid values for the e_flags field. */ +++ +++#define EF_S390_HIGH_GPRS 0x00000001 /* High GPRs kernel facility needed. */ +++ ++ /* Additional s390 relocs */ ++ ++ #define R_390_NONE 0 /* No reloc. */ ++@@ -2515,8 +2860,9 @@ typedef Elf32_Addr Elf32_Conflict; ++ #define R_390_GOTPLT20 59 /* 20 bit offset to jump slot. */ ++ #define R_390_TLS_GOTIE20 60 /* 20 bit GOT offset for static TLS ++ block offset. */ +++#define R_390_IRELATIVE 61 /* STT_GNU_IFUNC relocation. */ ++ /* Keep this the last entry. */ ++-#define R_390_NUM 61 +++#define R_390_NUM 62 ++ ++ ++ /* CRIS relocations. */ ++@@ -2577,13 +2923,23 @@ typedef Elf32_Addr Elf32_Conflict; ++ #define R_X86_64_GOTOFF64 25 /* 64 bit offset to GOT */ ++ #define R_X86_64_GOTPC32 26 /* 32 bit signed pc relative ++ offset to GOT */ ++-/* 27 .. 33 */ +++#define R_X86_64_GOT64 27 /* 64-bit GOT entry offset */ +++#define R_X86_64_GOTPCREL64 28 /* 64-bit PC relative offset +++ to GOT entry */ +++#define R_X86_64_GOTPC64 29 /* 64-bit PC relative offset to GOT */ +++#define R_X86_64_GOTPLT64 30 /* like GOT64, says PLT entry needed */ +++#define R_X86_64_PLTOFF64 31 /* 64-bit GOT relative offset +++ to PLT entry */ +++#define R_X86_64_SIZE32 32 /* Size of symbol plus 32-bit addend */ +++#define R_X86_64_SIZE64 33 /* Size of symbol plus 64-bit addend */ ++ #define R_X86_64_GOTPC32_TLSDESC 34 /* GOT offset for TLS descriptor. */ ++ #define R_X86_64_TLSDESC_CALL 35 /* Marker for call through TLS ++ descriptor. */ ++ #define R_X86_64_TLSDESC 36 /* TLS descriptor. */ +++#define R_X86_64_IRELATIVE 37 /* Adjust indirectly by program base */ +++#define R_X86_64_RELATIVE64 38 /* 64-bit adjust by program base */ ++ ++-#define R_X86_64_NUM 37 +++#define R_X86_64_NUM 39 ++ ++ ++ /* AM33 relocations. */ ++@@ -2611,8 +2967,23 @@ typedef Elf32_Addr Elf32_Conflict; ++ #define R_MN10300_GLOB_DAT 21 /* Create GOT entry. */ ++ #define R_MN10300_JMP_SLOT 22 /* Create PLT entry. */ ++ #define R_MN10300_RELATIVE 23 /* Adjust by program base. */ ++- ++-#define R_MN10300_NUM 24 +++#define R_MN10300_TLS_GD 24 /* 32-bit offset for global dynamic. */ +++#define R_MN10300_TLS_LD 25 /* 32-bit offset for local dynamic. */ +++#define R_MN10300_TLS_LDO 26 /* Module-relative offset. */ +++#define R_MN10300_TLS_GOTIE 27 /* GOT offset for static TLS block +++ offset. */ +++#define R_MN10300_TLS_IE 28 /* GOT address for static TLS block +++ offset. */ +++#define R_MN10300_TLS_LE 29 /* Offset relative to static TLS +++ block. */ +++#define R_MN10300_TLS_DTPMOD 30 /* ID of module containing symbol. */ +++#define R_MN10300_TLS_DTPOFF 31 /* Offset in module TLS block. */ +++#define R_MN10300_TLS_TPOFF 32 /* Offset in static TLS block. */ +++#define R_MN10300_SYM_DIFF 33 /* Adjustment for next reloc as needed +++ by linker relaxation. */ +++#define R_MN10300_ALIGN 34 /* Alignment requirement for linker +++ relaxation. */ +++#define R_MN10300_NUM 35 ++ ++ ++ /* M32R relocs. */ ++@@ -2670,5 +3041,264 @@ typedef Elf32_Addr Elf32_Conflict; ++ #define R_M32R_GOTOFF_LO 64 /* Low 16 bit offset to GOT */ ++ #define R_M32R_NUM 256 /* Keep this the last entry. */ ++ +++/* MicroBlaze relocations */ +++#define R_MICROBLAZE_NONE 0 /* No reloc. */ +++#define R_MICROBLAZE_32 1 /* Direct 32 bit. */ +++#define R_MICROBLAZE_32_PCREL 2 /* PC relative 32 bit. */ +++#define R_MICROBLAZE_64_PCREL 3 /* PC relative 64 bit. */ +++#define R_MICROBLAZE_32_PCREL_LO 4 /* Low 16 bits of PCREL32. */ +++#define R_MICROBLAZE_64 5 /* Direct 64 bit. */ +++#define R_MICROBLAZE_32_LO 6 /* Low 16 bit. */ +++#define R_MICROBLAZE_SRO32 7 /* Read-only small data area. */ +++#define R_MICROBLAZE_SRW32 8 /* Read-write small data area. */ +++#define R_MICROBLAZE_64_NONE 9 /* No reloc. */ +++#define R_MICROBLAZE_32_SYM_OP_SYM 10 /* Symbol Op Symbol relocation. */ +++#define R_MICROBLAZE_GNU_VTINHERIT 11 /* GNU C++ vtable hierarchy. */ +++#define R_MICROBLAZE_GNU_VTENTRY 12 /* GNU C++ vtable member usage. */ +++#define R_MICROBLAZE_GOTPC_64 13 /* PC-relative GOT offset. */ +++#define R_MICROBLAZE_GOT_64 14 /* GOT entry offset. */ +++#define R_MICROBLAZE_PLT_64 15 /* PLT offset (PC-relative). */ +++#define R_MICROBLAZE_REL 16 /* Adjust by program base. */ +++#define R_MICROBLAZE_JUMP_SLOT 17 /* Create PLT entry. */ +++#define R_MICROBLAZE_GLOB_DAT 18 /* Create GOT entry. */ +++#define R_MICROBLAZE_GOTOFF_64 19 /* 64 bit offset to GOT. */ +++#define R_MICROBLAZE_GOTOFF_32 20 /* 32 bit offset to GOT. */ +++#define R_MICROBLAZE_COPY 21 /* Runtime copy. */ +++#define R_MICROBLAZE_TLS 22 /* TLS Reloc. */ +++#define R_MICROBLAZE_TLSGD 23 /* TLS General Dynamic. */ +++#define R_MICROBLAZE_TLSLD 24 /* TLS Local Dynamic. */ +++#define R_MICROBLAZE_TLSDTPMOD32 25 /* TLS Module ID. */ +++#define R_MICROBLAZE_TLSDTPREL32 26 /* TLS Offset Within TLS Block. */ +++#define R_MICROBLAZE_TLSDTPREL64 27 /* TLS Offset Within TLS Block. */ +++#define R_MICROBLAZE_TLSGOTTPREL32 28 /* TLS Offset From Thread Pointer. */ +++#define R_MICROBLAZE_TLSTPREL32 29 /* TLS Offset From Thread Pointer. */ +++ +++/* TILEPro relocations. */ +++#define R_TILEPRO_NONE 0 /* No reloc */ +++#define R_TILEPRO_32 1 /* Direct 32 bit */ +++#define R_TILEPRO_16 2 /* Direct 16 bit */ +++#define R_TILEPRO_8 3 /* Direct 8 bit */ +++#define R_TILEPRO_32_PCREL 4 /* PC relative 32 bit */ +++#define R_TILEPRO_16_PCREL 5 /* PC relative 16 bit */ +++#define R_TILEPRO_8_PCREL 6 /* PC relative 8 bit */ +++#define R_TILEPRO_LO16 7 /* Low 16 bit */ +++#define R_TILEPRO_HI16 8 /* High 16 bit */ +++#define R_TILEPRO_HA16 9 /* High 16 bit, adjusted */ +++#define R_TILEPRO_COPY 10 /* Copy relocation */ +++#define R_TILEPRO_GLOB_DAT 11 /* Create GOT entry */ +++#define R_TILEPRO_JMP_SLOT 12 /* Create PLT entry */ +++#define R_TILEPRO_RELATIVE 13 /* Adjust by program base */ +++#define R_TILEPRO_BROFF_X1 14 /* X1 pipe branch offset */ +++#define R_TILEPRO_JOFFLONG_X1 15 /* X1 pipe jump offset */ +++#define R_TILEPRO_JOFFLONG_X1_PLT 16 /* X1 pipe jump offset to PLT */ +++#define R_TILEPRO_IMM8_X0 17 /* X0 pipe 8-bit */ +++#define R_TILEPRO_IMM8_Y0 18 /* Y0 pipe 8-bit */ +++#define R_TILEPRO_IMM8_X1 19 /* X1 pipe 8-bit */ +++#define R_TILEPRO_IMM8_Y1 20 /* Y1 pipe 8-bit */ +++#define R_TILEPRO_MT_IMM15_X1 21 /* X1 pipe mtspr */ +++#define R_TILEPRO_MF_IMM15_X1 22 /* X1 pipe mfspr */ +++#define R_TILEPRO_IMM16_X0 23 /* X0 pipe 16-bit */ +++#define R_TILEPRO_IMM16_X1 24 /* X1 pipe 16-bit */ +++#define R_TILEPRO_IMM16_X0_LO 25 /* X0 pipe low 16-bit */ +++#define R_TILEPRO_IMM16_X1_LO 26 /* X1 pipe low 16-bit */ +++#define R_TILEPRO_IMM16_X0_HI 27 /* X0 pipe high 16-bit */ +++#define R_TILEPRO_IMM16_X1_HI 28 /* X1 pipe high 16-bit */ +++#define R_TILEPRO_IMM16_X0_HA 29 /* X0 pipe high 16-bit, adjusted */ +++#define R_TILEPRO_IMM16_X1_HA 30 /* X1 pipe high 16-bit, adjusted */ +++#define R_TILEPRO_IMM16_X0_PCREL 31 /* X0 pipe PC relative 16 bit */ +++#define R_TILEPRO_IMM16_X1_PCREL 32 /* X1 pipe PC relative 16 bit */ +++#define R_TILEPRO_IMM16_X0_LO_PCREL 33 /* X0 pipe PC relative low 16 bit */ +++#define R_TILEPRO_IMM16_X1_LO_PCREL 34 /* X1 pipe PC relative low 16 bit */ +++#define R_TILEPRO_IMM16_X0_HI_PCREL 35 /* X0 pipe PC relative high 16 bit */ +++#define R_TILEPRO_IMM16_X1_HI_PCREL 36 /* X1 pipe PC relative high 16 bit */ +++#define R_TILEPRO_IMM16_X0_HA_PCREL 37 /* X0 pipe PC relative ha() 16 bit */ +++#define R_TILEPRO_IMM16_X1_HA_PCREL 38 /* X1 pipe PC relative ha() 16 bit */ +++#define R_TILEPRO_IMM16_X0_GOT 39 /* X0 pipe 16-bit GOT offset */ +++#define R_TILEPRO_IMM16_X1_GOT 40 /* X1 pipe 16-bit GOT offset */ +++#define R_TILEPRO_IMM16_X0_GOT_LO 41 /* X0 pipe low 16-bit GOT offset */ +++#define R_TILEPRO_IMM16_X1_GOT_LO 42 /* X1 pipe low 16-bit GOT offset */ +++#define R_TILEPRO_IMM16_X0_GOT_HI 43 /* X0 pipe high 16-bit GOT offset */ +++#define R_TILEPRO_IMM16_X1_GOT_HI 44 /* X1 pipe high 16-bit GOT offset */ +++#define R_TILEPRO_IMM16_X0_GOT_HA 45 /* X0 pipe ha() 16-bit GOT offset */ +++#define R_TILEPRO_IMM16_X1_GOT_HA 46 /* X1 pipe ha() 16-bit GOT offset */ +++#define R_TILEPRO_MMSTART_X0 47 /* X0 pipe mm "start" */ +++#define R_TILEPRO_MMEND_X0 48 /* X0 pipe mm "end" */ +++#define R_TILEPRO_MMSTART_X1 49 /* X1 pipe mm "start" */ +++#define R_TILEPRO_MMEND_X1 50 /* X1 pipe mm "end" */ +++#define R_TILEPRO_SHAMT_X0 51 /* X0 pipe shift amount */ +++#define R_TILEPRO_SHAMT_X1 52 /* X1 pipe shift amount */ +++#define R_TILEPRO_SHAMT_Y0 53 /* Y0 pipe shift amount */ +++#define R_TILEPRO_SHAMT_Y1 54 /* Y1 pipe shift amount */ +++#define R_TILEPRO_DEST_IMM8_X1 55 /* X1 pipe destination 8-bit */ +++/* Relocs 56-59 are currently not defined. */ +++#define R_TILEPRO_TLS_GD_CALL 60 /* "jal" for TLS GD */ +++#define R_TILEPRO_IMM8_X0_TLS_GD_ADD 61 /* X0 pipe "addi" for TLS GD */ +++#define R_TILEPRO_IMM8_X1_TLS_GD_ADD 62 /* X1 pipe "addi" for TLS GD */ +++#define R_TILEPRO_IMM8_Y0_TLS_GD_ADD 63 /* Y0 pipe "addi" for TLS GD */ +++#define R_TILEPRO_IMM8_Y1_TLS_GD_ADD 64 /* Y1 pipe "addi" for TLS GD */ +++#define R_TILEPRO_TLS_IE_LOAD 65 /* "lw_tls" for TLS IE */ +++#define R_TILEPRO_IMM16_X0_TLS_GD 66 /* X0 pipe 16-bit TLS GD offset */ +++#define R_TILEPRO_IMM16_X1_TLS_GD 67 /* X1 pipe 16-bit TLS GD offset */ +++#define R_TILEPRO_IMM16_X0_TLS_GD_LO 68 /* X0 pipe low 16-bit TLS GD offset */ +++#define R_TILEPRO_IMM16_X1_TLS_GD_LO 69 /* X1 pipe low 16-bit TLS GD offset */ +++#define R_TILEPRO_IMM16_X0_TLS_GD_HI 70 /* X0 pipe high 16-bit TLS GD offset */ +++#define R_TILEPRO_IMM16_X1_TLS_GD_HI 71 /* X1 pipe high 16-bit TLS GD offset */ +++#define R_TILEPRO_IMM16_X0_TLS_GD_HA 72 /* X0 pipe ha() 16-bit TLS GD offset */ +++#define R_TILEPRO_IMM16_X1_TLS_GD_HA 73 /* X1 pipe ha() 16-bit TLS GD offset */ +++#define R_TILEPRO_IMM16_X0_TLS_IE 74 /* X0 pipe 16-bit TLS IE offset */ +++#define R_TILEPRO_IMM16_X1_TLS_IE 75 /* X1 pipe 16-bit TLS IE offset */ +++#define R_TILEPRO_IMM16_X0_TLS_IE_LO 76 /* X0 pipe low 16-bit TLS IE offset */ +++#define R_TILEPRO_IMM16_X1_TLS_IE_LO 77 /* X1 pipe low 16-bit TLS IE offset */ +++#define R_TILEPRO_IMM16_X0_TLS_IE_HI 78 /* X0 pipe high 16-bit TLS IE offset */ +++#define R_TILEPRO_IMM16_X1_TLS_IE_HI 79 /* X1 pipe high 16-bit TLS IE offset */ +++#define R_TILEPRO_IMM16_X0_TLS_IE_HA 80 /* X0 pipe ha() 16-bit TLS IE offset */ +++#define R_TILEPRO_IMM16_X1_TLS_IE_HA 81 /* X1 pipe ha() 16-bit TLS IE offset */ +++#define R_TILEPRO_TLS_DTPMOD32 82 /* ID of module containing symbol */ +++#define R_TILEPRO_TLS_DTPOFF32 83 /* Offset in TLS block */ +++#define R_TILEPRO_TLS_TPOFF32 84 /* Offset in static TLS block */ +++#define R_TILEPRO_IMM16_X0_TLS_LE 85 /* X0 pipe 16-bit TLS LE offset */ +++#define R_TILEPRO_IMM16_X1_TLS_LE 86 /* X1 pipe 16-bit TLS LE offset */ +++#define R_TILEPRO_IMM16_X0_TLS_LE_LO 87 /* X0 pipe low 16-bit TLS LE offset */ +++#define R_TILEPRO_IMM16_X1_TLS_LE_LO 88 /* X1 pipe low 16-bit TLS LE offset */ +++#define R_TILEPRO_IMM16_X0_TLS_LE_HI 89 /* X0 pipe high 16-bit TLS LE offset */ +++#define R_TILEPRO_IMM16_X1_TLS_LE_HI 90 /* X1 pipe high 16-bit TLS LE offset */ +++#define R_TILEPRO_IMM16_X0_TLS_LE_HA 91 /* X0 pipe ha() 16-bit TLS LE offset */ +++#define R_TILEPRO_IMM16_X1_TLS_LE_HA 92 /* X1 pipe ha() 16-bit TLS LE offset */ +++ +++#define R_TILEPRO_GNU_VTINHERIT 128 /* GNU C++ vtable hierarchy */ +++#define R_TILEPRO_GNU_VTENTRY 129 /* GNU C++ vtable member usage */ +++ +++#define R_TILEPRO_NUM 130 +++ +++ +++/* TILE-Gx relocations. */ +++#define R_TILEGX_NONE 0 /* No reloc */ +++#define R_TILEGX_64 1 /* Direct 64 bit */ +++#define R_TILEGX_32 2 /* Direct 32 bit */ +++#define R_TILEGX_16 3 /* Direct 16 bit */ +++#define R_TILEGX_8 4 /* Direct 8 bit */ +++#define R_TILEGX_64_PCREL 5 /* PC relative 64 bit */ +++#define R_TILEGX_32_PCREL 6 /* PC relative 32 bit */ +++#define R_TILEGX_16_PCREL 7 /* PC relative 16 bit */ +++#define R_TILEGX_8_PCREL 8 /* PC relative 8 bit */ +++#define R_TILEGX_HW0 9 /* hword 0 16-bit */ +++#define R_TILEGX_HW1 10 /* hword 1 16-bit */ +++#define R_TILEGX_HW2 11 /* hword 2 16-bit */ +++#define R_TILEGX_HW3 12 /* hword 3 16-bit */ +++#define R_TILEGX_HW0_LAST 13 /* last hword 0 16-bit */ +++#define R_TILEGX_HW1_LAST 14 /* last hword 1 16-bit */ +++#define R_TILEGX_HW2_LAST 15 /* last hword 2 16-bit */ +++#define R_TILEGX_COPY 16 /* Copy relocation */ +++#define R_TILEGX_GLOB_DAT 17 /* Create GOT entry */ +++#define R_TILEGX_JMP_SLOT 18 /* Create PLT entry */ +++#define R_TILEGX_RELATIVE 19 /* Adjust by program base */ +++#define R_TILEGX_BROFF_X1 20 /* X1 pipe branch offset */ +++#define R_TILEGX_JUMPOFF_X1 21 /* X1 pipe jump offset */ +++#define R_TILEGX_JUMPOFF_X1_PLT 22 /* X1 pipe jump offset to PLT */ +++#define R_TILEGX_IMM8_X0 23 /* X0 pipe 8-bit */ +++#define R_TILEGX_IMM8_Y0 24 /* Y0 pipe 8-bit */ +++#define R_TILEGX_IMM8_X1 25 /* X1 pipe 8-bit */ +++#define R_TILEGX_IMM8_Y1 26 /* Y1 pipe 8-bit */ +++#define R_TILEGX_DEST_IMM8_X1 27 /* X1 pipe destination 8-bit */ +++#define R_TILEGX_MT_IMM14_X1 28 /* X1 pipe mtspr */ +++#define R_TILEGX_MF_IMM14_X1 29 /* X1 pipe mfspr */ +++#define R_TILEGX_MMSTART_X0 30 /* X0 pipe mm "start" */ +++#define R_TILEGX_MMEND_X0 31 /* X0 pipe mm "end" */ +++#define R_TILEGX_SHAMT_X0 32 /* X0 pipe shift amount */ +++#define R_TILEGX_SHAMT_X1 33 /* X1 pipe shift amount */ +++#define R_TILEGX_SHAMT_Y0 34 /* Y0 pipe shift amount */ +++#define R_TILEGX_SHAMT_Y1 35 /* Y1 pipe shift amount */ +++#define R_TILEGX_IMM16_X0_HW0 36 /* X0 pipe hword 0 */ +++#define R_TILEGX_IMM16_X1_HW0 37 /* X1 pipe hword 0 */ +++#define R_TILEGX_IMM16_X0_HW1 38 /* X0 pipe hword 1 */ +++#define R_TILEGX_IMM16_X1_HW1 39 /* X1 pipe hword 1 */ +++#define R_TILEGX_IMM16_X0_HW2 40 /* X0 pipe hword 2 */ +++#define R_TILEGX_IMM16_X1_HW2 41 /* X1 pipe hword 2 */ +++#define R_TILEGX_IMM16_X0_HW3 42 /* X0 pipe hword 3 */ +++#define R_TILEGX_IMM16_X1_HW3 43 /* X1 pipe hword 3 */ +++#define R_TILEGX_IMM16_X0_HW0_LAST 44 /* X0 pipe last hword 0 */ +++#define R_TILEGX_IMM16_X1_HW0_LAST 45 /* X1 pipe last hword 0 */ +++#define R_TILEGX_IMM16_X0_HW1_LAST 46 /* X0 pipe last hword 1 */ +++#define R_TILEGX_IMM16_X1_HW1_LAST 47 /* X1 pipe last hword 1 */ +++#define R_TILEGX_IMM16_X0_HW2_LAST 48 /* X0 pipe last hword 2 */ +++#define R_TILEGX_IMM16_X1_HW2_LAST 49 /* X1 pipe last hword 2 */ +++#define R_TILEGX_IMM16_X0_HW0_PCREL 50 /* X0 pipe PC relative hword 0 */ +++#define R_TILEGX_IMM16_X1_HW0_PCREL 51 /* X1 pipe PC relative hword 0 */ +++#define R_TILEGX_IMM16_X0_HW1_PCREL 52 /* X0 pipe PC relative hword 1 */ +++#define R_TILEGX_IMM16_X1_HW1_PCREL 53 /* X1 pipe PC relative hword 1 */ +++#define R_TILEGX_IMM16_X0_HW2_PCREL 54 /* X0 pipe PC relative hword 2 */ +++#define R_TILEGX_IMM16_X1_HW2_PCREL 55 /* X1 pipe PC relative hword 2 */ +++#define R_TILEGX_IMM16_X0_HW3_PCREL 56 /* X0 pipe PC relative hword 3 */ +++#define R_TILEGX_IMM16_X1_HW3_PCREL 57 /* X1 pipe PC relative hword 3 */ +++#define R_TILEGX_IMM16_X0_HW0_LAST_PCREL 58 /* X0 pipe PC-rel last hword 0 */ +++#define R_TILEGX_IMM16_X1_HW0_LAST_PCREL 59 /* X1 pipe PC-rel last hword 0 */ +++#define R_TILEGX_IMM16_X0_HW1_LAST_PCREL 60 /* X0 pipe PC-rel last hword 1 */ +++#define R_TILEGX_IMM16_X1_HW1_LAST_PCREL 61 /* X1 pipe PC-rel last hword 1 */ +++#define R_TILEGX_IMM16_X0_HW2_LAST_PCREL 62 /* X0 pipe PC-rel last hword 2 */ +++#define R_TILEGX_IMM16_X1_HW2_LAST_PCREL 63 /* X1 pipe PC-rel last hword 2 */ +++#define R_TILEGX_IMM16_X0_HW0_GOT 64 /* X0 pipe hword 0 GOT offset */ +++#define R_TILEGX_IMM16_X1_HW0_GOT 65 /* X1 pipe hword 0 GOT offset */ +++#define R_TILEGX_IMM16_X0_HW0_PLT_PCREL 66 /* X0 pipe PC-rel PLT hword 0 */ +++#define R_TILEGX_IMM16_X1_HW0_PLT_PCREL 67 /* X1 pipe PC-rel PLT hword 0 */ +++#define R_TILEGX_IMM16_X0_HW1_PLT_PCREL 68 /* X0 pipe PC-rel PLT hword 1 */ +++#define R_TILEGX_IMM16_X1_HW1_PLT_PCREL 69 /* X1 pipe PC-rel PLT hword 1 */ +++#define R_TILEGX_IMM16_X0_HW2_PLT_PCREL 70 /* X0 pipe PC-rel PLT hword 2 */ +++#define R_TILEGX_IMM16_X1_HW2_PLT_PCREL 71 /* X1 pipe PC-rel PLT hword 2 */ +++#define R_TILEGX_IMM16_X0_HW0_LAST_GOT 72 /* X0 pipe last hword 0 GOT offset */ +++#define R_TILEGX_IMM16_X1_HW0_LAST_GOT 73 /* X1 pipe last hword 0 GOT offset */ +++#define R_TILEGX_IMM16_X0_HW1_LAST_GOT 74 /* X0 pipe last hword 1 GOT offset */ +++#define R_TILEGX_IMM16_X1_HW1_LAST_GOT 75 /* X1 pipe last hword 1 GOT offset */ +++#define R_TILEGX_IMM16_X0_HW3_PLT_PCREL 76 /* X0 pipe PC-rel PLT hword 3 */ +++#define R_TILEGX_IMM16_X1_HW3_PLT_PCREL 77 /* X1 pipe PC-rel PLT hword 3 */ +++#define R_TILEGX_IMM16_X0_HW0_TLS_GD 78 /* X0 pipe hword 0 TLS GD offset */ +++#define R_TILEGX_IMM16_X1_HW0_TLS_GD 79 /* X1 pipe hword 0 TLS GD offset */ +++#define R_TILEGX_IMM16_X0_HW0_TLS_LE 80 /* X0 pipe hword 0 TLS LE offset */ +++#define R_TILEGX_IMM16_X1_HW0_TLS_LE 81 /* X1 pipe hword 0 TLS LE offset */ +++#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE 82 /* X0 pipe last hword 0 LE off */ +++#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE 83 /* X1 pipe last hword 0 LE off */ +++#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE 84 /* X0 pipe last hword 1 LE off */ +++#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE 85 /* X1 pipe last hword 1 LE off */ +++#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD 86 /* X0 pipe last hword 0 GD off */ +++#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD 87 /* X1 pipe last hword 0 GD off */ +++#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD 88 /* X0 pipe last hword 1 GD off */ +++#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD 89 /* X1 pipe last hword 1 GD off */ +++/* Relocs 90-91 are currently not defined. */ +++#define R_TILEGX_IMM16_X0_HW0_TLS_IE 92 /* X0 pipe hword 0 TLS IE offset */ +++#define R_TILEGX_IMM16_X1_HW0_TLS_IE 93 /* X1 pipe hword 0 TLS IE offset */ +++#define R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL 94 /* X0 pipe PC-rel PLT last hword 0 */ +++#define R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL 95 /* X1 pipe PC-rel PLT last hword 0 */ +++#define R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL 96 /* X0 pipe PC-rel PLT last hword 1 */ +++#define R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL 97 /* X1 pipe PC-rel PLT last hword 1 */ +++#define R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL 98 /* X0 pipe PC-rel PLT last hword 2 */ +++#define R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL 99 /* X1 pipe PC-rel PLT last hword 2 */ +++#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE 100 /* X0 pipe last hword 0 IE off */ +++#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE 101 /* X1 pipe last hword 0 IE off */ +++#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE 102 /* X0 pipe last hword 1 IE off */ +++#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE 103 /* X1 pipe last hword 1 IE off */ +++/* Relocs 104-105 are currently not defined. */ +++#define R_TILEGX_TLS_DTPMOD64 106 /* 64-bit ID of symbol's module */ +++#define R_TILEGX_TLS_DTPOFF64 107 /* 64-bit offset in TLS block */ +++#define R_TILEGX_TLS_TPOFF64 108 /* 64-bit offset in static TLS block */ +++#define R_TILEGX_TLS_DTPMOD32 109 /* 32-bit ID of symbol's module */ +++#define R_TILEGX_TLS_DTPOFF32 110 /* 32-bit offset in TLS block */ +++#define R_TILEGX_TLS_TPOFF32 111 /* 32-bit offset in static TLS block */ +++#define R_TILEGX_TLS_GD_CALL 112 /* "jal" for TLS GD */ +++#define R_TILEGX_IMM8_X0_TLS_GD_ADD 113 /* X0 pipe "addi" for TLS GD */ +++#define R_TILEGX_IMM8_X1_TLS_GD_ADD 114 /* X1 pipe "addi" for TLS GD */ +++#define R_TILEGX_IMM8_Y0_TLS_GD_ADD 115 /* Y0 pipe "addi" for TLS GD */ +++#define R_TILEGX_IMM8_Y1_TLS_GD_ADD 116 /* Y1 pipe "addi" for TLS GD */ +++#define R_TILEGX_TLS_IE_LOAD 117 /* "ld_tls" for TLS IE */ +++#define R_TILEGX_IMM8_X0_TLS_ADD 118 /* X0 pipe "addi" for TLS GD/IE */ +++#define R_TILEGX_IMM8_X1_TLS_ADD 119 /* X1 pipe "addi" for TLS GD/IE */ +++#define R_TILEGX_IMM8_Y0_TLS_ADD 120 /* Y0 pipe "addi" for TLS GD/IE */ +++#define R_TILEGX_IMM8_Y1_TLS_ADD 121 /* Y1 pipe "addi" for TLS GD/IE */ +++ +++#define R_TILEGX_GNU_VTINHERIT 128 /* GNU C++ vtable hierarchy */ +++#define R_TILEGX_GNU_VTENTRY 129 /* GNU C++ vtable member usage */ +++ +++#define R_TILEGX_NUM 130 +++ +++ +++/* __END_DECLS */ ++ ++ #endif /* elf.h */ ++diff --git a/sources/patchelf/patchelf.cc b/sources/patchelf/patchelf.cc ++index c6f495e..3ca38d9 100644 ++--- a/sources/patchelf/patchelf.cc +++++ b/sources/patchelf/patchelf.cc ++@@ -1,91 +1,133 @@ +++/* +++ * PatchELF is a utility to modify properties of ELF executables and libraries +++ * Copyright (C) 2004-2016 Eelco Dolstra +++ * +++ * This program is free software: you can redistribute it and/or modify +++ * it under the terms of the GNU General Public License as published by +++ * the Free Software Foundation, either version 3 of the License, or (at +++ * your option) any later version. +++ * +++ * This program is distributed in the hope that it will be useful, but +++ * WITHOUT ANY WARRANTY; without even the implied warranty of +++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +++ * General Public License for more details. +++ * +++ * You should have received a copy of the GNU General Public License +++ * along with this program. If not, see . +++ */ +++ ++ #include ++ #include ++ #include ++ #include ++ #include ++- ++-#include ++-#include ++-#include ++-#include ++-#include ++-#include +++#include +++#include +++#include +++#include +++ +++#include +++#include +++#include +++#include +++#include +++#include ++ ++ #include ++ #include ++ #include ++ #include ++-#include ++ ++ #include "elf.h" ++ ++-using namespace std; ++ +++static bool debugMode = false; ++ ++-#ifdef MIPSEL ++-/* The lemote fuloong 2f kernel defconfig sets a page size of 16KB */ ++-const unsigned int pageSize = 4096*4; ++-#else ++-const unsigned int pageSize = 4096; ++-#endif +++static bool forceRPath = false; ++ +++static std::vector fileNames; +++static int pageSize = PAGESIZE; ++ ++-static bool debugMode = false; +++typedef std::shared_ptr> FileContents; ++ ++-static bool forceRPath = false; ++ ++-static string fileName; +++#define ElfFileParams class Elf_Ehdr, class Elf_Phdr, class Elf_Shdr, class Elf_Addr, class Elf_Off, class Elf_Dyn, class Elf_Sym, class Elf_Verneed +++#define ElfFileParamNames Elf_Ehdr, Elf_Phdr, Elf_Shdr, Elf_Addr, Elf_Off, Elf_Dyn, Elf_Sym, Elf_Verneed ++ ++ ++-off_t fileSize, maxSize; ++-unsigned char * contents = 0; +++static std::vector splitColonDelimitedString(const char * s) +++{ +++ std::vector parts; +++ const char * pos = s; +++ while (*pos) { +++ const char * end = strchr(pos, ':'); +++ if (!end) end = strchr(pos, 0); +++ +++ parts.push_back(std::string(pos, end - pos)); +++ if (*end == ':') ++end; +++ pos = end; +++ } ++ +++ return parts; +++} ++ ++-#define ElfFileParams class Elf_Ehdr, class Elf_Phdr, class Elf_Shdr, class Elf_Addr, class Elf_Off, class Elf_Dyn, class Elf_Sym ++-#define ElfFileParamNames Elf_Ehdr, Elf_Phdr, Elf_Shdr, Elf_Addr, Elf_Off, Elf_Dyn, Elf_Sym +++static bool hasAllowedPrefix(const std::string & s, const std::vector & allowedPrefixes) +++{ +++ for (auto & i : allowedPrefixes) +++ if (!s.compare(0, i.size(), i)) return true; +++ return false; +++} +++ +++ +++static unsigned int getPageSize() +++{ +++ return pageSize; +++} ++ ++ ++ template ++ class ElfFile ++ { +++public: +++ +++ const FileContents fileContents; +++ +++private: +++ +++ unsigned char * contents; +++ ++ Elf_Ehdr * hdr; ++- vector phdrs; ++- vector shdrs; +++ std::vector phdrs; +++ std::vector shdrs; ++ ++ bool littleEndian; ++ ++- bool changed; +++ bool changed = false; ++ ++- bool isExecutable; +++ bool isExecutable = false; ++ ++- typedef string SectionName; ++- typedef map ReplacedSections; +++ typedef std::string SectionName; +++ typedef std::map ReplacedSections; ++ ++ ReplacedSections replacedSections; ++ ++- string sectionNames; /* content of the .shstrtab section */ +++ std::string sectionNames; /* content of the .shstrtab section */ ++ ++ /* Align on 4 or 8 bytes boundaries on 32- or 64-bit platforms ++ respectively. */ ++- unsigned int sectionAlignment; +++ size_t sectionAlignment = sizeof(Elf_Off); ++ ++- vector sectionsByOldIndex; +++ std::vector sectionsByOldIndex; ++ ++ public: ++ ++- ElfFile() ++- { ++- changed = false; ++- sectionAlignment = sizeof(Elf_Off); ++- } +++ ElfFile(FileContents fileContents); ++ ++ bool isChanged() ++ { ++ return changed; ++ } ++ ++- void parse(); ++- ++ private: ++ ++ struct CompPhdr ++@@ -93,8 +135,11 @@ private: ++ ElfFile * elfFile; ++ bool operator ()(const Elf_Phdr & x, const Elf_Phdr & y) ++ { ++- if (x.p_type == PT_PHDR) return true; +++ // A PHDR comes before everything else. ++ if (y.p_type == PT_PHDR) return false; +++ if (x.p_type == PT_PHDR) return true; +++ +++ // Sort non-PHDRs by address. ++ return elfFile->rdi(x.p_paddr) < elfFile->rdi(y.p_paddr); ++ } ++ }; ++@@ -118,7 +163,7 @@ private: ++ ++ void shiftFile(unsigned int extraPages, Elf_Addr startPage); ++ ++- string getSectionName(const Elf_Shdr & shdr); +++ std::string getSectionName(const Elf_Shdr & shdr); ++ ++ Elf_Shdr & findSection(const SectionName & sectionName); ++ ++@@ -126,9 +171,11 @@ private: ++ ++ unsigned int findSection3(const SectionName & sectionName); ++ ++- string & replaceSection(const SectionName & sectionName, +++ std::string & replaceSection(const SectionName & sectionName, ++ unsigned int size); ++ +++ bool haveReplacedSection(const SectionName & sectionName); +++ ++ void writeReplacedSections(Elf_Off & curOff, ++ Elf_Addr startAddr, Elf_Off startOffset); ++ ++@@ -142,15 +189,27 @@ public: ++ ++ void rewriteSections(); ++ ++- string getInterpreter(); +++ std::string getInterpreter(); ++ ++- void setInterpreter(const string & newInterpreter); +++ typedef enum { printSoname, replaceSoname } sonameMode; ++ ++- typedef enum { rpPrint, rpShrink, rpSet } RPathOp; +++ void modifySoname(sonameMode op, const std::string & newSoname); ++ ++- void modifyRPath(RPathOp op, string newRPath); +++ void setInterpreter(const std::string & newInterpreter); ++ ++- void removeNeeded(set libs); +++ typedef enum { rpPrint, rpShrink, rpSet, rpRemove } RPathOp; +++ +++ void modifyRPath(RPathOp op, const std::vector & allowedRpathPrefixes, std::string newRPath); +++ +++ void addNeeded(const std::set & libs); +++ +++ void removeNeeded(const std::set & libs); +++ +++ void replaceNeeded(const std::map & libs); +++ +++ void printNeededLibs(); +++ +++ void noDefaultLib(); ++ ++ private: ++ ++@@ -205,73 +264,151 @@ static void debug(const char * format, ...) ++ } ++ ++ ++-static void error(string msg) +++void fmt2(std::ostringstream & out) +++{ +++} +++ +++ +++template +++void fmt2(std::ostringstream & out, T x, Args... args) +++{ +++ out << x; +++ fmt2(out, args...); +++} +++ +++ +++template +++std::string fmt(Args... args) ++ { ++- if (errno) perror(msg.c_str()); else fprintf(stderr, "%s\n", msg.c_str()); ++- exit(1); +++ std::ostringstream out; +++ fmt2(out, args...); +++ return out.str(); ++ } ++ ++ ++-static void growFile(off_t newSize) +++struct SysError : std::runtime_error ++ { ++- if (newSize > maxSize) error("maximum file size exceeded"); ++- if (newSize <= fileSize) return; ++- if (newSize > fileSize) ++- memset(contents + fileSize, 0, newSize - fileSize); ++- fileSize = newSize; +++ int errNo; +++ SysError(const std::string & msg) +++ : std::runtime_error(fmt(msg + ": " + strerror(errno))) +++ , errNo(errno) +++ { } +++}; +++ +++ +++__attribute__((noreturn)) static void error(std::string msg) +++{ +++ if (errno) +++ throw SysError(msg); +++ else +++ throw std::runtime_error(msg); ++ } ++ ++ ++-static void readFile(string fileName, mode_t * fileMode) +++static void growFile(FileContents contents, size_t newSize) +++{ +++ if (newSize > contents->capacity()) error("maximum file size exceeded"); +++ if (newSize <= contents->size()) return; +++ contents->resize(newSize, 0); +++} +++ +++ +++static FileContents readFile(std::string fileName, +++ size_t cutOff = std::numeric_limits::max()) ++ { ++ struct stat st; ++- if (stat(fileName.c_str(), &st) != 0) error("stat"); ++- fileSize = st.st_size; ++- *fileMode = st.st_mode; ++- maxSize = fileSize + 8 * 1024 * 1024; +++ if (stat(fileName.c_str(), &st) != 0) +++ throw SysError(fmt("getting info about '", fileName, "'")); +++ +++ if ((uint64_t) st.st_size > (uint64_t) std::numeric_limits::max()) +++ throw SysError(fmt("cannot read file of size ", st.st_size, " into memory")); +++ +++ size_t size = std::min(cutOff, (size_t) st.st_size); ++ ++- contents = (unsigned char *) malloc(fileSize + maxSize); ++- if (!contents) abort(); +++ FileContents contents = std::make_shared>(); +++ contents->reserve(size + 32 * 1024 * 1024); +++ contents->resize(size, 0); ++ ++ int fd = open(fileName.c_str(), O_RDONLY); ++- if (fd == -1) error("open"); +++ if (fd == -1) throw SysError(fmt("opening '", fileName, "'")); ++ ++- if (read(fd, contents, fileSize) != fileSize) error("read"); +++ size_t bytesRead = 0; +++ ssize_t portion; +++ while ((portion = read(fd, contents->data() + bytesRead, size - bytesRead)) > 0) +++ bytesRead += portion; +++ +++ if (bytesRead != size) +++ throw SysError(fmt("reading '", fileName, "'")); ++ ++ close(fd); +++ +++ return contents; ++ } ++ ++ ++-static void checkPointer(void * p, unsigned int size) +++struct ElfType +++{ +++ bool is32Bit; +++ int machine; // one of EM_* +++}; +++ +++ +++ElfType getElfType(const FileContents & fileContents) +++{ +++ /* Check the ELF header for basic validity. */ +++ if (fileContents->size() < (off_t) sizeof(Elf32_Ehdr)) error("missing ELF header"); +++ +++ auto contents = fileContents->data(); +++ +++ if (memcmp(contents, ELFMAG, SELFMAG) != 0) +++ error("not an ELF executable"); +++ +++ if (contents[EI_VERSION] != EV_CURRENT) +++ error("unsupported ELF version"); +++ +++ if (contents[EI_CLASS] != ELFCLASS32 && contents[EI_CLASS] != ELFCLASS64) +++ error("ELF executable is not 32 or 64 bit"); +++ +++ bool is32Bit = contents[EI_CLASS] == ELFCLASS32; +++ +++ // FIXME: endianness +++ return ElfType{is32Bit, is32Bit ? ((Elf32_Ehdr *) contents)->e_machine : ((Elf64_Ehdr *) contents)->e_machine}; +++} +++ +++ +++static void checkPointer(const FileContents & contents, void * p, unsigned int size) ++ { ++ unsigned char * q = (unsigned char *) p; ++- assert(q >= contents && q + size <= contents + fileSize); +++ assert(q >= contents->data() && q + size <= contents->data() + contents->size()); ++ } ++ ++ ++ template ++-void ElfFile::parse() +++ElfFile::ElfFile(FileContents fileContents) +++ : fileContents(fileContents) +++ , contents(fileContents->data()) ++ { ++- isExecutable = false; ++- ++ /* Check the ELF header for basic validity. */ ++- if (fileSize < (off_t) sizeof(Elf_Ehdr)) error("missing ELF header"); +++ if (fileContents->size() < (off_t) sizeof(Elf_Ehdr)) error("missing ELF header"); ++ ++- hdr = (Elf_Ehdr *) contents; +++ hdr = (Elf_Ehdr *) fileContents->data(); ++ ++ if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0) ++ error("not an ELF executable"); ++ ++- littleEndian = contents[EI_DATA] == ELFDATA2LSB; +++ littleEndian = hdr->e_ident[EI_DATA] == ELFDATA2LSB; ++ ++ if (rdi(hdr->e_type) != ET_EXEC && rdi(hdr->e_type) != ET_DYN) ++ error("wrong ELF type"); ++ ++- if ((off_t) (rdi(hdr->e_phoff) + rdi(hdr->e_phnum) * rdi(hdr->e_phentsize)) > fileSize) ++- error("missing program headers"); +++ if ((size_t) (rdi(hdr->e_phoff) + rdi(hdr->e_phnum) * rdi(hdr->e_phentsize)) > fileContents->size()) +++ error("program header table out of bounds"); ++ ++- if ((off_t) (rdi(hdr->e_shoff) + rdi(hdr->e_shnum) * rdi(hdr->e_shentsize)) > fileSize) ++- error("missing section headers"); +++ if (rdi(hdr->e_shnum) == 0) +++ error("no section headers. The input file is probably a statically linked, self-decompressing binary"); +++ +++ if ((size_t) (rdi(hdr->e_shoff) + rdi(hdr->e_shnum) * rdi(hdr->e_shentsize)) > fileContents->size()) +++ error("section header table out of bounds"); ++ ++ if (rdi(hdr->e_phentsize) != sizeof(Elf_Phdr)) ++ error("program headers have wrong size"); ++@@ -292,12 +429,12 @@ void ElfFile::parse() ++ assert(shstrtabIndex < shdrs.size()); ++ unsigned int shstrtabSize = rdi(shdrs[shstrtabIndex].sh_size); ++ char * shstrtab = (char * ) contents + rdi(shdrs[shstrtabIndex].sh_offset); ++- checkPointer(shstrtab, shstrtabSize); +++ checkPointer(fileContents, shstrtab, shstrtabSize); ++ ++ assert(shstrtabSize > 0); ++ assert(shstrtab[shstrtabSize - 1] == 0); ++ ++- sectionNames = string(shstrtab, shstrtabSize); +++ sectionNames = std::string(shstrtab, shstrtabSize); ++ ++ sectionsByOldIndex.resize(hdr->e_shnum); ++ for (unsigned int i = 1; i < rdi(hdr->e_shnum); ++i) ++@@ -320,13 +457,13 @@ void ElfFile::sortShdrs() ++ { ++ /* Translate sh_link mappings to section names, since sorting the ++ sections will invalidate the sh_link fields. */ ++- map linkage; +++ std::map linkage; ++ for (unsigned int i = 1; i < rdi(hdr->e_shnum); ++i) ++ if (rdi(shdrs[i].sh_link) != 0) ++ linkage[getSectionName(shdrs[i])] = getSectionName(shdrs[rdi(shdrs[i].sh_link)]); ++ ++ /* Idem for sh_info on certain sections. */ ++- map info; +++ std::map info; ++ for (unsigned int i = 1; i < rdi(hdr->e_shnum); ++i) ++ if (rdi(shdrs[i].sh_info) != 0 && ++ (rdi(shdrs[i].sh_type) == SHT_REL || rdi(shdrs[i].sh_type) == SHT_RELA)) ++@@ -358,21 +495,22 @@ void ElfFile::sortShdrs() ++ } ++ ++ ++-static void writeFile(string fileName, mode_t fileMode) +++static void writeFile(std::string fileName, FileContents contents) ++ { ++- string fileName2 = fileName + "_patchelf_tmp"; ++- ++- int fd = open(fileName2.c_str(), ++- O_CREAT | O_TRUNC | O_WRONLY, 0700); ++- if (fd == -1) error("open"); +++ int fd = open(fileName.c_str(), O_TRUNC | O_WRONLY); +++ if (fd == -1) +++ error("open"); ++ ++- if (write(fd, contents, fileSize) != fileSize) error("write"); +++ size_t bytesWritten = 0; +++ ssize_t portion; +++ while ((portion = write(fd, contents->data() + bytesWritten, contents->size() - bytesWritten)) > 0) +++ bytesWritten += portion; ++ ++- if (close(fd) != 0) error("close"); +++ if (bytesWritten != contents->size()) +++ error("write"); ++ ++- if (chmod(fileName2.c_str(), fileMode) != 0) error("chmod"); ++- ++- if (rename(fileName2.c_str(), fileName.c_str()) != 0) error("rename"); +++ if (close(fd) != 0) +++ error("close"); ++ } ++ ++ ++@@ -385,12 +523,12 @@ static unsigned int roundUp(unsigned int n, unsigned int m) ++ template ++ void ElfFile::shiftFile(unsigned int extraPages, Elf_Addr startPage) ++ { ++- /* Move the entire contents of the file `extraPages' pages +++ /* Move the entire contents of the file 'extraPages' pages ++ further. */ ++- unsigned int oldSize = fileSize; ++- unsigned int shift = extraPages * pageSize; ++- growFile(fileSize + extraPages * pageSize); ++- memmove(contents + extraPages * pageSize, contents, oldSize); +++ unsigned int oldSize = fileContents->size(); +++ unsigned int shift = extraPages * getPageSize(); +++ growFile(fileContents, fileContents->size() + extraPages * getPageSize()); +++ memmove(contents + extraPages * getPageSize(), contents, oldSize); ++ memset(contents + sizeof(Elf_Ehdr), 0, shift - sizeof(Elf_Ehdr)); ++ ++ /* Adjust the ELF header. */ ++@@ -407,8 +545,8 @@ void ElfFile::shiftFile(unsigned int extraPages, Elf_Addr sta ++ if (rdi(phdrs[i].p_align) != 0 && ++ (rdi(phdrs[i].p_vaddr) - rdi(phdrs[i].p_offset)) % rdi(phdrs[i].p_align) != 0) { ++ debug("changing alignment of program header %d from %d to %d\n", i, ++- rdi(phdrs[i].p_align), pageSize); ++- wri(phdrs[i].p_align, pageSize); +++ rdi(phdrs[i].p_align), getPageSize()); +++ wri(phdrs[i].p_align, getPageSize()); ++ } ++ } ++ ++@@ -422,14 +560,14 @@ void ElfFile::shiftFile(unsigned int extraPages, Elf_Addr sta ++ wri(phdr.p_vaddr, wri(phdr.p_paddr, startPage)); ++ wri(phdr.p_filesz, wri(phdr.p_memsz, shift)); ++ wri(phdr.p_flags, PF_R | PF_W); ++- wri(phdr.p_align, pageSize); +++ wri(phdr.p_align, getPageSize()); ++ } ++ ++ ++ template ++-string ElfFile::getSectionName(const Elf_Shdr & shdr) +++std::string ElfFile::getSectionName(const Elf_Shdr & shdr) ++ { ++- return string(sectionNames.c_str() + rdi(shdr.sh_name)); +++ return std::string(sectionNames.c_str() + rdi(shdr.sh_name)); ++ } ++ ++ ++@@ -437,8 +575,12 @@ template ++ Elf_Shdr & ElfFile::findSection(const SectionName & sectionName) ++ { ++ Elf_Shdr * shdr = findSection2(sectionName); ++- if (!shdr) ++- error("cannot find section " + sectionName); +++ if (!shdr) { +++ std::string extraMsg = ""; +++ if (sectionName == ".interp" || sectionName == ".dynamic" || sectionName == ".dynstr") +++ extraMsg = ". The input file is most likely statically linked"; +++ error("cannot find section '" + sectionName + "'" + extraMsg); +++ } ++ return *shdr; ++ } ++ ++@@ -459,19 +601,28 @@ unsigned int ElfFile::findSection3(const SectionName & sectio ++ return 0; ++ } ++ +++template +++bool ElfFile::haveReplacedSection(const SectionName & sectionName) +++{ +++ ReplacedSections::iterator i = replacedSections.find(sectionName); +++ +++ if (i != replacedSections.end()) +++ return true; +++ return false; +++} ++ ++ template ++-string & ElfFile::replaceSection(const SectionName & sectionName, +++std::string & ElfFile::replaceSection(const SectionName & sectionName, ++ unsigned int size) ++ { ++ ReplacedSections::iterator i = replacedSections.find(sectionName); ++- string s; +++ std::string s; ++ ++ if (i != replacedSections.end()) { ++- s = string(i->second); +++ s = std::string(i->second); ++ } else { ++ Elf_Shdr & shdr = findSection(sectionName); ++- s = string((char *) contents + rdi(shdr.sh_offset), rdi(shdr.sh_size)); +++ s = std::string((char *) contents + rdi(shdr.sh_offset), rdi(shdr.sh_size)); ++ } ++ ++ s.resize(size); ++@@ -488,29 +639,25 @@ void ElfFile::writeReplacedSections(Elf_Off & curOff, ++ /* Overwrite the old section contents with 'X's. Do this ++ *before* writing the new section contents (below) to prevent ++ clobbering previously written new section contents. */ ++- for (ReplacedSections::iterator i = replacedSections.begin(); ++- i != replacedSections.end(); ++i) ++- { ++- string sectionName = i->first; +++ for (auto & i : replacedSections) { +++ std::string sectionName = i.first; ++ Elf_Shdr & shdr = findSection(sectionName); ++ memset(contents + rdi(shdr.sh_offset), 'X', rdi(shdr.sh_size)); ++ } ++ ++- for (ReplacedSections::iterator i = replacedSections.begin(); ++- i != replacedSections.end(); ++i) ++- { ++- string sectionName = i->first; +++ for (auto & i : replacedSections) { +++ std::string sectionName = i.first; ++ Elf_Shdr & shdr = findSection(sectionName); ++- debug("rewriting section `%s' from offset 0x%x (size %d) to offset 0x%x (size %d)\n", ++- sectionName.c_str(), rdi(shdr.sh_offset), rdi(shdr.sh_size), curOff, i->second.size()); +++ debug("rewriting section '%s' from offset 0x%x (size %d) to offset 0x%x (size %d)\n", +++ sectionName.c_str(), rdi(shdr.sh_offset), rdi(shdr.sh_size), curOff, i.second.size()); ++ ++- memcpy(contents + curOff, (unsigned char *) i->second.c_str(), ++- i->second.size()); +++ memcpy(contents + curOff, (unsigned char *) i.second.c_str(), +++ i.second.size()); ++ ++ /* Update the section header for this section. */ ++ wri(shdr.sh_offset, curOff); ++ wri(shdr.sh_addr, startAddr + (curOff - startOffset)); ++- wri(shdr.sh_size, i->second.size()); +++ wri(shdr.sh_size, i.second.size()); ++ wri(shdr.sh_addralign, sectionAlignment); ++ ++ /* If this is the .interp section, then the PT_INTERP segment ++@@ -535,7 +682,7 @@ void ElfFile::writeReplacedSections(Elf_Off & curOff, ++ } ++ } ++ ++- curOff += roundUp(i->second.size(), sectionAlignment); +++ curOff += roundUp(i.second.size(), sectionAlignment); ++ } ++ ++ replacedSections.clear(); ++@@ -551,58 +698,57 @@ void ElfFile::rewriteSectionsLibrary() ++ page of other segments. */ ++ Elf_Addr startPage = 0; ++ for (unsigned int i = 0; i < phdrs.size(); ++i) { ++- Elf_Addr thisPage = roundUp(rdi(phdrs[i].p_vaddr) + rdi(phdrs[i].p_memsz), pageSize); +++ Elf_Addr thisPage = roundUp(rdi(phdrs[i].p_vaddr) + rdi(phdrs[i].p_memsz), getPageSize()); ++ if (thisPage > startPage) startPage = thisPage; ++ } ++ ++ debug("last page is 0x%llx\n", (unsigned long long) startPage); ++ +++ /* Because we're adding a new section header, we're necessarily increasing +++ the size of the program header table. This can cause the first section +++ to overlap the program header table in memory; we need to shift the first +++ few segments to someplace else. */ +++ /* Some sections may already be replaced so account for that */ +++ unsigned int i = 1; +++ Elf_Addr pht_size = sizeof(Elf_Ehdr) + (phdrs.size() + 1)*sizeof(Elf_Phdr); +++ while( shdrs[i].sh_addr <= pht_size && i < rdi(hdr->e_shnum) ) { +++ if (not haveReplacedSection(getSectionName(shdrs[i]))) +++ replaceSection(getSectionName(shdrs[i]), shdrs[i].sh_size); +++ i++; +++ } ++ ++- /* Compute the total space needed for the replaced sections and ++- the program headers. */ ++- off_t neededSpace = (phdrs.size() + 1) * sizeof(Elf_Phdr); ++- for (ReplacedSections::iterator i = replacedSections.begin(); ++- i != replacedSections.end(); ++i) ++- neededSpace += roundUp(i->second.size(), sectionAlignment); +++ /* Compute the total space needed for the replaced sections */ +++ off_t neededSpace = 0; +++ for (auto & i : replacedSections) +++ neededSpace += roundUp(i.second.size(), sectionAlignment); ++ debug("needed space is %d\n", neededSpace); ++ +++ size_t startOffset = roundUp(fileContents->size(), getPageSize()); ++ ++- size_t startOffset = roundUp(fileSize, pageSize); ++- ++- growFile(startOffset + neededSpace); ++- +++ growFile(fileContents, startOffset + neededSpace); ++ ++ /* Even though this file is of type ET_DYN, it could actually be ++ an executable. For instance, Gold produces executables marked ++- ET_DYN. In that case we can still hit the kernel bug that ++- necessitated rewriteSectionsExecutable(). However, such ++- executables also tend to start at virtual address 0, so +++ ET_DYN as does LD when linking with pie. If we move PT_PHDR, it +++ has to stay in the first PT_LOAD segment or any subsequent ones +++ if they're continuous in memory due to linux kernel constraints +++ (see BUGS). Since the end of the file would be after bss, we can't +++ move PHDR there, we therefore choose to leave PT_PHDR where it is but +++ move enough following sections such that we can add the extra PT_LOAD +++ section to it. This PT_LOAD segment ensures the sections at the end of +++ the file are mapped into memory for ld.so to process. +++ We can't use the approach in rewriteSectionsExecutable() +++ since DYN executables tend to start at virtual address 0, so ++ rewriteSectionsExecutable() won't work because it doesn't have ++- any virtual address space to grow downwards into. As a ++- workaround, make sure that the virtual address of our new ++- PT_LOAD segment relative to the first PT_LOAD segment is equal ++- to its offset; otherwise we hit the kernel bug. This may ++- require creating a hole in the executable. The bigger the size ++- of the uninitialised data segment, the bigger the hole. */ +++ any virtual address space to grow downwards into. */ ++ if (isExecutable) { ++ if (startOffset >= startPage) { ++ debug("shifting new PT_LOAD segment by %d bytes to work around a Linux kernel bug\n", startOffset - startPage); ++- } else { ++- size_t hole = startPage - startOffset; ++- /* Print a warning, because the hole could be very big. */ ++- fprintf(stderr, "warning: working around a Linux kernel bug by creating a hole of %zu bytes in ‘%s’\n", hole, fileName.c_str()); ++- assert(hole % pageSize == 0); ++- /* !!! We could create an actual hole in the file here, ++- but it's probably not worth the effort. */ ++- growFile(fileSize + hole); ++- startOffset += hole; ++ } ++ startPage = startOffset; ++ } ++ ++- ++- /* Add a segment that maps the replaced sections and program ++- headers into memory. */ +++ /* Add a segment that maps the replaced sections into memory. */ ++ phdrs.resize(rdi(hdr->e_phnum) + 1); ++ wri(hdr->e_phnum, rdi(hdr->e_phnum) + 1); ++ Elf_Phdr & phdr = phdrs[rdi(hdr->e_phnum) - 1]; ++@@ -611,19 +757,16 @@ void ElfFile::rewriteSectionsLibrary() ++ wri(phdr.p_vaddr, wri(phdr.p_paddr, startPage)); ++ wri(phdr.p_filesz, wri(phdr.p_memsz, neededSpace)); ++ wri(phdr.p_flags, PF_R | PF_W); ++- wri(phdr.p_align, pageSize); +++ wri(phdr.p_align, getPageSize()); ++ ++ ++ /* Write out the replaced sections. */ ++- Elf_Off curOff = startOffset + phdrs.size() * sizeof(Elf_Phdr); +++ Elf_Off curOff = startOffset; ++ writeReplacedSections(curOff, startPage, startOffset); ++- assert((off_t) curOff == startOffset + neededSpace); ++- +++ assert(curOff == startOffset + neededSpace); ++ ++- /* Move the program header to the start of the new area. */ ++- wri(hdr->e_phoff, startOffset); ++- ++- rewriteHeaders(startPage); +++ /* Write out the updated program and section headers */ +++ rewriteHeaders(hdr->e_phoff); ++ } ++ ++ ++@@ -638,9 +781,9 @@ void ElfFile::rewriteSectionsExecutable() ++ /* What is the index of the last replaced section? */ ++ unsigned int lastReplaced = 0; ++ for (unsigned int i = 1; i < rdi(hdr->e_shnum); ++i) { ++- string sectionName = getSectionName(shdrs[i]); +++ std::string sectionName = getSectionName(shdrs[i]); ++ if (replacedSections.find(sectionName) != replacedSections.end()) { ++- debug("using replaced section `%s'\n", sectionName.c_str()); +++ debug("using replaced section '%s'\n", sectionName.c_str()); ++ lastReplaced = i; ++ } ++ } ++@@ -656,11 +799,11 @@ void ElfFile::rewriteSectionsExecutable() ++ assert(lastReplaced + 1 < shdrs.size()); /* !!! I'm lazy. */ ++ size_t startOffset = rdi(shdrs[lastReplaced + 1].sh_offset); ++ Elf_Addr startAddr = rdi(shdrs[lastReplaced + 1].sh_addr); ++- string prevSection; +++ std::string prevSection; ++ for (unsigned int i = 1; i <= lastReplaced; ++i) { ++ Elf_Shdr & shdr(shdrs[i]); ++- string sectionName = getSectionName(shdr); ++- debug("looking at section `%s'\n", sectionName.c_str()); +++ std::string sectionName = getSectionName(shdr); +++ debug("looking at section '%s'\n", sectionName.c_str()); ++ /* !!! Why do we stop after a .dynstr section? I can't ++ remember! */ ++ if ((rdi(shdr.sh_type) == SHT_PROGBITS && sectionName != ".interp") ++@@ -672,7 +815,7 @@ void ElfFile::rewriteSectionsExecutable() ++ break; ++ } else { ++ if (replacedSections.find(sectionName) == replacedSections.end()) { ++- debug("replacing section `%s' which is in the way\n", sectionName.c_str()); +++ debug("replacing section '%s' which is in the way\n", sectionName.c_str()); ++ replaceSection(sectionName, rdi(shdr.sh_size)); ++ } ++ } ++@@ -682,23 +825,33 @@ void ElfFile::rewriteSectionsExecutable() ++ debug("first reserved offset/addr is 0x%x/0x%llx\n", ++ startOffset, (unsigned long long) startAddr); ++ ++- assert(startAddr % pageSize == startOffset % pageSize); +++ assert(startAddr % getPageSize() == startOffset % getPageSize()); ++ Elf_Addr firstPage = startAddr - startOffset; ++ debug("first page is 0x%llx\n", (unsigned long long) firstPage); ++ ++- /* Right now we assume that the section headers are somewhere near ++- the end, which appears to be the case most of the time. ++- Therefore they're not accidentally overwritten by the replaced ++- sections. !!! Fix this. */ ++- assert((off_t) rdi(hdr->e_shoff) >= startOffset); +++ if (rdi(hdr->e_shoff) < startOffset) { +++ /* The section headers occur too early in the file and would be +++ overwritten by the replaced sections. Move them to the end of the file +++ before proceeding. */ +++ off_t shoffNew = fileContents->size(); +++ off_t shSize = rdi(hdr->e_shoff) + rdi(hdr->e_shnum) * rdi(hdr->e_shentsize); +++ growFile(fileContents, fileContents->size() + shSize); +++ wri(hdr->e_shoff, shoffNew); +++ +++ /* Rewrite the section header table. For neatness, keep the +++ sections sorted. */ +++ assert(rdi(hdr->e_shnum) == shdrs.size()); +++ sortShdrs(); +++ for (unsigned int i = 1; i < rdi(hdr->e_shnum); ++i) +++ * ((Elf_Shdr *) (contents + rdi(hdr->e_shoff)) + i) = shdrs[i]; +++ } ++ ++ ++ /* Compute the total space needed for the replaced sections, the ++ ELF header, and the program headers. */ ++ size_t neededSpace = sizeof(Elf_Ehdr) + phdrs.size() * sizeof(Elf_Phdr); ++- for (ReplacedSections::iterator i = replacedSections.begin(); ++- i != replacedSections.end(); ++i) ++- neededSpace += roundUp(i->second.size(), sectionAlignment); +++ for (auto & i : replacedSections) +++ neededSpace += roundUp(i.second.size(), sectionAlignment); ++ ++ debug("needed space is %d\n", neededSpace); ++ ++@@ -711,13 +864,13 @@ void ElfFile::rewriteSectionsExecutable() ++ neededSpace += sizeof(Elf_Phdr); ++ debug("needed space is %d\n", neededSpace); ++ ++- unsigned int neededPages = roundUp(neededSpace - startOffset, pageSize) / pageSize; +++ unsigned int neededPages = roundUp(neededSpace - startOffset, getPageSize()) / getPageSize(); ++ debug("needed pages is %d\n", neededPages); ++- if (neededPages * pageSize > firstPage) +++ if (neededPages * getPageSize() > firstPage) ++ error("virtual address space underrun!"); ++ ++- firstPage -= neededPages * pageSize; ++- startOffset += neededPages * pageSize; +++ firstPage -= neededPages * getPageSize(); +++ startOffset += neededPages * getPageSize(); ++ ++ shiftFile(neededPages, firstPage); ++ } ++@@ -731,7 +884,7 @@ void ElfFile::rewriteSectionsExecutable() ++ ++ /* Write out the replaced sections. */ ++ writeReplacedSections(curOff, firstPage, 0); ++- assert((off_t) curOff == neededSpace); +++ assert(curOff == neededSpace); ++ ++ ++ rewriteHeaders(firstPage + rdi(hdr->e_phoff)); ++@@ -743,10 +896,9 @@ void ElfFile::rewriteSections() ++ { ++ if (replacedSections.empty()) return; ++ ++- for (ReplacedSections::iterator i = replacedSections.begin(); ++- i != replacedSections.end(); ++i) ++- debug("replacing section `%s' with size %d\n", ++- i->first.c_str(), i->second.size()); +++ for (auto & i : replacedSections) +++ debug("replacing section '%s' with size %d\n", +++ i.first.c_str(), i.second.size()); ++ ++ if (rdi(hdr->e_type) == ET_DYN) { ++ debug("this is a dynamic library\n"); ++@@ -764,11 +916,14 @@ void ElfFile::rewriteHeaders(Elf_Addr phdrAddress) ++ /* Rewrite the program header table. */ ++ ++ /* If there is a segment for the program header table, update it. ++- (According to the ELF spec, it must be the first entry.) */ ++- if (rdi(phdrs[0].p_type) == PT_PHDR) { ++- phdrs[0].p_offset = hdr->e_phoff; ++- wri(phdrs[0].p_vaddr, wri(phdrs[0].p_paddr, phdrAddress)); ++- wri(phdrs[0].p_filesz, wri(phdrs[0].p_memsz, phdrs.size() * sizeof(Elf_Phdr))); +++ (According to the ELF spec, there can only be one.) */ +++ for (unsigned int i = 0; i < phdrs.size(); ++i) { +++ if (rdi(phdrs[i].p_type) == PT_PHDR) { +++ phdrs[i].p_offset = hdr->e_phoff; +++ wri(phdrs[i].p_vaddr, wri(phdrs[i].p_paddr, phdrAddress)); +++ wri(phdrs[i].p_filesz, wri(phdrs[i].p_memsz, phdrs.size() * sizeof(Elf_Phdr))); +++ break; +++ } ++ } ++ ++ sortPhdrs(); ++@@ -815,11 +970,18 @@ void ElfFile::rewriteHeaders(Elf_Addr phdrAddress) ++ /* no idea if this makes sense, but it was needed for some ++ program */ ++ if (!shdr) shdr = findSection2(".rel.got"); ++- if (!shdr) error("cannot find .rel.dyn or .rel.got"); +++ /* some programs have neither section, but this doesn't seem +++ to be a problem */ +++ if (!shdr) continue; +++ dyn->d_un.d_ptr = shdr->sh_addr; +++ } +++ else if (d_tag == DT_RELA) { +++ Elf_Shdr * shdr = findSection2(".rela.dyn"); +++ /* some programs lack this section, but it doesn't seem to +++ be a problem */ +++ if (!shdr) continue; ++ dyn->d_un.d_ptr = shdr->sh_addr; ++ } ++- else if (d_tag == DT_RELA) ++- dyn->d_un.d_ptr = findSection(".rela.dyn").sh_addr; /* PPC Linux */ ++ else if (d_tag == DT_VERNEED) ++ dyn->d_un.d_ptr = findSection(".gnu.version_r").sh_addr; ++ else if (d_tag == DT_VERSYM) ++@@ -835,12 +997,21 @@ void ElfFile::rewriteHeaders(Elf_Addr phdrAddress) ++ debug("rewriting symbol table section %d\n", i); ++ for (size_t entry = 0; (entry + 1) * sizeof(Elf_Sym) <= rdi(shdrs[i].sh_size); entry++) { ++ Elf_Sym * sym = (Elf_Sym *) (contents + rdi(shdrs[i].sh_offset) + entry * sizeof(Elf_Sym)); ++- if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE) { ++- string section = sectionsByOldIndex[rdi(sym->st_shndx)]; +++ unsigned int shndx = rdi(sym->st_shndx); +++ if (shndx != SHN_UNDEF && shndx < SHN_LORESERVE) { +++ if (shndx >= sectionsByOldIndex.size()) { +++ fprintf(stderr, "warning: entry %d in symbol table refers to a non-existent section, skipping\n", shndx); +++ continue; +++ } +++ std::string section = sectionsByOldIndex.at(shndx); ++ assert(!section.empty()); ++ unsigned int newIndex = findSection3(section); // inefficient ++- //debug("rewriting symbol %d: index = %d (%s) -> %d\n", entry, rdi(sym->st_shndx), section.c_str(), newIndex); +++ //debug("rewriting symbol %d: index = %d (%s) -> %d\n", entry, shndx, section.c_str(), newIndex); ++ wri(sym->st_shndx, newIndex); +++ /* Rewrite st_value. FIXME: we should do this for all +++ types, but most don't actually change. */ +++ if (ELF32_ST_TYPE(rdi(sym->st_info)) == STT_SECTION) +++ wri(sym->st_value, rdi(shdrs[newIndex].sh_addr)); ++ } ++ } ++ } ++@@ -848,7 +1019,7 @@ void ElfFile::rewriteHeaders(Elf_Addr phdrAddress) ++ ++ ++ ++-static void setSubstr(string & s, unsigned int pos, const string & t) +++static void setSubstr(std::string & s, unsigned int pos, const std::string & t) ++ { ++ assert(pos + t.size() <= s.size()); ++ copy(t.begin(), t.end(), s.begin() + pos); ++@@ -856,23 +1027,102 @@ static void setSubstr(string & s, unsigned int pos, const string & t) ++ ++ ++ template ++-string ElfFile::getInterpreter() +++std::string ElfFile::getInterpreter() ++ { ++ Elf_Shdr & shdr = findSection(".interp"); ++- return string((char *) contents + rdi(shdr.sh_offset), rdi(shdr.sh_size)); +++ return std::string((char *) contents + rdi(shdr.sh_offset), rdi(shdr.sh_size)); ++ } ++ +++template +++void ElfFile::modifySoname(sonameMode op, const std::string & newSoname) +++{ +++ if (rdi(hdr->e_type) != ET_DYN) { +++ debug("this is not a dynamic library\n"); +++ return; +++ } +++ +++ Elf_Shdr & shdrDynamic = findSection(".dynamic"); +++ Elf_Shdr & shdrDynStr = findSection(".dynstr"); +++ char * strTab = (char *) contents + rdi(shdrDynStr.sh_offset); +++ +++ /* Walk through the dynamic section, look for the DT_SONAME entry. */ +++ Elf_Dyn * dyn = (Elf_Dyn *) (contents + rdi(shdrDynamic.sh_offset)); +++ Elf_Dyn * dynSoname = 0; +++ char * soname = 0; +++ for ( ; rdi(dyn->d_tag) != DT_NULL; dyn++) { +++ if (rdi(dyn->d_tag) == DT_SONAME) { +++ dynSoname = dyn; +++ soname = strTab + rdi(dyn->d_un.d_val); +++ } +++ } +++ +++ if (op == printSoname) { +++ if (soname) { +++ if (std::string(soname ? soname : "") == "") +++ debug("DT_SONAME is empty\n"); +++ else +++ printf("%s\n", soname); +++ } else { +++ debug("no DT_SONAME found\n"); +++ } +++ return; +++ } +++ +++ if (std::string(soname ? soname : "") == newSoname) { +++ debug("current and proposed new SONAMEs are equal keeping DT_SONAME entry\n"); +++ return; +++ } +++ +++ /* Zero out the previous SONAME */ +++ unsigned int sonameSize = 0; +++ if (soname) { +++ sonameSize = strlen(soname); +++ memset(soname, 'X', sonameSize); +++ } +++ +++ debug("new SONAME is '%s'\n", newSoname.c_str()); +++ +++ /* Grow the .dynstr section to make room for the new SONAME. */ +++ debug("SONAME is too long, resizing...\n"); +++ +++ std::string & newDynStr = replaceSection(".dynstr", rdi(shdrDynStr.sh_size) + newSoname.size() + 1); +++ setSubstr(newDynStr, rdi(shdrDynStr.sh_size), newSoname + '\0'); +++ +++ /* Update the DT_SONAME entry. */ +++ if (dynSoname) { +++ dynSoname->d_un.d_val = shdrDynStr.sh_size; +++ } else { +++ /* There is no DT_SONAME entry in the .dynamic section, so we +++ have to grow the .dynamic section. */ +++ std::string & newDynamic = replaceSection(".dynamic", rdi(shdrDynamic.sh_size) + sizeof(Elf_Dyn)); +++ +++ unsigned int idx = 0; +++ for (; rdi(((Elf_Dyn *) newDynamic.c_str())[idx].d_tag) != DT_NULL; idx++); +++ debug("DT_NULL index is %d\n", idx); +++ +++ /* Shift all entries down by one. */ +++ setSubstr(newDynamic, sizeof(Elf_Dyn), std::string(newDynamic, 0, sizeof(Elf_Dyn) * (idx + 1))); +++ +++ /* Add the DT_SONAME entry at the top. */ +++ Elf_Dyn newDyn; +++ wri(newDyn.d_tag, DT_SONAME); +++ newDyn.d_un.d_val = shdrDynStr.sh_size; +++ setSubstr(newDynamic, 0, std::string((char *)&newDyn, sizeof(Elf_Dyn))); +++ } +++ +++ changed = true; +++} ++ ++ template ++-void ElfFile::setInterpreter(const string & newInterpreter) +++void ElfFile::setInterpreter(const std::string & newInterpreter) ++ { ++- string & section = replaceSection(".interp", newInterpreter.size() + 1); +++ std::string & section = replaceSection(".interp", newInterpreter.size() + 1); ++ setSubstr(section, 0, newInterpreter + '\0'); ++ changed = true; ++ } ++ ++ ++-static void concatToRPath(string & rpath, const string & path) +++static void concatToRPath(std::string & rpath, const std::string & path) ++ { ++ if (!rpath.empty()) rpath += ":"; ++ rpath += path; ++@@ -880,7 +1130,8 @@ static void concatToRPath(string & rpath, const string & path) ++ ++ ++ template ++-void ElfFile::modifyRPath(RPathOp op, string newRPath) +++void ElfFile::modifyRPath(RPathOp op, +++ const std::vector & allowedRpathPrefixes, std::string newRPath) ++ { ++ Elf_Shdr & shdrDynamic = findSection(".dynamic"); ++ ++@@ -889,15 +1140,6 @@ void ElfFile::modifyRPath(RPathOp op, string newRPath) ++ Elf_Shdr & shdrDynStr = findSection(".dynstr"); ++ char * strTab = (char *) contents + rdi(shdrDynStr.sh_offset); ++ ++- /* Find the DT_STRTAB entry in the dynamic section. */ ++- Elf_Dyn * dyn = (Elf_Dyn *) (contents + rdi(shdrDynamic.sh_offset)); ++- Elf_Addr strTabAddr = 0; ++- for ( ; rdi(dyn->d_tag) != DT_NULL; dyn++) ++- if (rdi(dyn->d_tag) == DT_STRTAB) strTabAddr = rdi(dyn->d_un.d_ptr); ++- if (!strTabAddr) error("strange: no string table"); ++- ++- assert(strTabAddr == rdi(shdrDynStr.sh_addr)); ++- ++ ++ /* Walk through the dynamic section, look for the RPATH/RUNPATH ++ entry. ++@@ -907,12 +1149,12 @@ void ElfFile::modifyRPath(RPathOp op, string newRPath) ++ overriden by LD_LIBRARY_PATH, and it's scoped (the DT_RUNPATH ++ for an executable or library doesn't affect the search path for ++ libraries used by it). DT_RPATH is ignored if DT_RUNPATH is ++- present. The binutils `ld' still generates only DT_RPATH, ++- unless you use its `--enable-new-dtag' option, in which case it +++ present. The binutils 'ld' still generates only DT_RPATH, +++ unless you use its '--enable-new-dtag' option, in which case it ++ generates a DT_RPATH and DT_RUNPATH pointing at the same ++ string. */ ++- static vector neededLibs; ++- dyn = (Elf_Dyn *) (contents + rdi(shdrDynamic.sh_offset)); +++ std::vector neededLibs; +++ Elf_Dyn * dyn = (Elf_Dyn *) (contents + rdi(shdrDynamic.sh_offset)); ++ Elf_Dyn * dynRPath = 0, * dynRunPath = 0; ++ char * rpath = 0; ++ for ( ; rdi(dyn->d_tag) != DT_NULL; dyn++) { ++@@ -927,7 +1169,7 @@ void ElfFile::modifyRPath(RPathOp op, string newRPath) ++ rpath = strTab + rdi(dyn->d_un.d_val); ++ } ++ else if (rdi(dyn->d_tag) == DT_NEEDED) ++- neededLibs.push_back(string(strTab + rdi(dyn->d_un.d_val))); +++ neededLibs.push_back(std::string(strTab + rdi(dyn->d_un.d_val))); ++ } ++ ++ if (op == rpPrint) { ++@@ -944,19 +1186,11 @@ void ElfFile::modifyRPath(RPathOp op, string newRPath) ++ /* For each directory in the RPATH, check if it contains any ++ needed library. */ ++ if (op == rpShrink) { ++- static vector neededLibFound(neededLibs.size(), false); +++ std::vector neededLibFound(neededLibs.size(), false); ++ ++ newRPath = ""; ++ ++- char * pos = rpath; ++- while (*pos) { ++- char * end = strchr(pos, ':'); ++- if (!end) end = strchr(pos, 0); ++- ++- /* Get the name of the directory. */ ++- string dirName(pos, end - pos); ++- if (*end == ':') ++end; ++- pos = end; +++ for (auto & dirName : splitColonDelimitedString(rpath)) { ++ ++ /* Non-absolute entries are allowed (e.g., the special ++ "$ORIGIN" hack). */ ++@@ -965,28 +1199,62 @@ void ElfFile::modifyRPath(RPathOp op, string newRPath) ++ continue; ++ } ++ +++ /* If --allowed-rpath-prefixes was given, reject directories +++ not starting with any of the (colon-delimited) prefixes. */ +++ if (!allowedRpathPrefixes.empty() && !hasAllowedPrefix(dirName, allowedRpathPrefixes)) { +++ debug("removing directory '%s' from RPATH because of non-allowed prefix\n", dirName.c_str()); +++ continue; +++ } +++ ++ /* For each library that we haven't found yet, see if it ++ exists in this directory. */ ++ bool libFound = false; ++ for (unsigned int j = 0; j < neededLibs.size(); ++j) ++ if (!neededLibFound[j]) { ++- string libName = dirName + "/" + neededLibs[j]; ++- struct stat st; ++- if (stat(libName.c_str(), &st) == 0) { ++- neededLibFound[j] = true; ++- libFound = true; +++ std::string libName = dirName + "/" + neededLibs[j]; +++ try { +++ if (getElfType(readFile(libName, sizeof(Elf32_Ehdr))).machine == rdi(hdr->e_machine)) { +++ neededLibFound[j] = true; +++ libFound = true; +++ } else +++ debug("ignoring library '%s' because its machine type differs\n", libName.c_str()); +++ } catch (SysError & e) { +++ if (e.errNo != ENOENT) throw; ++ } ++ } ++ ++ if (!libFound) ++- debug("removing directory `%s' from RPATH\n", dirName.c_str()); +++ debug("removing directory '%s' from RPATH\n", dirName.c_str()); ++ else ++ concatToRPath(newRPath, dirName); ++ } ++ } ++ +++ if (op == rpRemove) { +++ if (!rpath) { +++ debug("no RPATH to delete\n"); +++ return; +++ } ++ ++- if (string(rpath ? rpath : "") == newRPath) return; +++ Elf_Dyn * dyn = (Elf_Dyn *) (contents + rdi(shdrDynamic.sh_offset)); +++ Elf_Dyn * last = dyn; +++ for ( ; rdi(dyn->d_tag) != DT_NULL; dyn++) { +++ if (rdi(dyn->d_tag) == DT_RPATH) { +++ debug("removing DT_RPATH entry\n"); +++ changed = true; +++ } else if (rdi(dyn->d_tag) == DT_RUNPATH) { +++ debug("removing DT_RUNPATH entry\n"); +++ changed = true; +++ } else { +++ *last++ = *dyn; +++ } +++ } +++ memset(last, 0, sizeof(Elf_Dyn) * (dyn - last)); +++ return; +++ } +++ +++ +++ if (std::string(rpath ? rpath : "") == newRPath) return; ++ ++ changed = true; ++ ++@@ -998,7 +1266,7 @@ void ElfFile::modifyRPath(RPathOp op, string newRPath) ++ memset(rpath, 'X', rpathSize); ++ } ++ ++- debug("new rpath is `%s'\n", newRPath.c_str()); +++ debug("new rpath is '%s'\n", newRPath.c_str()); ++ ++ if (!forceRPath && dynRPath && !dynRunPath) { /* convert DT_RPATH to DT_RUNPATH */ ++ dynRPath->d_tag = DT_RUNPATH; ++@@ -1018,7 +1286,7 @@ void ElfFile::modifyRPath(RPathOp op, string newRPath) ++ /* Grow the .dynstr section to make room for the new RPATH. */ ++ debug("rpath is too long, resizing...\n"); ++ ++- string & newDynStr = replaceSection(".dynstr", +++ std::string & newDynStr = replaceSection(".dynstr", ++ rdi(shdrDynStr.sh_size) + newRPath.size() + 1); ++ setSubstr(newDynStr, rdi(shdrDynStr.sh_size), newRPath + '\0'); ++ ++@@ -1031,7 +1299,7 @@ void ElfFile::modifyRPath(RPathOp op, string newRPath) ++ else { ++ /* There is no DT_RUNPATH entry in the .dynamic section, so we ++ have to grow the .dynamic section. */ ++- string & newDynamic = replaceSection(".dynamic", +++ std::string & newDynamic = replaceSection(".dynamic", ++ rdi(shdrDynamic.sh_size) + sizeof(Elf_Dyn)); ++ ++ unsigned int idx = 0; ++@@ -1040,19 +1308,19 @@ void ElfFile::modifyRPath(RPathOp op, string newRPath) ++ ++ /* Shift all entries down by one. */ ++ setSubstr(newDynamic, sizeof(Elf_Dyn), ++- string(newDynamic, 0, sizeof(Elf_Dyn) * (idx + 1))); +++ std::string(newDynamic, 0, sizeof(Elf_Dyn) * (idx + 1))); ++ ++ /* Add the DT_RUNPATH entry at the top. */ ++ Elf_Dyn newDyn; ++ wri(newDyn.d_tag, forceRPath ? DT_RPATH : DT_RUNPATH); ++ newDyn.d_un.d_val = shdrDynStr.sh_size; ++- setSubstr(newDynamic, 0, string((char *) &newDyn, sizeof(Elf_Dyn))); +++ setSubstr(newDynamic, 0, std::string((char *) &newDyn, sizeof(Elf_Dyn))); ++ } ++ } ++ ++ ++ template ++-void ElfFile::removeNeeded(set libs) +++void ElfFile::removeNeeded(const std::set & libs) ++ { ++ if (libs.empty()) return; ++ ++@@ -1066,10 +1334,10 @@ void ElfFile::removeNeeded(set libs) ++ if (rdi(dyn->d_tag) == DT_NEEDED) { ++ char * name = strTab + rdi(dyn->d_un.d_val); ++ if (libs.find(name) != libs.end()) { ++- debug("removing DT_NEEDED entry `%s'\n", name); +++ debug("removing DT_NEEDED entry '%s'\n", name); ++ changed = true; ++ } else { ++- debug("keeping DT_NEEDED entry `%s'\n", name); +++ debug("keeping DT_NEEDED entry '%s'\n", name); ++ *last++ = *dyn; ++ } ++ } else ++@@ -1079,96 +1347,309 @@ void ElfFile::removeNeeded(set libs) ++ memset(last, 0, sizeof(Elf_Dyn) * (dyn - last)); ++ } ++ +++template +++void ElfFile::replaceNeeded(const std::map & libs) +++{ +++ if (libs.empty()) return; ++ ++-static bool printInterpreter = false; ++-static string newInterpreter; +++ Elf_Shdr & shdrDynamic = findSection(".dynamic"); +++ Elf_Shdr & shdrDynStr = findSection(".dynstr"); +++ char * strTab = (char *) contents + rdi(shdrDynStr.sh_offset); +++ +++ Elf_Dyn * dyn = (Elf_Dyn *) (contents + rdi(shdrDynamic.sh_offset)); +++ +++ unsigned int verNeedNum = 0; +++ +++ unsigned int dynStrAddedBytes = 0; +++ +++ for ( ; rdi(dyn->d_tag) != DT_NULL; dyn++) { +++ if (rdi(dyn->d_tag) == DT_NEEDED) { +++ char * name = strTab + rdi(dyn->d_un.d_val); +++ auto i = libs.find(name); +++ if (i != libs.end()) { +++ auto replacement = i->second; +++ +++ debug("replacing DT_NEEDED entry '%s' with '%s'\n", name, replacement.c_str()); +++ +++ // technically, the string referred by d_val could be used otherwise, too (although unlikely) +++ // we'll therefore add a new string +++ debug("resizing .dynstr ...\n"); +++ +++ std::string & newDynStr = replaceSection(".dynstr", +++ rdi(shdrDynStr.sh_size) + replacement.size() + 1 + dynStrAddedBytes); +++ setSubstr(newDynStr, rdi(shdrDynStr.sh_size) + dynStrAddedBytes, replacement + '\0'); +++ +++ wri(dyn->d_un.d_val, rdi(shdrDynStr.sh_size) + dynStrAddedBytes); +++ +++ dynStrAddedBytes += replacement.size() + 1; +++ +++ changed = true; +++ } else { +++ debug("keeping DT_NEEDED entry '%s'\n", name); +++ } +++ } +++ if (rdi(dyn->d_tag) == DT_VERNEEDNUM) { +++ verNeedNum = rdi(dyn->d_un.d_val); +++ } +++ } ++ +++ // If a replaced library uses symbol versions, then there will also be +++ // references to it in the "version needed" table, and these also need to +++ // be replaced. +++ +++ if (verNeedNum) { +++ Elf_Shdr & shdrVersionR = findSection(".gnu.version_r"); +++ // The filename strings in the .gnu.version_r are different from the +++ // ones in .dynamic: instead of being in .dynstr, they're in some +++ // arbitrary section and we have to look in ->sh_link to figure out +++ // which one. +++ Elf_Shdr & shdrVersionRStrings = shdrs[rdi(shdrVersionR.sh_link)]; +++ // this is where we find the actual filename strings +++ char * verStrTab = (char *) contents + rdi(shdrVersionRStrings.sh_offset); +++ // and we also need the name of the section containing the strings, so +++ // that we can pass it to replaceSection +++ std::string versionRStringsSName = getSectionName(shdrVersionRStrings); +++ +++ debug("found .gnu.version_r with %i entries, strings in %s\n", verNeedNum, versionRStringsSName.c_str()); +++ +++ unsigned int verStrAddedBytes = 0; +++ +++ Elf_Verneed * need = (Elf_Verneed *) (contents + rdi(shdrVersionR.sh_offset)); +++ while (verNeedNum > 0) { +++ char * file = verStrTab + rdi(need->vn_file); +++ auto i = libs.find(file); +++ if (i != libs.end()) { +++ auto replacement = i->second; +++ +++ debug("replacing .gnu.version_r entry '%s' with '%s'\n", file, replacement.c_str()); +++ debug("resizing string section %s ...\n", versionRStringsSName.c_str()); +++ +++ std::string & newVerDynStr = replaceSection(versionRStringsSName, +++ rdi(shdrVersionRStrings.sh_size) + replacement.size() + 1 + verStrAddedBytes); +++ setSubstr(newVerDynStr, rdi(shdrVersionRStrings.sh_size) + verStrAddedBytes, replacement + '\0'); +++ +++ wri(need->vn_file, rdi(shdrVersionRStrings.sh_size) + verStrAddedBytes); +++ +++ verStrAddedBytes += replacement.size() + 1; +++ +++ changed = true; +++ } else { +++ debug("keeping .gnu.version_r entry '%s'\n", file); +++ } +++ // the Elf_Verneed structures form a linked list, so jump to next entry +++ need = (Elf_Verneed *) (((char *) need) + rdi(need->vn_next)); +++ --verNeedNum; +++ } +++ } +++} +++ +++template +++void ElfFile::addNeeded(const std::set & libs) +++{ +++ if (libs.empty()) return; +++ +++ Elf_Shdr & shdrDynamic = findSection(".dynamic"); +++ Elf_Shdr & shdrDynStr = findSection(".dynstr"); +++ +++ /* add all new libs to the dynstr string table */ +++ unsigned int length = 0; +++ for (auto & i : libs) length += i.size() + 1; +++ +++ std::string & newDynStr = replaceSection(".dynstr", +++ rdi(shdrDynStr.sh_size) + length + 1); +++ std::set libStrings; +++ unsigned int pos = 0; +++ for (auto & i : libs) { +++ setSubstr(newDynStr, rdi(shdrDynStr.sh_size) + pos, i + '\0'); +++ libStrings.insert(rdi(shdrDynStr.sh_size) + pos); +++ pos += i.size() + 1; +++ } +++ +++ /* add all new needed entries to the dynamic section */ +++ std::string & newDynamic = replaceSection(".dynamic", +++ rdi(shdrDynamic.sh_size) + sizeof(Elf_Dyn) * libs.size()); +++ +++ unsigned int idx = 0; +++ for ( ; rdi(((Elf_Dyn *) newDynamic.c_str())[idx].d_tag) != DT_NULL; idx++) ; +++ debug("DT_NULL index is %d\n", idx); +++ +++ /* Shift all entries down by the number of new entries. */ +++ setSubstr(newDynamic, sizeof(Elf_Dyn) * libs.size(), +++ std::string(newDynamic, 0, sizeof(Elf_Dyn) * (idx + 1))); +++ +++ /* Add the DT_NEEDED entries at the top. */ +++ unsigned int i = 0; +++ for (auto & j : libStrings) { +++ Elf_Dyn newDyn; +++ wri(newDyn.d_tag, DT_NEEDED); +++ wri(newDyn.d_un.d_val, j); +++ setSubstr(newDynamic, i * sizeof(Elf_Dyn), std::string((char *) &newDyn, sizeof(Elf_Dyn))); +++ i++; +++ } +++ +++ changed = true; +++} +++ +++template +++void ElfFile::printNeededLibs() +++{ +++ Elf_Shdr & shdrDynamic = findSection(".dynamic"); +++ Elf_Shdr & shdrDynStr = findSection(".dynstr"); +++ char *strTab = (char *)contents + rdi(shdrDynStr.sh_offset); +++ +++ Elf_Dyn *dyn = (Elf_Dyn *) (contents + rdi(shdrDynamic.sh_offset)); +++ +++ for (; rdi(dyn->d_tag) != DT_NULL; dyn++) { +++ if (rdi(dyn->d_tag) == DT_NEEDED) { +++ char *name = strTab + rdi(dyn->d_un.d_val); +++ printf("%s\n", name); +++ } +++ } +++} +++ +++ +++template +++void ElfFile::noDefaultLib() +++{ +++ Elf_Shdr & shdrDynamic = findSection(".dynamic"); +++ +++ Elf_Dyn * dyn = (Elf_Dyn *) (contents + rdi(shdrDynamic.sh_offset)); +++ Elf_Dyn * dynFlags1 = 0; +++ for ( ; rdi(dyn->d_tag) != DT_NULL; dyn++) { +++ if (rdi(dyn->d_tag) == DT_FLAGS_1) { +++ dynFlags1 = dyn; +++ break; +++ } +++ } +++ if (dynFlags1) { +++ if (dynFlags1->d_un.d_val & DF_1_NODEFLIB) +++ return; +++ dynFlags1->d_un.d_val |= DF_1_NODEFLIB; +++ } else { +++ std::string & newDynamic = replaceSection(".dynamic", +++ rdi(shdrDynamic.sh_size) + sizeof(Elf_Dyn)); +++ +++ unsigned int idx = 0; +++ for ( ; rdi(((Elf_Dyn *) newDynamic.c_str())[idx].d_tag) != DT_NULL; idx++) ; +++ debug("DT_NULL index is %d\n", idx); +++ +++ /* Shift all entries down by one. */ +++ setSubstr(newDynamic, sizeof(Elf_Dyn), +++ std::string(newDynamic, 0, sizeof(Elf_Dyn) * (idx + 1))); +++ +++ /* Add the DT_FLAGS_1 entry at the top. */ +++ Elf_Dyn newDyn; +++ wri(newDyn.d_tag, DT_FLAGS_1); +++ newDyn.d_un.d_val = DF_1_NODEFLIB; +++ setSubstr(newDynamic, 0, std::string((char *) &newDyn, sizeof(Elf_Dyn))); +++ } +++ +++ changed = true; +++} +++ +++ +++static bool printInterpreter = false; +++static bool printSoname = false; +++static bool setSoname = false; +++static std::string newSoname; +++static std::string newInterpreter; ++ static bool shrinkRPath = false; +++static std::vector allowedRpathPrefixes; +++static bool removeRPath = false; ++ static bool setRPath = false; ++ static bool printRPath = false; ++-static string newRPath; ++-static set neededLibsToRemove; ++- +++static std::string newRPath; +++static std::set neededLibsToRemove; +++static std::map neededLibsToReplace; +++static std::set neededLibsToAdd; +++static bool printNeeded = false; +++static bool noDefaultLib = false; ++ ++ template ++-static void patchElf2(ElfFile & elfFile, mode_t fileMode) +++static void patchElf2(ElfFile && elfFile, std::string fileName) ++ { ++- elfFile.parse(); ++- ++ if (printInterpreter) ++ printf("%s\n", elfFile.getInterpreter().c_str()); ++ +++ if (printSoname) +++ elfFile.modifySoname(elfFile.printSoname, ""); +++ +++ if (setSoname) +++ elfFile.modifySoname(elfFile.replaceSoname, newSoname); +++ ++ if (newInterpreter != "") ++ elfFile.setInterpreter(newInterpreter); ++ ++ if (printRPath) ++- elfFile.modifyRPath(elfFile.rpPrint, ""); +++ elfFile.modifyRPath(elfFile.rpPrint, {}, ""); ++ ++ if (shrinkRPath) ++- elfFile.modifyRPath(elfFile.rpShrink, ""); +++ elfFile.modifyRPath(elfFile.rpShrink, allowedRpathPrefixes, ""); +++ else if (removeRPath) +++ elfFile.modifyRPath(elfFile.rpRemove, {}, ""); ++ else if (setRPath) ++- elfFile.modifyRPath(elfFile.rpSet, newRPath); +++ elfFile.modifyRPath(elfFile.rpSet, {}, newRPath); +++ +++ if (printNeeded) elfFile.printNeededLibs(); ++ ++ elfFile.removeNeeded(neededLibsToRemove); +++ elfFile.replaceNeeded(neededLibsToReplace); +++ elfFile.addNeeded(neededLibsToAdd); +++ +++ if (noDefaultLib) +++ elfFile.noDefaultLib(); ++ ++ if (elfFile.isChanged()){ ++ elfFile.rewriteSections(); ++- writeFile(fileName, fileMode); +++ writeFile(fileName, elfFile.fileContents); ++ } ++ } ++ ++ ++ static void patchElf() ++ { ++- if (!printInterpreter && !printRPath) ++- debug("patching ELF file `%s'\n", fileName.c_str()); ++- ++- mode_t fileMode; +++ for (auto fileName : fileNames) { +++ if (!printInterpreter && !printRPath && !printSoname && !printNeeded) +++ debug("patching ELF file '%s'\n", fileName.c_str()); ++ ++- readFile(fileName, &fileMode); +++ debug("Kernel page size is %u bytes\n", getPageSize()); ++ +++ auto fileContents = readFile(fileName); ++ ++- /* Check the ELF header for basic validity. */ ++- if (fileSize < (off_t) sizeof(Elf32_Ehdr)) error("missing ELF header"); ++- ++- if (memcmp(contents, ELFMAG, SELFMAG) != 0) ++- error("not an ELF executable"); ++- ++- if (contents[EI_CLASS] == ELFCLASS32 && ++- contents[EI_VERSION] == EV_CURRENT) ++- { ++- ElfFile elfFile; ++- patchElf2(elfFile, fileMode); ++- } ++- else if (contents[EI_CLASS] == ELFCLASS64 && ++- contents[EI_VERSION] == EV_CURRENT) ++- { ++- ElfFile elfFile; ++- patchElf2(elfFile, fileMode); ++- } ++- else { ++- error("ELF executable is not 32/64-bit, little/big-endian, version 1"); +++ if (getElfType(fileContents).is32Bit) +++ patchElf2(ElfFile(fileContents), fileName); +++ else +++ patchElf2(ElfFile(fileContents), fileName); ++ } ++ } ++ ++ ++-void showHelp(const string & progName) +++void showHelp(const std::string & progName) ++ { ++ fprintf(stderr, "syntax: %s\n\ ++ [--set-interpreter FILENAME]\n\ +++ [--page-size SIZE]\n\ ++ [--print-interpreter]\n\ +++ [--print-soname]\t\tPrints 'DT_SONAME' entry of .dynamic section. Raises an error if DT_SONAME doesn't exist\n\ +++ [--set-soname SONAME]\t\tSets 'DT_SONAME' entry to SONAME.\n\ ++ [--set-rpath RPATH]\n\ +++ [--remove-rpath]\n\ ++ [--shrink-rpath]\n\ +++ [--allowed-rpath-prefixes PREFIXES]\t\tWith '--shrink-rpath', reject rpath entries not starting with the allowed prefix\n\ ++ [--print-rpath]\n\ ++ [--force-rpath]\n\ +++ [--add-needed LIBRARY]\n\ ++ [--remove-needed LIBRARY]\n\ +++ [--replace-needed LIBRARY NEW_LIBRARY]\n\ +++ [--print-needed]\n\ +++ [--no-default-lib]\n\ ++ [--debug]\n\ ++ [--version]\n\ ++ FILENAME\n", progName.c_str()); ++ } ++ ++ ++-int main(int argc, char * * argv) +++int mainWrapped(int argc, char * * argv) ++ { ++ if (argc <= 1) { ++ showHelp(argv[0]); ++@@ -1179,17 +1660,37 @@ int main(int argc, char * * argv) ++ ++ int i; ++ for (i = 1; i < argc; ++i) { ++- string arg(argv[i]); +++ std::string arg(argv[i]); ++ if (arg == "--set-interpreter" || arg == "--interpreter") { ++ if (++i == argc) error("missing argument"); ++ newInterpreter = argv[i]; ++ } +++ else if (arg == "--page-size") { +++ if (++i == argc) error("missing argument"); +++ pageSize = atoi(argv[i]); +++ if (pageSize <= 0) error("invalid argument to --page-size"); +++ } ++ else if (arg == "--print-interpreter") { ++ printInterpreter = true; ++ } +++ else if (arg == "--print-soname") { +++ printSoname = true; +++ } +++ else if (arg == "--set-soname") { +++ if (++i == argc) error("missing argument"); +++ setSoname = true; +++ newSoname = argv[i]; +++ } +++ else if (arg == "--remove-rpath") { +++ removeRPath = true; +++ } ++ else if (arg == "--shrink-rpath") { ++ shrinkRPath = true; ++ } +++ else if (arg == "--allowed-rpath-prefixes") { +++ if (++i == argc) error("missing argument"); +++ allowedRpathPrefixes = splitColonDelimitedString(argv[i]); +++ } ++ else if (arg == "--set-rpath") { ++ if (++i == argc) error("missing argument"); ++ setRPath = true; ++@@ -1212,28 +1713,54 @@ int main(int argc, char * * argv) ++ added. */ ++ forceRPath = true; ++ } +++ else if (arg == "--print-needed") { +++ printNeeded = true; +++ } +++ else if (arg == "--add-needed") { +++ if (++i == argc) error("missing argument"); +++ neededLibsToAdd.insert(argv[i]); +++ } ++ else if (arg == "--remove-needed") { ++ if (++i == argc) error("missing argument"); ++ neededLibsToRemove.insert(argv[i]); ++ } +++ else if (arg == "--replace-needed") { +++ if (i+2 >= argc) error("missing argument(s)"); +++ neededLibsToReplace[ argv[i+1] ] = argv[i+2]; +++ i += 2; +++ } ++ else if (arg == "--debug") { ++ debugMode = true; ++ } ++- else if (arg == "--help") { +++ else if (arg == "--no-default-lib") { +++ noDefaultLib = true; +++ } +++ else if (arg == "--help" || arg == "-h" ) { ++ showHelp(argv[0]); ++ return 0; ++ } ++ else if (arg == "--version") { ++- printf("1.0\n"); +++ printf(PACKAGE_STRING "\n"); ++ return 0; ++ } ++- else break; +++ else { +++ fileNames.push_back(arg); +++ } ++ } ++ ++- if (i == argc) error("missing filename"); ++- fileName = argv[i]; +++ if (fileNames.empty()) error("missing filename"); ++ ++ patchElf(); ++ ++ return 0; ++ } +++ +++int main(int argc, char * * argv) +++{ +++ try { +++ return mainWrapped(argc, argv); +++ } catch (std::exception & e) { +++ fprintf(stderr, "patchelf: %s\n", e.what()); +++ return 1; +++ } +++} diff --cc debian/pyside2-tools.install index 0000000,0000000..bb4b1fe new file mode 100644 --- /dev/null +++ b/debian/pyside2-tools.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py3.*/bin/pyside2-* usr/bin diff --cc debian/pyside2-tools.manpages index 0000000,0000000..ca1b931 new file mode 100644 --- /dev/null +++ b/debian/pyside2-tools.manpages @@@ -1,0 -1,0 +1,2 @@@ ++pyside3_install/py3*/share/man/man1/pyside2-* ++ diff --cc debian/python-pyside2-doc.docs index 0000000,0000000..2ada6e7 new file mode 100644 --- /dev/null +++ b/debian/python-pyside2-doc.docs @@@ -1,0 -1,0 +1,3 @@@ ++README.md ++README.pyside2.md ++README.shiboken2.md diff --cc debian/python-pyside2-doc.examples index 0000000,0000000..e39721e new file mode 100644 --- /dev/null +++ b/debian/python-pyside2-doc.examples @@@ -1,0 -1,0 +1,1 @@@ ++examples/* diff --cc debian/python3-pyside2.qt3dcore.install index 0000000,0000000..cc90239 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qt3dcore.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/Qt3DCore.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qt3dinput.install index 0000000,0000000..400bae0 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qt3dinput.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/Qt3DInput.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qt3dlogic.install index 0000000,0000000..b1976e1 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qt3dlogic.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/Qt3DLogic.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qt3drender.install index 0000000,0000000..6047dea new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qt3drender.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/Qt3DRender.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtcharts.install index 0000000,0000000..52255de new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtcharts.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtCharts.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtconcurrent.install index 0000000,0000000..ed9eae0 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtconcurrent.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtConcurrent.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtcore.install index 0000000,0000000..18bfbc7 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtcore.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtCore.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtdatavisualization.install index 0000000,0000000..e44f36c new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtdatavisualization.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtDataVisualization.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtgui.install index 0000000,0000000..9c8d25c new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtgui.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtGui.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qthelp.install index 0000000,0000000..8012c75 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qthelp.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtHelp.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtlocation.install index 0000000,0000000..133e850 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtlocation.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtLocation.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtmultimedia.install index 0000000,0000000..e100d1e new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtmultimedia.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtMultimedia.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtmultimediawidgets.install index 0000000,0000000..11420f9 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtmultimediawidgets.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtMultimediaWidgets.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtnetwork.install index 0000000,0000000..cddff59 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtnetwork.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtNetwork.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtopengl.install index 0000000,0000000..736e241 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtopengl.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtOpenGL.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtopenglfunctions.install index 0000000,0000000..9b444f7 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtopenglfunctions.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtOpenGLFunctions.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtpositioning.install index 0000000,0000000..2375c30 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtpositioning.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtPositioning.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtprintsupport.install index 0000000,0000000..72eb659 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtprintsupport.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtPrintSupport.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtqml.install index 0000000,0000000..8116b2d new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtqml.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtQml.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtquick.install index 0000000,0000000..d2045b1 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtquick.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtQuick.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtquickwidgets.install index 0000000,0000000..8e61233 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtquickwidgets.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtQuickWidgets.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtscript.install index 0000000,0000000..b0b1aa5 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtscript.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtScript.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtscripttools.install index 0000000,0000000..9cf3a61 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtscripttools.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtScriptTools.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtscxml.install index 0000000,0000000..1b9c790 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtscxml.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtScxml.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtsensors.install index 0000000,0000000..4ac8aee new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtsensors.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtSensors.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtsql.install index 0000000,0000000..b50b3e4 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtsql.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtSql.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtsvg.install index 0000000,0000000..522de6c new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtsvg.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtSvg.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qttest.install index 0000000,0000000..bc16f74 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qttest.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtTest.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qttexttospeech.install index 0000000,0000000..28fcab4 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qttexttospeech.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtTextToSpeech.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtuitools.install index 0000000,0000000..9bbb6db new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtuitools.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtUiTools.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtwebchannel.install index 0000000,0000000..97ab7cf new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtwebchannel.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtWebChannel.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtwebengine.install index 0000000,0000000..4430a23 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtwebengine.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtWebEngine.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtwebenginecore.install index 0000000,0000000..efe85a2 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtwebenginecore.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtWebEngineCore.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtwebenginewidgets.install index 0000000,0000000..3dbc143 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtwebenginewidgets.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtWebEngineWidgets.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtwebsockets.install index 0000000,0000000..54f3e1b new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtwebsockets.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtWebSockets.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtwidgets.install index 0000000,0000000..ff9a2ce new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtwidgets.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtWidgets.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtx11extras.install index 0000000,0000000..9d56ddd new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtx11extras.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtX11Extras.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtxml.install index 0000000,0000000..714f2b4 new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtxml.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtXml.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/python3-pyside2.qtxmlpatterns.install index 0000000,0000000..a4b464d new file mode 100644 --- /dev/null +++ b/debian/python3-pyside2.qtxmlpatterns.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py*-relwithdebinfo/lib/python3*/site-packages/PySide2/QtXmlPatterns.*.so usr/lib/python3/dist-packages/PySide2 diff --cc debian/rules index 0000000,0000000..1e6101e new file mode 100755 --- /dev/null +++ b/debian/rules @@@ -1,0 -1,0 +1,65 @@@ ++#!/usr/bin/make -f ++ ++include /usr/share/dpkg/default.mk ++ ++# Safety measure to ensure package names match SONAMEs ++PYSIDE_MAJOR := $(shell echo $(DEB_VERSION_UPSTREAM) | cut -d. -f1-2) ++ifeq ($(shell awk '/Package:/ {print $$2}' debian/control | grep -- -$(PYSIDE_MAJOR)$$),) ++ $(error Please update package names for major version $(PYSIDE_MAJOR)) ++endif ++ifeq ($(shell ls debian/lib* | grep -- -$(PYSIDE_MAJOR)),) ++ $(error Please update files debian/lib*.* for major version $(PYSIDE_MAJOR)) ++endif ++ifneq (,$(filter parallel=%,$(DEB_BUILD_OPTIONS))) ++ OPTION_JOBS = --parallel=$(patsubst parallel=%,%,$(filter parallel=%,$(DEB_BUILD_OPTIONS))) ++endif ++ ++export PYBUILD_NAME=pyside2 ++export PYBUILD_SYSTEM=distutils ++export PYBUILD_BUILD_ARGS=--relwithdebinfo --verbose-build --no-examples --build-tests --ignore-git $(OPTION_JOBS) ++ ++export MAIN_VERSION_UPSTREAM := $(shell echo $(DEB_VERSION_UPSTREAM)) ++export DEB_BUILD_MAINT_OPTIONS = hardening=+all ++# Add CPPFLAGS to CXXFLAGS as CMake ignores CPPFLAGS by default ++CXXFLAGS+=$(CPPFLAGS) ++ ++# Work around buildd bug (https://bugs.debian.org/842565) ++undefine XDG_RUNTIME_DIR ++ ++%: ++ dh $@ --with python3,sphinxdoc --buildsystem=pybuild ++ ++override_dh_auto_build: ++ dh_auto_build ++ #PYTHONPATH=. http_proxy='127.0.0.1:9' sphinx-build -N -bhtml doc/rst build/html # HTML generator ++ ++override_dh_auto_install: ++ # Don't use pybuild install process, we take over this step to ++ # split files in the way we want it. But we echo the list of files ++ # built to make it easier to update *.install files. ++ echo ">>> In pyside*_{package,install}" ++ -find pyside*_install pyside*_build ++ ++override_dh_makeshlibs: ++ dh_makeshlibs -VUpstream-Version ++ ++override_dh_install-indep: ++ dh_install -X.doctrees ++ ++override_dh_install-arch: ++ dh_install ++ # remove RUNPATH setup in shiboken2 ++ chrpath -d debian/shiboken2/usr/bin/shiboken2 ++ # change the library path in pkg-info/*.pc and in *.cmake files: ++ # during the build the path is setup to the build dir ++ # /build/pyside2* (required to find lib during the build) but it's ++ # not what we need ++ debian/set-paths ++ ++override_dh_auto_test: ++ifeq (mips64el,$(DEB_HOST_ARCH)) ++ # See https://bugs.debian.org/868745 ++ QSG_NO_DEPTH_BUFFER=1 xvfb-run python3 testrunner.py test ++else ++ xvfb-run python3 testrunner.py test ++endif diff --cc debian/set-paths index 0000000,0000000..9e334a2 new file mode 100755 --- /dev/null +++ b/debian/set-paths @@@ -1,0 -1,0 +1,42 @@@ ++#!/bin/sh ++ ++# Replace build directory value by install directory value ++package="libshiboken2-dev" ++for directory in "cmake/Shiboken2-$MAIN_VERSION_UPSTREAM" "pkgconfig"; do ++ sed -i "s|build.*relwithdebinfo/lib|usr/lib/$DEB_HOST_MULTIARCH|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/*; ++ sed -i "s|build.*relwithdebinfo|usr|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/*; ++ sed -i "s|\${PACKAGE_PREFIX_DIR}|/usr|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/*; ++ sed -i "s|\${_IMPORT_PREFIX}/lib|\${_IMPORT_PREFIX}/$DEB_HOST_MULTIARCH|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/*; ++ sed -i "s|\${_IMPORT_PREFIX}/include|\${_IMPORT_PREFIX}/../include|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/*; ++ sed -i "s|libshiboken2.*\.so|libshiboken2\${PYTHON_CONFIG_SUFFIX}.so|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/Shiboken2Targets-*.cmake; ++done ++ ++package="libpyside2-dev" ++for directory in "pkgconfig" "cmake/PySide2-$MAIN_VERSION_UPSTREAM"; do ++ sed -i "s|build.*relwithdebinfo/lib|usr/lib/$DEB_HOST_MULTIARCH|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/*; ++ sed -i "s|build.*relwithdebinfo|usr|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/*; ++ sed -i "s|\${PACKAGE_PREFIX_DIR}|/usr|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/*; ++ sed -i "s|\${_IMPORT_PREFIX}/lib|\${_IMPORT_PREFIX}/$DEB_HOST_MULTIARCH|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/*; ++ sed -i "s|\${_IMPORT_PREFIX}/include|\${_IMPORT_PREFIX}/../include|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/*; ++ sed -i "s|libpyside2.*\.so|libpyside2\${PYTHON_CONFIG_SUFFIX}.so|" \ ++ debian/$package/usr/lib/$DEB_HOST_MULTIARCH/$directory/PySide2Targets-*.cmake; ++done ++ ++# Set correctly the python path for pyside2 (Python3) ++sed -i "s|^set_and_check(PYSIDE_PYTHONPATH.*|set_and_check(PYSIDE_PYTHONPATH \"/usr/lib/python3/dist-packages/PySide2\")|" \ ++ debian/libpyside2-dev/usr/lib/$DEB_HOST_MULTIARCH/cmake/PySide2-$MAIN_VERSION_UPSTREAM/PySide2Config.cpython-3*-$DEB_HOST_MULTIARCH.cmake ++ ++# Set correctly the python path for shiboken2 (Python3) ++sed -i "s|^set_and_check(SHIBOKEN_PYTHON_MODULE_DIR.*|set_and_check(SHIBOKEN_PYTHON_MODULE_DIR \"/usr/lib/python3/dist-packages/shiboken2\")|" \ ++ debian/libshiboken2-dev/usr/lib/$DEB_HOST_MULTIARCH/cmake/Shiboken2-$MAIN_VERSION_UPSTREAM/Shiboken2Config.cpython-3*-$DEB_HOST_MULTIARCH.cmake diff --cc debian/shiboken2-doc.docs index 0000000,0000000..d3a722a new file mode 100644 --- /dev/null +++ b/debian/shiboken2-doc.docs @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_build/py3.8-*-relwithdebinfo/shiboken2/doc/html diff --cc debian/shiboken2.install index 0000000,0000000..335f3c4 new file mode 100644 --- /dev/null +++ b/debian/shiboken2.install @@@ -1,0 -1,0 +1,1 @@@ ++pyside3_install/py3*-relwithdebinfo/bin/shiboken2 usr/bin diff --cc debian/source/format index 0000000,0000000..163aaf8 new file mode 100644 --- /dev/null +++ b/debian/source/format @@@ -1,0 -1,0 +1,1 @@@ ++3.0 (quilt) diff --cc debian/source/options index 0000000,0000000..cb61fa5 new file mode 100644 --- /dev/null +++ b/debian/source/options @@@ -1,0 -1,0 +1,1 @@@ ++extend-diff-ignore = "^[^/]*[.]egg-info/" diff --cc debian/tests/control index 0000000,0000000..edefa56 new file mode 100644 --- /dev/null +++ b/debian/tests/control @@@ -1,0 -1,0 +1,156 @@@ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtcore PySide2.QtCore ++Depends: python3-pyside2.qtcore, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtwidgets PySide2.QtWidgets ++Depends: python3-pyside2.qtwidgets, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qt3drender PySide2.Qt3DRender ++Depends: python3-pyside2.qt3drender, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtquick PySide2.QtQuick ++Depends: python3-pyside2.qtquick, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtpositioning PySide2.QtPositioning ++Depends: python3-pyside2.qtpositioning, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtx11extras PySide2.QtX11Extras ++Depends: python3-pyside2.qtx11extras, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtqml PySide2.QtQml ++Depends: python3-pyside2.qtqml, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtwebenginecore PySide2.QtWebEngineCore ++Depends: python3-pyside2.qtwebenginecore, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qttexttospeech PySide2.QtTextToSpeech ++Depends: python3-pyside2.qttexttospeech, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qthelp PySide2.QtHelp ++Depends: python3-pyside2.qthelp, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtscripttools PySide2.QtScriptTools ++Depends: python3-pyside2.qtscripttools, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtnetwork PySide2.QtNetwork ++Depends: python3-pyside2.qtnetwork, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtmultimediawidgets PySide2.QtMultimediaWidgets ++Depends: python3-pyside2.qtmultimediawidgets, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtlocation PySide2.QtLocation ++Depends: python3-pyside2.qtlocation, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qt3dlogic PySide2.Qt3DLogic ++Depends: python3-pyside2.qt3dlogic, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtsensors PySide2.QtSensors ++Depends: python3-pyside2.qtsensors, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtmultimedia PySide2.QtMultimedia ++Depends: python3-pyside2.qtmultimedia, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtscript PySide2.QtScript ++Depends: python3-pyside2.qtscript, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtwebchannel PySide2.QtWebChannel ++Depends: python3-pyside2.qtwebchannel, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtprintsupport PySide2.QtPrintSupport ++Depends: python3-pyside2.qtprintsupport, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtquickwidgets PySide2.QtQuickWidgets ++Depends: python3-pyside2.qtquickwidgets, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qt3dinput PySide2.Qt3DInput ++Depends: python3-pyside2.qt3dinput, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtxml PySide2.QtXml ++Depends: python3-pyside2.qtxml, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qttest PySide2.QtTest ++Depends: python3-pyside2.qttest, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtwebenginewidgets PySide2.QtWebEngineWidgets ++Depends: python3-pyside2.qtwebenginewidgets, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtconcurrent PySide2.QtConcurrent ++Depends: python3-pyside2.qtconcurrent, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtxmlpatterns PySide2.QtXmlPatterns ++Depends: python3-pyside2.qtxmlpatterns, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtcharts PySide2.QtCharts ++Depends: python3-pyside2.qtcharts, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtuitools PySide2.QtUiTools ++Depends: python3-pyside2.qtuitools, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtopengl PySide2.QtOpenGL ++Depends: python3-pyside2.qtopengl, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qt3dcore PySide2.Qt3DCore ++Depends: python3-pyside2.qt3dcore, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtsql PySide2.QtSql ++Depends: python3-pyside2.qtsql, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtgui PySide2.QtGui ++Depends: python3-pyside2.qtgui, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtsvg PySide2.QtSvg ++Depends: python3-pyside2.qtsvg, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtwebsockets PySide2.QtWebSockets ++Depends: python3-pyside2.qtwebsockets, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtdatavisualization PySide2.QtDataVisualization ++Depends: python3-pyside2.qtdatavisualization, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtopenglfunctions PySide2.QtOpenGLFunctions ++Depends: python3-pyside2.qtopenglfunctions, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtscxml PySide2.QtScxml ++Depends: python3-pyside2.qtscxml, python3-all ++Restrictions: allow-stderr, superficial ++ ++Test-Command: debian/tests/test_install_python3.sh python3-pyside2.qtwebengine PySide2.QtWebEngine ++Depends: python3-pyside2.qtwebengine, python3-all ++Restrictions: allow-stderr, superficial ++ diff --cc debian/tests/control.gen index 0000000,0000000..38ca10b new file mode 100755 --- /dev/null +++ b/debian/tests/control.gen @@@ -1,0 -1,0 +1,16 @@@ ++#!/bin/sh ++ ++# Remove debian/tests/control ++rm -f debian/tests/control ++ ++# Create the basic (import) test for Python 3 modules ++for binary_package in $(dh_listpackages|grep "python3-pyside2.qt"); do ++ module_name=$(echo $binary_package|awk -F. '{print $2}') ++ # find import_name ++ import_name=$(find sources/pyside2/PySide2/ -maxdepth 1 -type d| xargs -n 1 basename|grep -i ^$module_name$) ++ echo "Test-Command: debian/tests/test_install_python3.sh $binary_package PySide2.$import_name ++Depends: $binary_package, python3-all ++Restrictions: allow-stderr, superficial ++" >>debian/tests/control ++done ++ diff --cc debian/tests/test_install_python3.sh index 0000000,0000000..db431a2 new file mode 100755 --- /dev/null +++ b/debian/tests/test_install_python3.sh @@@ -1,0 -1,0 +1,10 @@@ ++#!/bin/sh ++ ++set -e ++ ++echo "Testing python3 package $1" ++for py in $(py3versions -r 2>/dev/null) ; do ++ cd "$AUTOPKGTEST_TMP" ; ++ echo "Testing with $py:" ; ++ $py -c "import $2; print($2)" ; ++done diff --cc debian/watch index 0000000,0000000..9fe24da new file mode 100644 --- /dev/null +++ b/debian/watch @@@ -1,0 -1,0 +1,2 @@@ ++version=4 ++https://download.qt.io/official_releases/QtForPython/pyside2/PySide2-([\d\.]+)-src/ pyside-setup-.*-src-@ANY_VERSION@@ARCHIVE_EXT@ debian uupdate