--- /dev/null
--- /dev/null
++Source: pyside2
++Section: python
++Priority: optional
++Maintainer: Debian Qt/KDE Maintainers <debian-qt-kde@lists.debian.org>
++Uploaders: Sophie Brun <sophie@freexian.com>,
++ Raphaël Hertzog <hertzog@debian.org>,
++ Sebastien Delafond <seb@debian.org>
++Build-Depends: chrpath,
++ cmake (>= 3.1),
++ debhelper-compat (= 13),
++ dh-exec,
++ dh-python,
++ graphviz,
++ libclang-9-dev,
++ libqt5charts5-dev,
++ libqt5datavisualization5-dev [!mips64el !mipsel !mips],
++ libqt5opengl5-dev,
++ libqt5scxml5-bin,
++ libqt5scxml5-dev,
++ libqt5sensors5-dev,
++ libqt5svg5-dev,
++ libqt5texttospeech5-dev,
++ libqt5webchannel5-dev,
++ libqt5webkit5-dev,
++ libqt5websockets5-dev,
++ libqt5x11extras5-dev,
++ libqt5xmlpatterns5-dev,
++ 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,
++ qt3d-assimpsceneimport-plugin,
++ qt3d-defaultgeometryloader-plugin,
++ qt3d-gltfsceneio-plugin,
++ qt3d-scene2d-plugin,
++ qt3d5-dev,
++ qt5-qmake,
++ qt5-qmake-bin,
++ qtbase5-dev,
++ qtbase5-private-dev,
++ qtchooser,
++ qtdeclarative5-dev,
++ qtdeclarative5-private-dev,
++ qtlocation5-dev,
++ qtmultimedia5-dev,
++ qtpositioning5-dev,
++ qtscript5-dev,
++ qttools5-dev,
++ qtwebengine5-dev [amd64 arm64 armhf i386 mipsel],
++#for tests
++ qml-module-qtquick2,
++ qml-module-qtquick-layouts,
++ qml-module-qtquick-controls,
++ xvfb,
++ xauth
++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.
--- /dev/null
--- /dev/null
++Description: Revert endl changes because incompatible with qt 5.14
++Author: Gianfranco Costamagna <locutusofborg@debian.org>
++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<QString, AbstractMetaBuilder::RejectReason>::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 << "<Code snippet \"" << location << ':' << identifier << "\" not found>\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<QStringRef> 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<QStringRef> 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<QStringRef> 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 << "<Code snippet \"" << location << "\" not found>\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 <brief> 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<QString, AbstractMetaArgument*>::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 <cctype>\n#include <cstring>\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<PyCFunction>(" << 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<PyTypeObject *>(")
++ + 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<const "
++ << typeName << " *>(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<const AbstractMetaClass *>& 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<SbkObjectType *>(")
++ + 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<SbkObject *>(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<PyTypeObject *>(" << 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 <sbkpython.h>\n";
++ s << "#include <shiboken.h>\n";
++@@ -5640,10 +5640,10 @@
++ s << "#include <qapp_macro.h>\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<Include> 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<const CustomConversion *> &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<const AbstractMetaType *> &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 Foo>).
++ const auto ptrName = metaType->typeEntry()->entryName();
++ int pos = indexName.indexOf(ptrName, 0, Qt::CaseInsensitive);
++@@ -460,7 +460,7 @@
++ const QVector<const AbstractMetaType *> &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);
++ }
--- /dev/null
--- /dev/null
++From: Debian Qt/KDE Maintainers <debian-qt-kde@lists.debian.org>
++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
+++ <http://www.gnu.org/licenses/>. */
++
++ #ifndef _ELF_H
++ #define _ELF_H 1
++
+++/* #include <features.h> */
+++
+++/* __BEGIN_DECLS */
+++
++ /* Standard ELF types. */
++
++ #include <stdint.h>
++@@ -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 <bits/auxv.h> */
++ /* 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<cond>). */
+++#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<cond>.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<cond>). */
++ #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 <edolstra@gmail.com>
+++ *
+++ * 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 <http://www.gnu.org/licenses/>.
+++ */
+++
++ #include <string>
++ #include <vector>
++ #include <set>
++ #include <map>
++ #include <algorithm>
++-
++-#include <stdlib.h>
++-#include <stdio.h>
++-#include <stdarg.h>
++-#include <assert.h>
++-#include <string.h>
++-#include <errno.h>
+++#include <memory>
+++#include <sstream>
+++#include <limits>
+++#include <stdexcept>
+++
+++#include <cstdlib>
+++#include <cstdio>
+++#include <cstdarg>
+++#include <cassert>
+++#include <cstring>
+++#include <cerrno>
++
++ #include <sys/types.h>
++ #include <sys/stat.h>
++ #include <unistd.h>
++ #include <fcntl.h>
++-#include <limits.h>
++
++ #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<std::string> fileNames;
+++static int pageSize = PAGESIZE;
++
++-static bool debugMode = false;
+++typedef std::shared_ptr<std::vector<unsigned char>> 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<std::string> splitColonDelimitedString(const char * s)
+++{
+++ std::vector<std::string> 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<std::string> & allowedPrefixes)
+++{
+++ for (auto & i : allowedPrefixes)
+++ if (!s.compare(0, i.size(), i)) return true;
+++ return false;
+++}
+++
+++
+++static unsigned int getPageSize()
+++{
+++ return pageSize;
+++}
++
++
++ template<ElfFileParams>
++ class ElfFile
++ {
+++public:
+++
+++ const FileContents fileContents;
+++
+++private:
+++
+++ unsigned char * contents;
+++
++ Elf_Ehdr * hdr;
++- vector<Elf_Phdr> phdrs;
++- vector<Elf_Shdr> shdrs;
+++ std::vector<Elf_Phdr> phdrs;
+++ std::vector<Elf_Shdr> shdrs;
++
++ bool littleEndian;
++
++- bool changed;
+++ bool changed = false;
++
++- bool isExecutable;
+++ bool isExecutable = false;
++
++- typedef string SectionName;
++- typedef map<SectionName, string> ReplacedSections;
+++ typedef std::string SectionName;
+++ typedef std::map<SectionName, std::string> 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<SectionName> sectionsByOldIndex;
+++ std::vector<SectionName> 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<string> libs);
+++ typedef enum { rpPrint, rpShrink, rpSet, rpRemove } RPathOp;
+++
+++ void modifyRPath(RPathOp op, const std::vector<std::string> & allowedRpathPrefixes, std::string newRPath);
+++
+++ void addNeeded(const std::set<std::string> & libs);
+++
+++ void removeNeeded(const std::set<std::string> & libs);
+++
+++ void replaceNeeded(const std::map<std::string, std::string> & 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<typename T, typename... Args>
+++void fmt2(std::ostringstream & out, T x, Args... args)
+++{
+++ out << x;
+++ fmt2(out, args...);
+++}
+++
+++
+++template<typename... Args>
+++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<size_t>::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<size_t>::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<std::vector<unsigned char>>();
+++ 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<ElfFileParams>
++-void ElfFile<ElfFileParamNames>::parse()
+++ElfFile<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::sortShdrs()
++ {
++ /* Translate sh_link mappings to section names, since sorting the
++ sections will invalidate the sh_link fields. */
++- map<SectionName, SectionName> linkage;
+++ std::map<SectionName, SectionName> 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<SectionName, SectionName> info;
+++ std::map<SectionName, SectionName> 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<ElfFileParamNames>::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<ElfFileParams>
++ void ElfFile<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParams>
++-string ElfFile<ElfFileParamNames>::getSectionName(const Elf_Shdr & shdr)
+++std::string ElfFile<ElfFileParamNames>::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<ElfFileParams>
++ Elf_Shdr & ElfFile<ElfFileParamNames>::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<ElfFileParamNames>::findSection3(const SectionName & sectio
++ return 0;
++ }
++
+++template<ElfFileParams>
+++bool ElfFile<ElfFileParamNames>::haveReplacedSection(const SectionName & sectionName)
+++{
+++ ReplacedSections::iterator i = replacedSections.find(sectionName);
+++
+++ if (i != replacedSections.end())
+++ return true;
+++ return false;
+++}
++
++ template<ElfFileParams>
++-string & ElfFile<ElfFileParamNames>::replaceSection(const SectionName & sectionName,
+++std::string & ElfFile<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::writeReplacedSections(Elf_Off & curOff,
++ }
++ }
++
++- curOff += roundUp(i->second.size(), sectionAlignment);
+++ curOff += roundUp(i.second.size(), sectionAlignment);
++ }
++
++ replacedSections.clear();
++@@ -551,58 +698,57 @@ void ElfFile<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParams>
++-string ElfFile<ElfFileParamNames>::getInterpreter()
+++std::string ElfFile<ElfFileParamNames>::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<ElfFileParams>
+++void ElfFile<ElfFileParamNames>::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<ElfFileParams>
++-void ElfFile<ElfFileParamNames>::setInterpreter(const string & newInterpreter)
+++void ElfFile<ElfFileParamNames>::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<ElfFileParams>
++-void ElfFile<ElfFileParamNames>::modifyRPath(RPathOp op, string newRPath)
+++void ElfFile<ElfFileParamNames>::modifyRPath(RPathOp op,
+++ const std::vector<std::string> & allowedRpathPrefixes, std::string newRPath)
++ {
++ Elf_Shdr & shdrDynamic = findSection(".dynamic");
++
++@@ -889,15 +1140,6 @@ void ElfFile<ElfFileParamNames>::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<ElfFileParamNames>::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<string> neededLibs;
++- dyn = (Elf_Dyn *) (contents + rdi(shdrDynamic.sh_offset));
+++ std::vector<std::string> 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<ElfFileParamNames>::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<ElfFileParamNames>::modifyRPath(RPathOp op, string newRPath)
++ /* For each directory in the RPATH, check if it contains any
++ needed library. */
++ if (op == rpShrink) {
++- static vector<bool> neededLibFound(neededLibs.size(), false);
+++ std::vector<bool> 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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParamNames>::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<ElfFileParams>
++-void ElfFile<ElfFileParamNames>::removeNeeded(set<string> libs)
+++void ElfFile<ElfFileParamNames>::removeNeeded(const std::set<std::string> & libs)
++ {
++ if (libs.empty()) return;
++
++@@ -1066,10 +1334,10 @@ void ElfFile<ElfFileParamNames>::removeNeeded(set<string> 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<ElfFileParamNames>::removeNeeded(set<string> libs)
++ memset(last, 0, sizeof(Elf_Dyn) * (dyn - last));
++ }
++
+++template<ElfFileParams>
+++void ElfFile<ElfFileParamNames>::replaceNeeded(const std::map<std::string, std::string> & 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<ElfFileParams>
+++void ElfFile<ElfFileParamNames>::addNeeded(const std::set<std::string> & 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<Elf64_Xword> 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<ElfFileParams>
+++void ElfFile<ElfFileParamNames>::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<ElfFileParams>
+++void ElfFile<ElfFileParamNames>::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<std::string> allowedRpathPrefixes;
+++static bool removeRPath = false;
++ static bool setRPath = false;
++ static bool printRPath = false;
++-static string newRPath;
++-static set<string> neededLibsToRemove;
++-
+++static std::string newRPath;
+++static std::set<std::string> neededLibsToRemove;
+++static std::map<std::string, std::string> neededLibsToReplace;
+++static std::set<std::string> neededLibsToAdd;
+++static bool printNeeded = false;
+++static bool noDefaultLib = false;
++
++ template<class ElfFile>
++-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<Elf32_Ehdr, Elf32_Phdr, Elf32_Shdr, Elf32_Addr, Elf32_Off, Elf32_Dyn, Elf32_Sym> elfFile;
++- patchElf2(elfFile, fileMode);
++- }
++- else if (contents[EI_CLASS] == ELFCLASS64 &&
++- contents[EI_VERSION] == EV_CURRENT)
++- {
++- ElfFile<Elf64_Ehdr, Elf64_Phdr, Elf64_Shdr, Elf64_Addr, Elf64_Off, Elf64_Dyn, Elf64_Sym> elfFile;
++- patchElf2(elfFile, fileMode);
++- }
++- else {
++- error("ELF executable is not 32/64-bit, little/big-endian, version 1");
+++ if (getElfType(fileContents).is32Bit)
+++ patchElf2(ElfFile<Elf32_Ehdr, Elf32_Phdr, Elf32_Shdr, Elf32_Addr, Elf32_Off, Elf32_Dyn, Elf32_Sym, Elf32_Verneed>(fileContents), fileName);
+++ else
+++ patchElf2(ElfFile<Elf64_Ehdr, Elf64_Phdr, Elf64_Shdr, Elf64_Addr, Elf64_Off, Elf64_Dyn, Elf64_Sym, Elf64_Verneed>(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;
+++ }
+++}
projects / pyside2.git / commitdiff