#!/usr/bin/env python3 # Copyright (C) The Qt Company Ltd. # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause import argparse import collections import os import locale import sys import subprocess import re import shutil from glob import glob import common debug_build = False encoding = locale.getdefaultlocale()[1] def get_args(): parser = argparse.ArgumentParser(description='Deploy Qt Creator dependencies for packaging') parser.add_argument('--elfutils-path', help='Path to elfutils installation for use by perfprofiler (Windows, Linux)') parser.add_argument('--llvm-path', help='Path to LLVM installation') parser.add_argument('qtcreator_binary', help='Path to Qt Creator binary (or the app bundle on macOS)') parser.add_argument('qmake_binary', help='Path to qmake binary') args = parser.parse_args() args.qtcreator_binary = os.path.abspath(args.qtcreator_binary) if common.is_mac_platform(): if not args.qtcreator_binary.lower().endswith(".app"): args.qtcreator_binary = args.qtcreator_binary + ".app" check = os.path.isdir else: check = os.path.isfile if common.is_windows_platform() and not args.qtcreator_binary.lower().endswith(".exe"): args.qtcreator_binary = args.qtcreator_binary + ".exe" if not check(args.qtcreator_binary): print('Cannot find Qt Creator binary.') sys.exit(1) args.qmake_binary = which(args.qmake_binary) if not args.qmake_binary: print('Cannot find qmake binary.') sys.exit(2) return args def with_exe_ext(filepath): return filepath + '.exe' if common.is_windows_platform() else filepath def which(program): def is_exe(fpath): return os.path.exists(fpath) and os.access(fpath, os.X_OK) fpath = os.path.dirname(program) if fpath: if is_exe(program): return program if common.is_windows_platform(): if is_exe(program + ".exe"): return program + ".exe" else: for path in os.environ["PATH"].split(os.pathsep): exe_file = os.path.join(path, program) if is_exe(exe_file): return exe_file if common.is_windows_platform(): if is_exe(exe_file + ".exe"): return exe_file + ".exe" return None def is_debug(fpath): # match all Qt Core dlls from Qt4, Qt5beta2 and Qt5rc1 and later # which all have the number at different places coredebug = re.compile(r'Qt[1-9]?Core[1-9]?d[1-9]?.dll') # bootstrap exception if coredebug.search(fpath): return True # try to use dumpbin (MSVC) or objdump (MinGW), otherwise ship all .dlls if which('dumpbin'): output = subprocess.check_output(['dumpbin', '/imports', fpath]) elif which('objdump'): output = subprocess.check_output(['objdump', '-p', fpath]) else: return debug_build return coredebug.search(output.decode(encoding)) != None def is_ignored_windows_file(use_debug, basepath, filename): ignore_patterns = ['.lib', '.pdb', '.exp', '.ilk'] if use_debug: ignore_patterns.extend(['libEGL.dll', 'libGLESv2.dll']) else: ignore_patterns.extend(['libEGLd.dll', 'libGLESv2d.dll']) for ip in ignore_patterns: if filename.endswith(ip): return True if filename.endswith('.dll'): filepath = os.path.join(basepath, filename) if use_debug != is_debug(filepath): return True return False def ignored_qt_lib_files(path, filenames): # Qt ships some unneeded object files in the qml plugins # On Windows we also do not want to ship the wrong debug/release .dlls or .lib files etc # And get rid of debug info directories (.dSYM) on macOS if common.is_linux_platform(): return [fn for fn in filenames if fn.endswith('.cpp.o')] if common.is_mac_platform(): return [fn for fn in filenames if fn.endswith('.dylib.dSYM') or fn.startswith('objects-')] return [fn for fn in filenames if fn.endswith('.cpp.obj') or is_ignored_windows_file(debug_build, path, fn)] def copy_qt_libs(target_qt_prefix_path, qt_bin_dir, qt_libs_dir): print("copying Qt libraries...") if common.is_windows_platform(): libraries = glob(os.path.join(qt_libs_dir, '*.dll')) else: libraries = glob(os.path.join(qt_libs_dir, '*.so.*')) if common.is_windows_platform(): lib_dest = os.path.join(target_qt_prefix_path) else: lib_dest = os.path.join(target_qt_prefix_path, 'lib') if not os.path.exists(lib_dest): os.makedirs(lib_dest) if common.is_windows_platform(): libraries = [lib for lib in libraries if not is_ignored_windows_file(debug_build, '', lib)] for library in libraries: print(library, '->', lib_dest) if os.path.islink(library): linkto = os.readlink(library) try: os.symlink(linkto, os.path.join(lib_dest, os.path.basename(library))) except OSError: pass else: shutil.copy(library, lib_dest) def deploy_binary(binary_name, qtc_binary_path, qt_install): print(f"Copying {binary_name}") binary_src = os.path.join(qt_install.bin, with_exe_ext(binary_name)) destdir = (qtc_binary_path if common.is_windows_platform() else os.path.join(qtc_binary_path, 'Contents', 'MacOS') if common.is_mac_platform() else os.path.join(qtc_binary_path, '..', 'lib', 'Qt', 'bin')) if not os.path.exists(destdir): os.makedirs(destdir) shutil.copy(binary_src, destdir) if common.is_mac_platform(): # fix RPATHs binary_dest = os.path.join(destdir, binary_name) subprocess.check_call(['xcrun', 'install_name_tool', '-add_rpath', '@loader_path/../Frameworks', binary_dest]) subprocess.check_call(['xcrun', 'install_name_tool', '-delete_rpath', '@loader_path/../lib', binary_dest]) def deploy_plugins(qtc_binary_path, qt_install): plugins = ['assetimporters', 'accessible', 'codecs', 'designer', 'iconengines', 'imageformats', 'platformthemes', 'platforminputcontexts', 'platforms', 'printsupport', 'qmltooling', 'sqldrivers', 'styles', 'xcbglintegrations', 'wayland-decoration-client', 'wayland-graphics-integration-client', 'wayland-shell-integration', 'tls' ] print("Copying plugins:", plugins) destdir = (os.path.join(qtc_binary_path, 'plugins') if common.is_windows_platform() else os.path.join(qtc_binary_path, 'Contents', 'PlugIns') if common.is_mac_platform() else os.path.join(qtc_binary_path, '..', 'lib', 'Qt', 'plugins')) for plugin in plugins: target = os.path.join(destdir, plugin) if (os.path.exists(target)): shutil.rmtree(target) pluginPath = os.path.join(qt_install.plugins, plugin) if (os.path.exists(pluginPath)): print('{0} -> {1}'.format(pluginPath, target)) common.copytree(pluginPath, target, ignore=ignored_qt_lib_files, symlinks=True) def deploy_imports(qtc_binary_path, qt_install): print("Copying qt quick 2 imports") destdir = (os.path.join(qtc_binary_path, 'qml') if common.is_windows_platform() else os.path.join(qtc_binary_path, 'Contents', 'Imports', 'qtquick2') if common.is_mac_platform() else os.path.join(qtc_binary_path, '..', 'lib', 'Qt', 'qml')) if (os.path.exists(destdir)): shutil.rmtree(destdir) print('{0} -> {1}'.format(qt_install.qml, destdir)) common.copytree(qt_install.qml, destdir, ignore=ignored_qt_lib_files, symlinks=True) def qt_conf_contents(): if common.is_linux_platform(): return '''[Paths] Prefix={0} Binaries=bin Libraries=lib Plugins=plugins Qml2Imports=qml ''' if common.is_windows_platform(): return '''[Paths] Prefix={0} Binaries=. Libraries=. Plugins=plugins Qml2Imports=qml ''' return '''[Paths] Prefix={0} Binaries=MacOS Libraries=Frameworks Plugins=PlugIns Qml2Imports=Imports/qtquick2 ''' def add_qt_conf(target_path, qt_prefix_path): qtconf_filepath = os.path.join(target_path, 'qt.conf') prefix_path = os.path.relpath(qt_prefix_path, target_path).replace('\\', '/') print('Creating qt.conf in "{0}":'.format(qtconf_filepath)) f = open(qtconf_filepath, 'w') f.write(qt_conf_contents().format(prefix_path)) f.close() def deploy_qt_conf_files(qtc_binary_path): if common.is_linux_platform(): qt_prefix_path = os.path.join(qtc_binary_path, '..', 'lib', 'Qt') add_qt_conf(os.path.join(qtc_binary_path, '..', 'libexec', 'qtcreator'), qt_prefix_path) add_qt_conf(os.path.join(qtc_binary_path, '..', 'lib', 'Qt', 'bin'), qt_prefix_path) # qtdiag etc add_qt_conf(qtc_binary_path, qt_prefix_path) # QtC itself if common.is_windows_platform(): add_qt_conf(qtc_binary_path, qtc_binary_path) # QtC itself, libexec, and qtdiag etc if common.is_mac_platform(): qt_prefix_path = os.path.join(qtc_binary_path, 'Contents') qtc_resources_path = os.path.join(qtc_binary_path, 'Contents', 'Resources') add_qt_conf(os.path.join(qtc_resources_path, 'libexec'), qt_prefix_path) add_qt_conf(os.path.join(qtc_resources_path, 'libexec', 'ios'), qt_prefix_path) # The Prefix path for a qt.conf in Contents/Resources/ is handled specially/funny by Qt, # relative paths are resolved relative to Contents/, so we must enforces Prefix=. add_qt_conf(qtc_resources_path, qtc_resources_path) # QtC itself def deploy_translations(qtc_binary_path, qt_install): print("Copying translations...") translations = glob(os.path.join(qt_install.translations, '*.qm')) destdir = (os.path.join(qtc_binary_path, 'Contents', 'Resources', 'translations') if common.is_mac_platform() else os.path.join(qtc_binary_path, '..', 'share', 'qtcreator', 'translations')) for translation in translations: print(translation, '->', destdir) shutil.copy(translation, destdir) def copyPreservingLinks(source, destination): if os.path.islink(source): linkto = os.readlink(source) destFilePath = destination if os.path.isdir(destination): destFilePath = os.path.join(destination, os.path.basename(source)) os.symlink(linkto, destFilePath) else: shutil.copy(source, destination) def deploy_clang(qtc_binary_path, llvm_install_dir, chrpath_bin): print("Copying clang...") # contains pairs of (source, target directory) deployinfo = [] resourcesource = os.path.join(llvm_install_dir, 'lib', 'clang') if common.is_windows_platform(): clang_targetdir = os.path.join(qtc_binary_path, 'clang') clangbinary_targetdir = os.path.join(clang_targetdir, 'bin') resourcetarget = os.path.join(clang_targetdir, 'lib', 'clang') elif common.is_linux_platform(): clang_targetdir = os.path.join(qtc_binary_path, '..', 'libexec', 'qtcreator', 'clang') clangbinary_targetdir = os.path.join(clang_targetdir, 'bin') resourcetarget = os.path.join(clang_targetdir, 'lib', 'clang') # ClazyPlugin. On RHEL ClazyPlugin is in lib64, so check both clanglibs_targetdir = os.path.join(clang_targetdir, 'lib') if not os.path.exists(clanglibs_targetdir): os.makedirs(clanglibs_targetdir) for lib_pattern in ['lib64/ClazyPlugin.so', 'lib/ClazyPlugin.so']: for lib in glob(os.path.join(llvm_install_dir, lib_pattern)): if os.path.exists(lib): deployinfo.append((lib, clanglibs_targetdir)) else: clang_targetdir = os.path.join(qtc_binary_path, 'Contents', 'Resources', 'libexec', 'clang') clanglibs_targetdir = os.path.join(clang_targetdir, 'lib') clangbinary_targetdir = os.path.join(clang_targetdir, 'bin') resourcetarget = os.path.join(clang_targetdir, 'lib', 'clang') # ClazyPlugin clanglibs_targetdir = os.path.join(clang_targetdir, 'lib') if not os.path.exists(clanglibs_targetdir): os.makedirs(clanglibs_targetdir) clazy_plugin = os.path.join(llvm_install_dir, 'lib', 'ClazyPlugin.dylib') if os.path.exists(clazy_plugin): deployinfo.append((clazy_plugin, clanglibs_targetdir)) # collect binaries if not os.path.exists(clangbinary_targetdir): os.makedirs(clangbinary_targetdir) for binary in ['clangd', 'clang-tidy', 'clazy-standalone', 'clang-format']: binary_filepath = os.path.join(llvm_install_dir, 'bin', with_exe_ext(binary)) if os.path.exists(binary_filepath): deployinfo.append((binary_filepath, clangbinary_targetdir)) # add link target if binary is actually a symlink (to a binary in the same directory) if not common.is_windows_platform() and os.path.islink(binary_filepath): linktarget = os.readlink(binary_filepath) deployinfo.append((os.path.join(os.path.dirname(binary_filepath), linktarget), os.path.join(clangbinary_targetdir, linktarget))) for source, target in deployinfo: print(source, '->', target) copyPreservingLinks(source, target) if common.is_linux_platform(): # libclang was statically compiled, so there is no need for the RPATHs # and they are confusing when fixing RPATHs later in the process. # Also fix clazy-standalone RPATH. for source, target in deployinfo: filename = os.path.basename(source) targetfilepath = target if not os.path.isdir(target) else os.path.join(target, filename) if filename == 'clazy-standalone': subprocess.call([chrpath_bin, '-r', '$ORIGIN/../lib', targetfilepath]) elif not os.path.islink(target): targetfilepath = target if not os.path.isdir(target) else os.path.join(target, os.path.basename(source)) subprocess.check_call([chrpath_bin, '-d', targetfilepath]) if common.is_mac_platform(): # fix RPATH of clazy-standalone clazy_dest = os.path.join(clangbinary_targetdir, 'clazy-standalone') subprocess.call(['xcrun', 'install_name_tool', '-add_rpath', '@loader_path/../lib', clazy_dest], stderr=subprocess.DEVNULL) subprocess.call(['xcrun', 'install_name_tool', '-delete_rpath', '/Users/qt/work/build/libclang/lib', clazy_dest], stderr=subprocess.DEVNULL) print(resourcesource, '->', resourcetarget) if (os.path.exists(resourcetarget)): shutil.rmtree(resourcetarget) common.copytree(resourcesource, resourcetarget, symlinks=True) def deploy_elfutils(qtc_install_dir, chrpath_bin, args): if common.is_mac_platform(): return libs = ['elf', 'dw'] version = '1' def lib_name(name, version): return ('lib' + name + '.so.' + version if common.is_linux_platform() else name + '.dll') def find_elfutils_lib_path(path): for root, _, files in os.walk(path): if lib_name('elf', version) in files: return root return path elfutils_lib_path = find_elfutils_lib_path(os.path.join(args.elfutils_path, 'lib')) if common.is_linux_platform(): install_path = os.path.join(qtc_install_dir, 'lib', 'elfutils') backends_install_path = install_path elif common.is_windows_platform(): install_path = os.path.join(qtc_install_dir, 'bin') backends_install_path = os.path.join(qtc_install_dir, 'lib', 'elfutils') libs.append('eu_compat') if not os.path.exists(install_path): os.makedirs(install_path) if not os.path.exists(backends_install_path): os.makedirs(backends_install_path) # copy main libs libs = [os.path.join(elfutils_lib_path, lib_name(lib, version)) for lib in libs] for lib in libs: print(lib, '->', install_path) shutil.copy(lib, install_path) # fix rpath if common.is_linux_platform(): relative_path = os.path.relpath(backends_install_path, install_path) subprocess.check_call([chrpath_bin, '-r', os.path.join('$ORIGIN', relative_path), os.path.join(install_path, lib_name('dw', version))]) # copy backend files # only non-versioned, we never dlopen the versioned ones files = glob(os.path.join(elfutils_lib_path, 'elfutils', '*ebl_*.*')) versioned_files = glob(os.path.join(elfutils_lib_path, 'elfutils', '*ebl_*.*-*.*.*')) unversioned_files = [file for file in files if file not in versioned_files] for file in unversioned_files: print(file, '->', backends_install_path) shutil.copy(file, backends_install_path) def deploy_qt_mac(qtc_binary_path, qt_install): # This runs macdeployqt # Collect things to pass via -executable libexec_path = os.path.join(qtc_binary_path, 'Contents', 'Resources', 'libexec') bin_path = os.path.join(qtc_binary_path, 'Contents', 'MacOS') plugins_path = os.path.join(qtc_binary_path, 'Contents', 'PlugIns') frameworks_path = os.path.join(qtc_binary_path, 'Contents', 'Frameworks') additional_paths = [] # Qbs apps = ['qbs', 'qbs-config', 'qbs-config-ui', 'qbs-setup-android', 'qbs-setup-qt', 'qbs-setup-toolchains', 'qbs-create-project'] for app in apps: additional_paths.append(os.path.join(bin_path, app)) additional_paths.append(os.path.join(libexec_path, 'qbs_processlauncher')) # QML Puppet puppets = glob(os.path.join(libexec_path, 'qmlpuppet*')) for puppet in puppets: additional_paths.append(puppet) # qtdiag, qtplugininfo additional_paths.append(os.path.join(bin_path, 'qtdiag')) additional_paths.append(os.path.join(bin_path, 'qtplugininfo')) # other libexec additional_paths.append(os.path.join(libexec_path, 'sdktool')) additional_paths.append(os.path.join(libexec_path, 'qtpromaker')) additional_paths.append(os.path.join(libexec_path, 'buildoutputparser')) additional_paths.append(os.path.join(libexec_path, 'cpaster')) additional_paths.append(os.path.join(libexec_path, 'ios', 'iostool')) existing_additional_paths = [p for p in additional_paths if os.path.exists(p)] macdeployqt = os.path.join(qt_install.bin, 'macdeployqt') print('Running macdeployqt (' + macdeployqt + ')') print('- with additional paths:', existing_additional_paths) executable_args = ['-executable='+path for path in existing_additional_paths] subprocess.check_call([macdeployqt, qtc_binary_path] + executable_args) # clean up some things that might have been deployed, but we don't want to_remove = [ os.path.join(plugins_path, 'tls', 'libqopensslbackend.dylib'), os.path.join(plugins_path, 'sqldrivers', 'libqsqlpsql.dylib'), os.path.join(plugins_path, 'sqldrivers', 'libqsqlodbc.dylib'), ] to_remove.extend(glob(os.path.join(frameworks_path, 'libpq.*dylib'))) to_remove.extend(glob(os.path.join(frameworks_path, 'libssl.*dylib'))) to_remove.extend(glob(os.path.join(frameworks_path, 'libcrypto.*dylib'))) for path in to_remove: if os.path.isfile(path): print('- Removing ' + path) os.remove(path) def get_qt_install_info(qmake_binary): qt_install_info = common.get_qt_install_info(qmake_binary) QtInstallInfo = collections.namedtuple('QtInstallInfo', ['bin', 'lib', 'plugins', 'qml', 'translations']) return (qt_install_info, QtInstallInfo(bin=qt_install_info['QT_INSTALL_BINS'], lib=qt_install_info['QT_INSTALL_LIBS'], plugins=qt_install_info['QT_INSTALL_PLUGINS'], qml=qt_install_info['QT_INSTALL_QML'], translations=qt_install_info['QT_INSTALL_TRANSLATIONS'])) def check_webengine(dest_dir): if common.is_linux_platform(): core_path = os.path.join(dest_dir, 'lib', 'libQt6WebEngineCore.so.6') elif common.is_windows_platform(): core_path = os.path.join(dest_dir, 'Qt6WebEngineCore.dll') if not os.path.exists(core_path): return False return True def deploy_webengine_process(qt_install_dir, dest_dir): if common.is_linux_platform(): process_path = os.path.join(qt_install_dir, 'libexec', 'QtWebEngineProcess') elif common.is_windows_platform(): process_path = os.path.join(qt_install_dir, 'bin', 'QtWebEngineProcess.exe') if not os.path.exists(process_path): print(f"Error: QtWebEngineProcess not found at {process_path}.") sys.exit(1) if common.is_linux_platform(): dest_process_dir = os.path.join(dest_dir, 'libexec') if common.is_windows_platform(): dest_process_dir = dest_dir os.makedirs(dest_process_dir, exist_ok=True) print(f"Copying: {process_path} -> {dest_process_dir}") shutil.copy(process_path, dest_process_dir) resources = ['icudtl.dat', 'qtwebengine_resources.pak', 'qtwebengine_resources_100p.pak', 'qtwebengine_resources_200p.pak', 'qtwebengine_devtools_resources.pak', 'v8_context_snapshot.bin'] resources_dir = os.path.join(qt_install_dir, 'resources') dest_resources_dir = os.path.join(dest_dir, 'resources') os.makedirs(dest_resources_dir, exist_ok=True) for resource in resources: resource_path = os.path.join(resources_dir, resource) if os.path.exists(resource_path): print(f"Copying: {resource_path} -> {dest_resources_dir}") shutil.copy(resource_path, dest_resources_dir) def main(): args = get_args() chrpath_bin = None if common.is_linux_platform(): chrpath_bin = which('chrpath') if chrpath_bin == None: print("Cannot find required binary 'chrpath'.") sys.exit(2) if common.is_windows_platform(): global debug_build debug_build = is_debug(args.qtcreator_binary) (qt_install_info, qt_install) = get_qt_install_info(args.qmake_binary) # /bin for Win/Lin, /.app for macOS qtcreator_binary_path = (args.qtcreator_binary if common.is_mac_platform() else os.path.dirname(args.qtcreator_binary)) deploy_binary('qtdiag', qtcreator_binary_path, qt_install) deploy_binary('qtplugininfo', qtcreator_binary_path, qt_install) deploy_binary('qsb', qtcreator_binary_path, qt_install) deploy_plugins(qtcreator_binary_path, qt_install) deploy_imports(qtcreator_binary_path, qt_install) deploy_translations(qtcreator_binary_path, qt_install) deploy_qt_conf_files(qtcreator_binary_path) if args.llvm_path: deploy_clang(qtcreator_binary_path, args.llvm_path, chrpath_bin) if common.is_mac_platform(): deploy_qt_mac(qtcreator_binary_path, qt_install) else: install_dir = os.path.abspath(os.path.join(qtcreator_binary_path, '..')) if common.is_linux_platform(): qt_deploy_prefix = os.path.join(install_dir, 'lib', 'Qt') else: qt_deploy_prefix = os.path.join(install_dir, 'bin') if common.is_windows_platform(): copy_qt_libs(qt_deploy_prefix, qt_install.bin, qt_install.bin) else: copy_qt_libs(qt_deploy_prefix, qt_install.bin, qt_install.lib) if args.elfutils_path: deploy_elfutils(install_dir, chrpath_bin, args) if not common.is_windows_platform(): print("fixing rpaths...") common.fix_rpaths(install_dir, os.path.join(qt_deploy_prefix, 'lib'), qt_install_info, chrpath_bin) # Unlike macOS, where it is part of lib/QtWebEngineCore.framework, it is missing if check_webengine(qt_deploy_prefix): deploy_webengine_process(qt_install_info['QT_INSTALL_PREFIX'], qt_deploy_prefix) if __name__ == "__main__": main()