diff options
78 files changed, 4553 insertions, 18285 deletions
diff --git a/.gitignore b/.gitignore deleted file mode 100644 index 3551c9c..0000000 --- a/.gitignore +++ /dev/null @@ -1 +0,0 @@ -OSX-sdk.zip @@ -3,22 +3,50 @@ meta-darwin OpenEmbedded meta layer for darwin based SDKs -Notes: odcctools is not 64 bit safe and forces compiles to use -m32. You also need libobjc -installed along with 32 bit libraries for ssl (libcrypto) and libuuid. -The odcctools2 version should be 64 bit safe and not need those workarounds. +Note: Only macOS SDK version 12.3 (Darwin 21) is supported. -You also need a OS-X sysroot tarball/zip file generated (copied) from a target OS-X +Ensure you have read and understood the Xcode license terms: +https://www.apple.com/legal/sla/docs/xcode.pdf + +You also need a macOS sysroot tarball/zip file generated (copied) from a target macOS system. This is placed in the osx-runtime files directory and is used to compile the SDK against it. It needs to contain the system libraries (/usr/lib) and include files -(/usr/include). +(/usr/include). This tarball is not part of this meta-darwin layer and must be +created by the user. To create it, the user is required to have a legitimate Mac computer +with macOS 12.3 or later and with Xcode installed. + +Information on packaging the SDK is available at: +https://github.com/tpoechtrager/osxcross#packaging-the-sdk + +Copy the created OSX-sdk.zip file to your Yocto development machine, placing it into +meta-darwin layer: + + <...>/meta-darwin/recipes-devtools/osx-runtime/files + +You can alternatively add a nativesdk-osx-runtime_%.bbappend file to your +layer and override SRC_URI and do_configure() to extract the SDK from +a different location. + This layer depends on: URI: git://git.openembedded.org/openembedded-core layers: meta - branch: master + branch: kirkstone + + URI: https://github.com/kraj/meta-clang.git + layers: meta-clang + branch: kirkstone + +Layer Maintainers: Richard Purdie <richard.purdie@linuxfoundation.org> + Dominik Schnitzer <dominik@snap.com> + Etienne Cordonnier <ecordonnier@snap.com> + +Please send changes to the yocto-patches mailing list +(yocto-patches@lists.yoctoproject.org) with [meta-darwin] in the subject line, +cc'ing the maintainers. You need to subscribe to the mailing list at +https://lists.yoctoproject.org/g/yocto-patches before being able to post. -Layer Maintainer: Richard Purdie <richard.purdie@linuxfoundation.org> +When sending single patches, please use something like: +'git send-email -M -1 --to yocto-patches@lists.yoctoproject.org --subject-prefix="meta-darwin][PATCH"' -Please send changes to the yocto mailing list with [meta-darwin] in the subject line, -cc'ing the maintainer. diff --git a/classes/chrpath.bbclass b/classes/chrpath.bbclass new file mode 100644 index 0000000..873a5b5 --- /dev/null +++ b/classes/chrpath.bbclass @@ -0,0 +1,134 @@ +CHRPATH_BIN ?= "chrpath" +PREPROCESS_RELOCATE_DIRS ?= "" + +def process_file_linux(cmd, fpath, rootdir, baseprefix, tmpdir, d, break_hardlinks = False): + import subprocess, oe.qa + + with oe.qa.ELFFile(fpath) as elf: + try: + elf.open() + except oe.qa.NotELFFileError: + return + + try: + out = subprocess.check_output([cmd, "-l", fpath], universal_newlines=True) + except subprocess.CalledProcessError: + return + + # Handle RUNPATH as well as RPATH + out = out.replace("RUNPATH=","RPATH=") + # Throw away everything other than the rpath list + curr_rpath = out.partition("RPATH=")[2] + #bb.note("Current rpath for %s is %s" % (fpath, curr_rpath.strip())) + rpaths = curr_rpath.strip().split(":") + new_rpaths = [] + modified = False + for rpath in rpaths: + # If rpath is already dynamic copy it to new_rpath and continue + if rpath.find("$ORIGIN") != -1: + new_rpaths.append(rpath) + continue + rpath = os.path.normpath(rpath) + if baseprefix not in rpath and tmpdir not in rpath: + # Skip standard search paths + if rpath in ['/lib', '/usr/lib', '/lib64/', '/usr/lib64']: + bb.warn("Skipping RPATH %s as is a standard search path for %s" % (rpath, fpath)) + modified = True + continue + new_rpaths.append(rpath) + continue + new_rpaths.append("$ORIGIN/" + os.path.relpath(rpath, os.path.dirname(fpath.replace(rootdir, "/")))) + modified = True + + # if we have modified some rpaths call chrpath to update the binary + if modified: + if break_hardlinks: + bb.utils.break_hardlinks(fpath) + + args = ":".join(new_rpaths) + #bb.note("Setting rpath for %s to %s" %(fpath, args)) + try: + subprocess.check_output([cmd, "-r", args, fpath], + stderr=subprocess.PIPE, universal_newlines=True) + except subprocess.CalledProcessError as e: + bb.fatal("chrpath command failed with exit code %d:\n%s\n%s" % (e.returncode, e.stdout, e.stderr)) + +def process_file_darwin(cmd, fpath, rootdir, baseprefix, tmpdir, d, break_hardlinks = False): + import subprocess as sub + + p = sub.Popen([d.expand("${HOST_PREFIX}otool"), '-L', fpath],stdout=sub.PIPE,stderr=sub.PIPE, universal_newlines=True) + out, err = p.communicate() + # If returned successfully, process stdout for results + if p.returncode != 0: + return + for l in out.split("\n"): + if "(compatibility" not in l: + continue + rpath = l.partition("(compatibility")[0].strip() + if baseprefix not in rpath: + continue + + if break_hardlinks: + bb.utils.break_hardlinks(fpath) + + newpath = "@loader_path/" + os.path.relpath(rpath, os.path.dirname(fpath.replace(rootdir, "/"))) + p = sub.Popen([d.expand("${HOST_PREFIX}install_name_tool"), '-change', rpath, newpath, fpath],stdout=sub.PIPE,stderr=sub.PIPE) + out, err = p.communicate() + +def process_dir(rootdir, directory, d, break_hardlinks = False): + bb.debug(2, "Checking %s for binaries to process" % directory) + if not os.path.exists(directory): + return + + import stat + + rootdir = os.path.normpath(rootdir) + cmd = d.expand('${CHRPATH_BIN}') + tmpdir = os.path.normpath(d.getVar('TMPDIR', False)) + baseprefix = os.path.normpath(d.expand('${base_prefix}')) + hostos = d.getVar("HOST_OS") + + if "linux" in hostos: + process_file = process_file_linux + elif "darwin" in hostos: + process_file = process_file_darwin + else: + # Relocations not supported + return + + dirs = os.listdir(directory) + for file in dirs: + fpath = directory + "/" + file + fpath = os.path.normpath(fpath) + if os.path.islink(fpath): + # Skip symlinks + continue + + if os.path.isdir(fpath): + process_dir(rootdir, fpath, d, break_hardlinks = break_hardlinks) + else: + #bb.note("Testing %s for relocatability" % fpath) + + # We need read and write permissions for chrpath, if we don't have + # them then set them temporarily. Take a copy of the files + # permissions so that we can restore them afterwards. + perms = os.stat(fpath)[stat.ST_MODE] + if os.access(fpath, os.W_OK|os.R_OK): + perms = None + else: + # Temporarily make the file writeable so we can chrpath it + os.chmod(fpath, perms|stat.S_IRWXU) + + process_file(cmd, fpath, rootdir, baseprefix, tmpdir, d, break_hardlinks = break_hardlinks) + + if perms: + os.chmod(fpath, perms) + +def rpath_replace (path, d): + bindirs = d.expand("${bindir} ${sbindir} ${base_sbindir} ${base_bindir} ${libdir} ${base_libdir} ${libexecdir} ${PREPROCESS_RELOCATE_DIRS}").split() + + for bindir in bindirs: + #bb.note ("Processing directory " + bindir) + directory = path + "/" + bindir + process_dir (path, directory, d) + diff --git a/classes/cmake.bbclass b/classes/cmake.bbclass new file mode 100644 index 0000000..735d68d --- /dev/null +++ b/classes/cmake.bbclass @@ -0,0 +1,219 @@ +# Path to the CMake file to process. +OECMAKE_SOURCEPATH ??= "${S}" + +DEPENDS:prepend = "cmake-native " +B = "${WORKDIR}/build" + +# What CMake generator to use. +# The supported options are "Unix Makefiles" or "Ninja". +OECMAKE_GENERATOR ?= "Ninja" + +python() { + generator = d.getVar("OECMAKE_GENERATOR") + if "Unix Makefiles" in generator: + args = "-G '" + generator + "' -DCMAKE_MAKE_PROGRAM=" + d.getVar("MAKE") + d.setVar("OECMAKE_GENERATOR_ARGS", args) + d.setVarFlag("do_compile", "progress", "percent") + elif "Ninja" in generator: + args = "-G '" + generator + "' -DCMAKE_MAKE_PROGRAM=ninja" + d.appendVar("DEPENDS", " ninja-native") + d.setVar("OECMAKE_GENERATOR_ARGS", args) + d.setVarFlag("do_compile", "progress", r"outof:^\[(\d+)/(\d+)\]\s+") + else: + bb.fatal("Unknown CMake Generator %s" % generator) +} +OECMAKE_AR ?= "${AR}" + +# Compiler flags +OECMAKE_C_FLAGS ?= "${HOST_CC_ARCH} ${TOOLCHAIN_OPTIONS} ${CFLAGS}" +OECMAKE_CXX_FLAGS ?= "${HOST_CC_ARCH} ${TOOLCHAIN_OPTIONS} ${CXXFLAGS}" +OECMAKE_C_FLAGS_RELEASE ?= "-DNDEBUG" +OECMAKE_CXX_FLAGS_RELEASE ?= "-DNDEBUG" +OECMAKE_C_LINK_FLAGS ?= "${HOST_CC_ARCH} ${TOOLCHAIN_OPTIONS} ${CPPFLAGS} ${LDFLAGS}" +OECMAKE_CXX_LINK_FLAGS ?= "${HOST_CC_ARCH} ${TOOLCHAIN_OPTIONS} ${CXXFLAGS} ${LDFLAGS}" + +def oecmake_map_compiler(compiler, d): + args = d.getVar(compiler).split() + if args[0] == "ccache": + return args[1], args[0] + return args[0], "" + +# C/C++ Compiler (without cpu arch/tune arguments) +OECMAKE_C_COMPILER ?= "${@oecmake_map_compiler('CC', d)[0]}" +OECMAKE_C_COMPILER_LAUNCHER ?= "${@oecmake_map_compiler('CC', d)[1]}" +OECMAKE_CXX_COMPILER ?= "${@oecmake_map_compiler('CXX', d)[0]}" +OECMAKE_CXX_COMPILER_LAUNCHER ?= "${@oecmake_map_compiler('CXX', d)[1]}" + +# clear compiler vars for allarch to avoid sig hash difference +OECMAKE_C_COMPILER_allarch = "" +OECMAKE_C_COMPILER_LAUNCHER_allarch = "" +OECMAKE_CXX_COMPILER_allarch = "" +OECMAKE_CXX_COMPILER_LAUNCHER_allarch = "" + +OECMAKE_RPATH ?= "" +OECMAKE_PERLNATIVE_DIR ??= "" +OECMAKE_EXTRA_ROOT_PATH ?= "" + +OECMAKE_FIND_ROOT_PATH_MODE_PROGRAM = "ONLY" +OECMAKE_FIND_ROOT_PATH_MODE_PROGRAM:class-native = "BOTH" + +EXTRA_OECMAKE:append = " ${PACKAGECONFIG_CONFARGS}" + +export CMAKE_BUILD_PARALLEL_LEVEL +CMAKE_BUILD_PARALLEL_LEVEL:task-compile = "${@oe.utils.parallel_make(d, False)}" +CMAKE_BUILD_PARALLEL_LEVEL:task-install = "${@oe.utils.parallel_make(d, True)}" + +OECMAKE_TARGET_COMPILE ?= "all" +OECMAKE_TARGET_INSTALL ?= "install" + +def map_host_os_to_system_name(host_os): + if host_os.startswith('darwin'): + return 'Darwin' + if host_os.startswith('mingw'): + return 'Windows' + if host_os.startswith('linux'): + return 'Linux' + return host_os + +# CMake expects target architectures in the format of uname(2), +# which do not always match TARGET_ARCH, so all the necessary +# conversions should happen here. +def map_host_arch_to_uname_arch(host_arch): + if host_arch == "powerpc": + return "ppc" + if host_arch == "powerpc64le": + return "ppc64le" + if host_arch == "powerpc64": + return "ppc64" + return host_arch + +cmake_do_generate_toolchain_file() { + if [ "${BUILD_SYS}" = "${HOST_SYS}" ]; then + cmake_crosscompiling="set( CMAKE_CROSSCOMPILING FALSE )" + fi + cat > ${WORKDIR}/toolchain.cmake <<EOF +# CMake system name must be something like "Linux". +# This is important for cross-compiling. +$cmake_crosscompiling +set( CMAKE_SYSTEM_NAME ${@map_host_os_to_system_name(d.getVar('HOST_OS'))} ) +set( CMAKE_SYSTEM_PROCESSOR ${@map_host_arch_to_uname_arch(d.getVar('HOST_ARCH'))} ) +set( CMAKE_C_COMPILER ${OECMAKE_C_COMPILER} ) +set( CMAKE_CXX_COMPILER ${OECMAKE_CXX_COMPILER} ) +set( CMAKE_C_COMPILER_LAUNCHER ${OECMAKE_C_COMPILER_LAUNCHER} ) +set( CMAKE_CXX_COMPILER_LAUNCHER ${OECMAKE_CXX_COMPILER_LAUNCHER} ) +set( CMAKE_ASM_COMPILER ${OECMAKE_C_COMPILER} ) +find_program( CMAKE_AR ${OECMAKE_AR} DOC "Archiver" REQUIRED ) + +set( CMAKE_C_FLAGS "${OECMAKE_C_FLAGS}" CACHE STRING "CFLAGS" ) +set( CMAKE_CXX_FLAGS "${OECMAKE_CXX_FLAGS}" CACHE STRING "CXXFLAGS" ) +set( CMAKE_ASM_FLAGS "${OECMAKE_C_FLAGS}" CACHE STRING "ASM FLAGS" ) +set( CMAKE_C_FLAGS_RELEASE "${OECMAKE_C_FLAGS_RELEASE}" CACHE STRING "Additional CFLAGS for release" ) +set( CMAKE_CXX_FLAGS_RELEASE "${OECMAKE_CXX_FLAGS_RELEASE}" CACHE STRING "Additional CXXFLAGS for release" ) +set( CMAKE_ASM_FLAGS_RELEASE "${OECMAKE_C_FLAGS_RELEASE}" CACHE STRING "Additional ASM FLAGS for release" ) +set( CMAKE_C_LINK_FLAGS "${OECMAKE_C_LINK_FLAGS}" CACHE STRING "LDFLAGS" ) +set( CMAKE_CXX_LINK_FLAGS "${OECMAKE_CXX_LINK_FLAGS}" CACHE STRING "LDFLAGS" ) + +# only search in the paths provided so cmake doesnt pick +# up libraries and tools from the native build machine +set( CMAKE_FIND_ROOT_PATH ${STAGING_DIR_HOST} ${STAGING_DIR_NATIVE} ${CROSS_DIR} ${OECMAKE_PERLNATIVE_DIR} ${OECMAKE_EXTRA_ROOT_PATH} ${EXTERNAL_TOOLCHAIN} ${HOSTTOOLS_DIR}) +set( CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY ) +set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ${OECMAKE_FIND_ROOT_PATH_MODE_PROGRAM} ) +set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) +set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) +set( CMAKE_PROGRAM_PATH "/" ) + +# Use qt.conf settings +set( ENV{QT_CONF_PATH} ${WORKDIR}/qt.conf ) + +# We need to set the rpath to the correct directory as cmake does not provide any +# directory as rpath by default +set( CMAKE_INSTALL_RPATH ${OECMAKE_RPATH} ) + +# Use RPATHs relative to build directory for reproducibility +set( CMAKE_BUILD_RPATH_USE_ORIGIN ON ) + +# Use our cmake modules +list(APPEND CMAKE_MODULE_PATH "${STAGING_DATADIR}/cmake/Modules/") + +# add for non /usr/lib libdir, e.g. /usr/lib64 +set( CMAKE_LIBRARY_PATH ${libdir} ${base_libdir}) + +# add include dir to implicit includes in case it differs from /usr/include +list(APPEND CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES ${includedir}) +list(APPEND CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES ${includedir}) + +EOF +} + +addtask generate_toolchain_file after do_patch before do_configure + +CONFIGURE_FILES = "CMakeLists.txt" + +do_configure[cleandirs] = "${@d.getVar('B') if d.getVar('S') != d.getVar('B') else ''}" + +cmake_do_configure() { + if [ "${OECMAKE_BUILDPATH}" ]; then + bbnote "cmake.bbclass no longer uses OECMAKE_BUILDPATH. The default behaviour is now out-of-tree builds with B=WORKDIR/build." + fi + + if [ "${S}" = "${B}" ]; then + find ${B} -name CMakeFiles -or -name Makefile -or -name cmake_install.cmake -or -name CMakeCache.txt -delete + fi + + # Just like autotools cmake can use a site file to cache result that need generated binaries to run + if [ -e ${WORKDIR}/site-file.cmake ] ; then + oecmake_sitefile="-C ${WORKDIR}/site-file.cmake" + else + oecmake_sitefile= + fi + + cmake \ + ${OECMAKE_GENERATOR_ARGS} \ + $oecmake_sitefile \ + ${OECMAKE_SOURCEPATH} \ + -DCMAKE_INSTALL_PREFIX:PATH=${prefix} \ + -DCMAKE_INSTALL_BINDIR:PATH=${@os.path.relpath(d.getVar('bindir'), d.getVar('prefix') + '/')} \ + -DCMAKE_INSTALL_SBINDIR:PATH=${@os.path.relpath(d.getVar('sbindir'), d.getVar('prefix') + '/')} \ + -DCMAKE_INSTALL_LIBEXECDIR:PATH=${@os.path.relpath(d.getVar('libexecdir'), d.getVar('prefix') + '/')} \ + -DCMAKE_INSTALL_SYSCONFDIR:PATH=${sysconfdir} \ + -DCMAKE_INSTALL_SHAREDSTATEDIR:PATH=${@os.path.relpath(d.getVar('sharedstatedir'), d. getVar('prefix') + '/')} \ + -DCMAKE_INSTALL_LOCALSTATEDIR:PATH=${localstatedir} \ + -DCMAKE_INSTALL_LIBDIR:PATH=${@os.path.relpath(d.getVar('libdir'), d.getVar('prefix') + '/')} \ + -DCMAKE_INSTALL_INCLUDEDIR:PATH=${@os.path.relpath(d.getVar('includedir'), d.getVar('prefix') + '/')} \ + -DCMAKE_INSTALL_DATAROOTDIR:PATH=${@os.path.relpath(d.getVar('datadir'), d.getVar('prefix') + '/')} \ + -DPYTHON_EXECUTABLE:PATH=${PYTHON} \ + -DPython_EXECUTABLE:PATH=${PYTHON} \ + -DPython3_EXECUTABLE:PATH=${PYTHON} \ + -DLIB_SUFFIX=${@d.getVar('baselib').replace('lib', '')} \ + -DCMAKE_INSTALL_SO_NO_EXE=0 \ + -DCMAKE_TOOLCHAIN_FILE=${WORKDIR}/toolchain.cmake \ + -DCMAKE_NO_SYSTEM_FROM_IMPORTED=1 \ + -DCMAKE_EXPORT_NO_PACKAGE_REGISTRY=ON \ + -DFETCHCONTENT_FULLY_DISCONNECTED=ON \ + ${EXTRA_OECMAKE} \ + -Wno-dev +} + +# To disable verbose cmake logs for a given recipe or globally config metadata e.g. local.conf +# add following +# +# CMAKE_VERBOSE = "" +# + +CMAKE_VERBOSE ??= "VERBOSE=1" + +# Then run do_compile again +cmake_runcmake_build() { + bbnote ${DESTDIR:+DESTDIR=${DESTDIR} }${CMAKE_VERBOSE} cmake --build '${B}' "$@" -- ${EXTRA_OECMAKE_BUILD} + eval ${DESTDIR:+DESTDIR=${DESTDIR} }${CMAKE_VERBOSE} cmake --build '${B}' "$@" -- ${EXTRA_OECMAKE_BUILD} +} + +cmake_do_compile() { + cmake_runcmake_build --target ${OECMAKE_TARGET_COMPILE} +} + +cmake_do_install() { + DESTDIR='${D}' cmake_runcmake_build --target ${OECMAKE_TARGET_INSTALL} +} + +EXPORT_FUNCTIONS do_configure do_compile do_install do_generate_toolchain_file diff --git a/classes/package.bbclass b/classes/package.bbclass new file mode 100644 index 0000000..8f5825e --- /dev/null +++ b/classes/package.bbclass @@ -0,0 +1,2552 @@ +# +# Packaging process +# +# Executive summary: This class iterates over the functions listed in PACKAGEFUNCS +# Taking D and splitting it up into the packages listed in PACKAGES, placing the +# resulting output in PKGDEST. +# +# There are the following default steps but PACKAGEFUNCS can be extended: +# +# a) package_convert_pr_autoinc - convert AUTOINC in PKGV to ${PRSERV_PV_AUTOINC} +# +# b) perform_packagecopy - Copy D into PKGD +# +# c) package_do_split_locales - Split out the locale files, updates FILES and PACKAGES +# +# d) split_and_strip_files - split the files into runtime and debug and strip them. +# Debug files include debug info split, and associated sources that end up in -dbg packages +# +# e) fixup_perms - Fix up permissions in the package before we split it. +# +# f) populate_packages - Split the files in PKGD into separate packages in PKGDEST/<pkgname> +# Also triggers the binary stripping code to put files in -dbg packages. +# +# g) package_do_filedeps - Collect perfile run-time dependency metadata +# The data is stores in FILER{PROVIDES,DEPENDS}_file_pkg variables with +# a list of affected files in FILER{PROVIDES,DEPENDS}FLIST_pkg +# +# h) package_do_shlibs - Look at the shared libraries generated and autotmatically add any +# dependencies found. Also stores the package name so anyone else using this library +# knows which package to depend on. +# +# i) package_do_pkgconfig - Keep track of which packages need and provide which .pc files +# +# j) read_shlibdeps - Reads the stored shlibs information into the metadata +# +# k) package_depchains - Adds automatic dependencies to -dbg and -dev packages +# +# l) emit_pkgdata - saves the packaging data into PKGDATA_DIR for use in later +# packaging steps + +inherit packagedata +inherit chrpath +inherit package_pkgdata +inherit insane + +PKGD = "${WORKDIR}/package" +PKGDEST = "${WORKDIR}/packages-split" + +LOCALE_SECTION ?= '' + +ALL_MULTILIB_PACKAGE_ARCHS = "${@all_multilib_tune_values(d, 'PACKAGE_ARCHS')}" + +# rpm is used for the per-file dependency identification +# dwarfsrcfiles is used to determine the list of debug source files +PACKAGE_DEPENDS += "rpm-native dwarfsrcfiles-native" + + +# If your postinstall can execute at rootfs creation time rather than on +# target but depends on a native/cross tool in order to execute, you need to +# list that tool in PACKAGE_WRITE_DEPS. Target package dependencies belong +# in the package dependencies as normal, this is just for native/cross support +# tools at rootfs build time. +PACKAGE_WRITE_DEPS ??= "" + +def legitimize_package_name(s): + """ + Make sure package names are legitimate strings + """ + import re + + def fixutf(m): + cp = m.group(1) + if cp: + return ('\\u%s' % cp).encode('latin-1').decode('unicode_escape') + + # Handle unicode codepoints encoded as <U0123>, as in glibc locale files. + s = re.sub(r'<U([0-9A-Fa-f]{1,4})>', fixutf, s) + + # Remaining package name validity fixes + return s.lower().replace('_', '-').replace('@', '+').replace(',', '+').replace('/', '-') + +def do_split_packages(d, root, file_regex, output_pattern, description, postinst=None, recursive=False, hook=None, extra_depends=None, aux_files_pattern=None, postrm=None, allow_dirs=False, prepend=False, match_path=False, aux_files_pattern_verbatim=None, allow_links=False, summary=None): + """ + Used in .bb files to split up dynamically generated subpackages of a + given package, usually plugins or modules. + + Arguments: + root -- the path in which to search + file_regex -- regular expression to match searched files. Use + parentheses () to mark the part of this expression + that should be used to derive the module name (to be + substituted where %s is used in other function + arguments as noted below) + output_pattern -- pattern to use for the package names. Must include %s. + description -- description to set for each package. Must include %s. + postinst -- postinstall script to use for all packages (as a + string) + recursive -- True to perform a recursive search - default False + hook -- a hook function to be called for every match. The + function will be called with the following arguments + (in the order listed): + f: full path to the file/directory match + pkg: the package name + file_regex: as above + output_pattern: as above + modulename: the module name derived using file_regex + extra_depends -- extra runtime dependencies (RDEPENDS) to be set for + all packages. The default value of None causes a + dependency on the main package (${PN}) - if you do + not want this, pass '' for this parameter. + aux_files_pattern -- extra item(s) to be added to FILES for each + package. Can be a single string item or a list of + strings for multiple items. Must include %s. + postrm -- postrm script to use for all packages (as a string) + allow_dirs -- True allow directories to be matched - default False + prepend -- if True, prepend created packages to PACKAGES instead + of the default False which appends them + match_path -- match file_regex on the whole relative path to the + root rather than just the file name + aux_files_pattern_verbatim -- extra item(s) to be added to FILES for + each package, using the actual derived module name + rather than converting it to something legal for a + package name. Can be a single string item or a list + of strings for multiple items. Must include %s. + allow_links -- True to allow symlinks to be matched - default False + summary -- Summary to set for each package. Must include %s; + defaults to description if not set. + + """ + + dvar = d.getVar('PKGD') + root = d.expand(root) + output_pattern = d.expand(output_pattern) + extra_depends = d.expand(extra_depends) + + # If the root directory doesn't exist, don't error out later but silently do + # no splitting. + if not os.path.exists(dvar + root): + return [] + + ml = d.getVar("MLPREFIX") + if ml: + if not output_pattern.startswith(ml): + output_pattern = ml + output_pattern + + newdeps = [] + for dep in (extra_depends or "").split(): + if dep.startswith(ml): + newdeps.append(dep) + else: + newdeps.append(ml + dep) + if newdeps: + extra_depends = " ".join(newdeps) + + + packages = d.getVar('PACKAGES').split() + split_packages = set() + + if postinst: + postinst = '#!/bin/sh\n' + postinst + '\n' + if postrm: + postrm = '#!/bin/sh\n' + postrm + '\n' + if not recursive: + objs = os.listdir(dvar + root) + else: + objs = [] + for walkroot, dirs, files in os.walk(dvar + root): + for file in files: + relpath = os.path.join(walkroot, file).replace(dvar + root + '/', '', 1) + if relpath: + objs.append(relpath) + + if extra_depends == None: + extra_depends = d.getVar("PN") + + if not summary: + summary = description + + for o in sorted(objs): + import re, stat + if match_path: + m = re.match(file_regex, o) + else: + m = re.match(file_regex, os.path.basename(o)) + + if not m: + continue + f = os.path.join(dvar + root, o) + mode = os.lstat(f).st_mode + if not (stat.S_ISREG(mode) or (allow_links and stat.S_ISLNK(mode)) or (allow_dirs and stat.S_ISDIR(mode))): + continue + on = legitimize_package_name(m.group(1)) + pkg = output_pattern % on + split_packages.add(pkg) + if not pkg in packages: + if prepend: + packages = [pkg] + packages + else: + packages.append(pkg) + oldfiles = d.getVar('FILES:' + pkg) + newfile = os.path.join(root, o) + # These names will be passed through glob() so if the filename actually + # contains * or ? (rare, but possible) we need to handle that specially + newfile = newfile.replace('*', '[*]') + newfile = newfile.replace('?', '[?]') + if not oldfiles: + the_files = [newfile] + if aux_files_pattern: + if type(aux_files_pattern) is list: + for fp in aux_files_pattern: + the_files.append(fp % on) + else: + the_files.append(aux_files_pattern % on) + if aux_files_pattern_verbatim: + if type(aux_files_pattern_verbatim) is list: + for fp in aux_files_pattern_verbatim: + the_files.append(fp % m.group(1)) + else: + the_files.append(aux_files_pattern_verbatim % m.group(1)) + d.setVar('FILES:' + pkg, " ".join(the_files)) + else: + d.setVar('FILES:' + pkg, oldfiles + " " + newfile) + if extra_depends != '': + d.appendVar('RDEPENDS:' + pkg, ' ' + extra_depends) + if not d.getVar('DESCRIPTION:' + pkg): + d.setVar('DESCRIPTION:' + pkg, description % on) + if not d.getVar('SUMMARY:' + pkg): + d.setVar('SUMMARY:' + pkg, summary % on) + if postinst: + d.setVar('pkg_postinst:' + pkg, postinst) + if postrm: + d.setVar('pkg_postrm:' + pkg, postrm) + if callable(hook): + hook(f, pkg, file_regex, output_pattern, m.group(1)) + + d.setVar('PACKAGES', ' '.join(packages)) + return list(split_packages) + +PACKAGE_DEPENDS += "file-native" + +python () { + if d.getVar('PACKAGES') != '': + deps = "" + for dep in (d.getVar('PACKAGE_DEPENDS') or "").split(): + deps += " %s:do_populate_sysroot" % dep + if d.getVar('PACKAGE_MINIDEBUGINFO') == '1': + deps += ' xz-native:do_populate_sysroot' + d.appendVarFlag('do_package', 'depends', deps) + + # shlibs requires any DEPENDS to have already packaged for the *.list files + d.appendVarFlag('do_package', 'deptask', " do_packagedata") +} + +# Get a list of files from file vars by searching files under current working directory +# The list contains symlinks, directories and normal files. +def files_from_filevars(filevars): + import os,glob + cpath = oe.cachedpath.CachedPath() + files = [] + for f in filevars: + if os.path.isabs(f): + f = '.' + f + if not f.startswith("./"): + f = './' + f + globbed = glob.glob(f) + if globbed: + if [ f ] != globbed: + files += globbed + continue + files.append(f) + + symlink_paths = [] + for ind, f in enumerate(files): + # Handle directory symlinks. Truncate path to the lowest level symlink + parent = '' + for dirname in f.split('/')[:-1]: + parent = os.path.join(parent, dirname) + if dirname == '.': + continue + if cpath.islink(parent): + bb.warn("FILES contains file '%s' which resides under a " + "directory symlink. Please fix the recipe and use the " + "real path for the file." % f[1:]) + symlink_paths.append(f) + files[ind] = parent + f = parent + break + + if not cpath.islink(f): + if cpath.isdir(f): + newfiles = [ os.path.join(f,x) for x in os.listdir(f) ] + if newfiles: + files += newfiles + + return files, symlink_paths + +# Called in package_<rpm,ipk,deb>.bbclass to get the correct list of configuration files +def get_conffiles(pkg, d): + pkgdest = d.getVar('PKGDEST') + root = os.path.join(pkgdest, pkg) + cwd = os.getcwd() + os.chdir(root) + + conffiles = d.getVar('CONFFILES:%s' % pkg); + if conffiles == None: + conffiles = d.getVar('CONFFILES') + if conffiles == None: + conffiles = "" + conffiles = conffiles.split() + conf_orig_list = files_from_filevars(conffiles)[0] + + # Remove links and directories from conf_orig_list to get conf_list which only contains normal files + conf_list = [] + for f in conf_orig_list: + if os.path.isdir(f): + continue + if os.path.islink(f): + continue + if not os.path.exists(f): + continue + conf_list.append(f) + + # Remove the leading './' + for i in range(0, len(conf_list)): + conf_list[i] = conf_list[i][1:] + + os.chdir(cwd) + return conf_list + +def checkbuildpath(file, d): + tmpdir = d.getVar('TMPDIR') + with open(file) as f: + file_content = f.read() + if tmpdir in file_content: + return True + + return False + +def parse_debugsources_from_dwarfsrcfiles_output(dwarfsrcfiles_output): + debugfiles = {} + + for line in dwarfsrcfiles_output.splitlines(): + if line.startswith("\t"): + debugfiles[os.path.normpath(line.split()[0])] = "" + + return debugfiles.keys() + +def source_info(file, d, fatal=True): + import subprocess + + cmd = ["dwarfsrcfiles", file] + try: + output = subprocess.check_output(cmd, universal_newlines=True, stderr=subprocess.STDOUT) + retval = 0 + except subprocess.CalledProcessError as exc: + output = exc.output + retval = exc.returncode + + # 255 means a specific file wasn't fully parsed to get the debug file list, which is not a fatal failure + if retval != 0 and retval != 255: + msg = "dwarfsrcfiles failed with exit code %s (cmd was %s)%s" % (retval, cmd, ":\n%s" % output if output else "") + if fatal: + bb.fatal(msg) + bb.note(msg) + + debugsources = parse_debugsources_from_dwarfsrcfiles_output(output) + + return list(debugsources) + +def splitdebuginfo(file, dvar, dv, d): + # Function to split a single file into two components, one is the stripped + # target system binary, the other contains any debugging information. The + # two files are linked to reference each other. + # + # return a mapping of files:debugsources + + import stat + import subprocess + + src = file[len(dvar):] + dest = dv["libdir"] + os.path.dirname(src) + dv["dir"] + "/" + os.path.basename(src) + dv["append"] + debugfile = dvar + dest + sources = [] + + if file.endswith(".ko") and file.find("/lib/modules/") != -1: + if oe.package.is_kernel_module_signed(file): + bb.debug(1, "Skip strip on signed module %s" % file) + return (file, sources) + + # Split the file... + bb.utils.mkdirhier(os.path.dirname(debugfile)) + #bb.note("Split %s -> %s" % (file, debugfile)) + # Only store off the hard link reference if we successfully split! + + dvar = d.getVar('PKGD') + objcopy = d.getVar("OBJCOPY") + + newmode = None + if not os.access(file, os.W_OK) or os.access(file, os.R_OK): + origmode = os.stat(file)[stat.ST_MODE] + newmode = origmode | stat.S_IWRITE | stat.S_IREAD + os.chmod(file, newmode) + + # We need to extract the debug src information here... + if dv["srcdir"]: + sources = source_info(file, d) + + bb.utils.mkdirhier(os.path.dirname(debugfile)) + + subprocess.check_output([objcopy, '--only-keep-debug', file, debugfile], stderr=subprocess.STDOUT) + + # Set the debuglink to have the view of the file path on the target + subprocess.check_output([objcopy, '--add-gnu-debuglink', debugfile, file], stderr=subprocess.STDOUT) + + if newmode: + os.chmod(file, origmode) + + return (file, sources) + +def splitstaticdebuginfo(file, dvar, dv, d): + # Unlike the function above, there is no way to split a static library + # two components. So to get similar results we will copy the unmodified + # static library (containing the debug symbols) into a new directory. + # We will then strip (preserving symbols) the static library in the + # typical location. + # + # return a mapping of files:debugsources + + import stat + + src = file[len(dvar):] + dest = dv["staticlibdir"] + os.path.dirname(src) + dv["staticdir"] + "/" + os.path.basename(src) + dv["staticappend"] + debugfile = dvar + dest + sources = [] + + # Copy the file... + bb.utils.mkdirhier(os.path.dirname(debugfile)) + #bb.note("Copy %s -> %s" % (file, debugfile)) + + dvar = d.getVar('PKGD') + + newmode = None + if not os.access(file, os.W_OK) or os.access(file, os.R_OK): + origmode = os.stat(file)[stat.ST_MODE] + newmode = origmode | stat.S_IWRITE | stat.S_IREAD + os.chmod(file, newmode) + + # We need to extract the debug src information here... + if dv["srcdir"]: + sources = source_info(file, d) + + bb.utils.mkdirhier(os.path.dirname(debugfile)) + + # Copy the unmodified item to the debug directory + shutil.copy2(file, debugfile) + + if newmode: + os.chmod(file, origmode) + + return (file, sources) + +def inject_minidebuginfo(file, dvar, dv, d): + # Extract just the symbols from debuginfo into minidebuginfo, + # compress it with xz and inject it back into the binary in a .gnu_debugdata section. + # https://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html + + import subprocess + + readelf = d.getVar('READELF') + nm = d.getVar('NM') + objcopy = d.getVar('OBJCOPY') + + minidebuginfodir = d.expand('${WORKDIR}/minidebuginfo') + + src = file[len(dvar):] + dest = dv["libdir"] + os.path.dirname(src) + dv["dir"] + "/" + os.path.basename(src) + dv["append"] + debugfile = dvar + dest + minidebugfile = minidebuginfodir + src + '.minidebug' + bb.utils.mkdirhier(os.path.dirname(minidebugfile)) + + # If we didn't produce debuginfo for any reason, we can't produce minidebuginfo either + # so skip it. + if not os.path.exists(debugfile): + bb.debug(1, 'ELF file {} has no debuginfo, skipping minidebuginfo injection'.format(file)) + return + + # Find non-allocated PROGBITS, NOTE, and NOBITS sections in the debuginfo. + # We will exclude all of these from minidebuginfo to save space. + remove_section_names = [] + for line in subprocess.check_output([readelf, '-W', '-S', debugfile], universal_newlines=True).splitlines(): + fields = line.split() + if len(fields) < 8: + continue + name = fields[0] + type = fields[1] + flags = fields[7] + # .debug_ sections will be removed by objcopy -S so no need to explicitly remove them + if name.startswith('.debug_'): + continue + if 'A' not in flags and type in ['PROGBITS', 'NOTE', 'NOBITS']: + remove_section_names.append(name) + + # List dynamic symbols in the binary. We can exclude these from minidebuginfo + # because they are always present in the binary. + dynsyms = set() + for line in subprocess.check_output([nm, '-D', file, '--format=posix', '--defined-only'], universal_newlines=True).splitlines(): + dynsyms.add(line.split()[0]) + + # Find all function symbols from debuginfo which aren't in the dynamic symbols table. + # These are the ones we want to keep in minidebuginfo. + keep_symbols_file = minidebugfile + '.symlist' + found_any_symbols = False + with open(keep_symbols_file, 'w') as f: + for line in subprocess.check_output([nm, debugfile, '--format=sysv', '--defined-only'], universal_newlines=True).splitlines(): + fields = line.split('|') + if len(fields) < 7: + continue + name = fields[0].strip() + type = fields[3].strip() + if type == 'FUNC' and name not in dynsyms: + f.write('{}\n'.format(name)) + found_any_symbols = True + + if not found_any_symbols: + bb.debug(1, 'ELF file {} contains no symbols, skipping minidebuginfo injection'.format(file)) + return + + bb.utils.remove(minidebugfile) + bb.utils.remove(minidebugfile + '.xz') + + subprocess.check_call([objcopy, '-S'] + + ['--remove-section={}'.format(s) for s in remove_section_names] + + ['--keep-symbols={}'.format(keep_symbols_file), debugfile, minidebugfile]) + + subprocess.check_call(['xz', '--keep', minidebugfile]) + + subprocess.check_call([objcopy, '--add-section', '.gnu_debugdata={}.xz'.format(minidebugfile), file]) + +def copydebugsources(debugsrcdir, sources, d): + # The debug src information written out to sourcefile is further processed + # and copied to the destination here. + + import stat + import subprocess + + if debugsrcdir and sources: + sourcefile = d.expand("${WORKDIR}/debugsources.list") + bb.utils.remove(sourcefile) + + # filenames are null-separated - this is an artefact of the previous use + # of rpm's debugedit, which was writing them out that way, and the code elsewhere + # is still assuming that. + debuglistoutput = '\0'.join(sources) + '\0' + with open(sourcefile, 'a') as sf: + sf.write(debuglistoutput) + + dvar = d.getVar('PKGD') + strip = d.getVar("STRIP") + objcopy = d.getVar("OBJCOPY") + workdir = d.getVar("WORKDIR") + sdir = d.getVar("S") + sparentdir = os.path.dirname(os.path.dirname(sdir)) + sbasedir = os.path.basename(os.path.dirname(sdir)) + "/" + os.path.basename(sdir) + workparentdir = os.path.dirname(os.path.dirname(workdir)) + workbasedir = os.path.basename(os.path.dirname(workdir)) + "/" + os.path.basename(workdir) + + # If S isnt based on WORKDIR we can infer our sources are located elsewhere, + # e.g. using externalsrc; use S as base for our dirs + if workdir in sdir or 'work-shared' in sdir: + basedir = workbasedir + parentdir = workparentdir + else: + basedir = sbasedir + parentdir = sparentdir + + # If build path exists in sourcefile, it means toolchain did not use + # -fdebug-prefix-map to compile + if checkbuildpath(sourcefile, d): + localsrc_prefix = parentdir + "/" + else: + localsrc_prefix = "/usr/src/debug/" + + nosuchdir = [] + basepath = dvar + for p in debugsrcdir.split("/"): + basepath = basepath + "/" + p + if not cpath.exists(basepath): + nosuchdir.append(basepath) + bb.utils.mkdirhier(basepath) + cpath.updatecache(basepath) + + # Ignore files from the recipe sysroots (target and native) + processdebugsrc = "LC_ALL=C ; sort -z -u '%s' | egrep -v -z '((<internal>|<built-in>)$|/.*recipe-sysroot.*/)' | " + # We need to ignore files that are not actually ours + # we do this by only paying attention to items from this package + processdebugsrc += "fgrep -zw '%s' | " + # Remove prefix in the source paths + processdebugsrc += "sed 's#%s##g' | " + processdebugsrc += "(cd '%s' ; cpio -pd0mlL --no-preserve-owner '%s%s' 2>/dev/null)" + + cmd = processdebugsrc % (sourcefile, basedir, localsrc_prefix, parentdir, dvar, debugsrcdir) + try: + subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT) + except subprocess.CalledProcessError: + # Can "fail" if internal headers/transient sources are attempted + pass + + # cpio seems to have a bug with -lL together and symbolic links are just copied, not dereferenced. + # Work around this by manually finding and copying any symbolic links that made it through. + cmd = "find %s%s -type l -print0 -delete | sed s#%s%s/##g | (cd '%s' ; cpio -pd0mL --no-preserve-owner '%s%s')" % \ + (dvar, debugsrcdir, dvar, debugsrcdir, parentdir, dvar, debugsrcdir) + subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT) + + + # debugsources.list may be polluted from the host if we used externalsrc, + # cpio uses copy-pass and may have just created a directory structure + # matching the one from the host, if thats the case move those files to + # debugsrcdir to avoid host contamination. + # Empty dir structure will be deleted in the next step. + + # Same check as above for externalsrc + if workdir not in sdir: + if os.path.exists(dvar + debugsrcdir + sdir): + cmd = "mv %s%s%s/* %s%s" % (dvar, debugsrcdir, sdir, dvar,debugsrcdir) + subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT) + + # The copy by cpio may have resulted in some empty directories! Remove these + cmd = "find %s%s -empty -type d -delete" % (dvar, debugsrcdir) + subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT) + + # Also remove debugsrcdir if its empty + for p in nosuchdir[::-1]: + if os.path.exists(p) and not os.listdir(p): + os.rmdir(p) + +# +# Package data handling routines +# + +def get_package_mapping (pkg, basepkg, d, depversions=None): + import oe.packagedata + + data = oe.packagedata.read_subpkgdata(pkg, d) + key = "PKG:%s" % pkg + + if key in data: + if bb.data.inherits_class('allarch', d) and bb.data.inherits_class('packagegroup', d) and pkg != data[key]: + bb.error("An allarch packagegroup shouldn't depend on packages which are dynamically renamed (%s to %s)" % (pkg, data[key])) + # Have to avoid undoing the write_extra_pkgs(global_variants...) + if bb.data.inherits_class('allarch', d) and not d.getVar('MULTILIB_VARIANTS') \ + and data[key] == basepkg: + return pkg + if depversions == []: + # Avoid returning a mapping if the renamed package rprovides its original name + rprovkey = "RPROVIDES:%s" % pkg + if rprovkey in data: + if pkg in bb.utils.explode_dep_versions2(data[rprovkey]): + bb.note("%s rprovides %s, not replacing the latter" % (data[key], pkg)) + return pkg + # Do map to rewritten package name + return data[key] + + return pkg + +def get_package_additional_metadata (pkg_type, d): + base_key = "PACKAGE_ADD_METADATA" + for key in ("%s_%s" % (base_key, pkg_type.upper()), base_key): + if d.getVar(key, False) is None: + continue + d.setVarFlag(key, "type", "list") + if d.getVarFlag(key, "separator") is None: + d.setVarFlag(key, "separator", "\\n") + metadata_fields = [field.strip() for field in oe.data.typed_value(key, d)] + return "\n".join(metadata_fields).strip() + +def runtime_mapping_rename (varname, pkg, d): + #bb.note("%s before: %s" % (varname, d.getVar(varname))) + + new_depends = {} + deps = bb.utils.explode_dep_versions2(d.getVar(varname) or "") + for depend, depversions in deps.items(): + new_depend = get_package_mapping(depend, pkg, d, depversions) + if depend != new_depend: + bb.note("package name mapping done: %s -> %s" % (depend, new_depend)) + new_depends[new_depend] = deps[depend] + + d.setVar(varname, bb.utils.join_deps(new_depends, commasep=False)) + + #bb.note("%s after: %s" % (varname, d.getVar(varname))) + +# +# Used by do_packagedata (and possibly other routines post do_package) +# + +PRSERV_ACTIVE = "${@bool(d.getVar("PRSERV_HOST"))}" +PRSERV_ACTIVE[vardepvalue] = "${PRSERV_ACTIVE}" +package_get_auto_pr[vardepsexclude] = "BB_TASKDEPDATA" +package_get_auto_pr[vardeps] += "PRSERV_ACTIVE" +python package_get_auto_pr() { + import oe.prservice + + def get_do_package_hash(pn): + if d.getVar("BB_RUNTASK") != "do_package": + taskdepdata = d.getVar("BB_TASKDEPDATA", False) + for dep in taskdepdata: + if taskdepdata[dep][1] == "do_package" and taskdepdata[dep][0] == pn: + return taskdepdata[dep][6] + return None + + # Support per recipe PRSERV_HOST + pn = d.getVar('PN') + host = d.getVar("PRSERV_HOST_" + pn) + if not (host is None): + d.setVar("PRSERV_HOST", host) + + pkgv = d.getVar("PKGV") + + # PR Server not active, handle AUTOINC + if not d.getVar('PRSERV_HOST'): + d.setVar("PRSERV_PV_AUTOINC", "0") + return + + auto_pr = None + pv = d.getVar("PV") + version = d.getVar("PRAUTOINX") + pkgarch = d.getVar("PACKAGE_ARCH") + checksum = get_do_package_hash(pn) + + # If do_package isn't in the dependencies, we can't get the checksum... + if not checksum: + bb.warn('Task %s requested do_package unihash, but it was not available.' % d.getVar('BB_RUNTASK')) + #taskdepdata = d.getVar("BB_TASKDEPDATA", False) + #for dep in taskdepdata: + # bb.warn('%s:%s = %s' % (taskdepdata[dep][0], taskdepdata[dep][1], taskdepdata[dep][6])) + return + + if d.getVar('PRSERV_LOCKDOWN'): + auto_pr = d.getVar('PRAUTO_' + version + '_' + pkgarch) or d.getVar('PRAUTO_' + version) or None + if auto_pr is None: + bb.fatal("Can NOT get PRAUTO from lockdown exported file") + d.setVar('PRAUTO',str(auto_pr)) + return + + try: + conn = oe.prservice.prserv_make_conn(d) + if conn is not None: + if "AUTOINC" in pkgv: + srcpv = bb.fetch2.get_srcrev(d) + base_ver = "AUTOINC-%s" % version[:version.find(srcpv)] + value = conn.getPR(base_ver, pkgarch, srcpv) + d.setVar("PRSERV_PV_AUTOINC", str(value)) + + auto_pr = conn.getPR(version, pkgarch, checksum) + conn.close() + except Exception as e: + bb.fatal("Can NOT get PRAUTO, exception %s" % str(e)) + if auto_pr is None: + bb.fatal("Can NOT get PRAUTO from remote PR service") + d.setVar('PRAUTO',str(auto_pr)) +} + +# +# Package functions suitable for inclusion in PACKAGEFUNCS +# + +python package_convert_pr_autoinc() { + pkgv = d.getVar("PKGV") + + # Adjust pkgv as necessary... + if 'AUTOINC' in pkgv: + d.setVar("PKGV", pkgv.replace("AUTOINC", "${PRSERV_PV_AUTOINC}")) + + # Change PRSERV_PV_AUTOINC and EXTENDPRAUTO usage to special values + d.setVar('PRSERV_PV_AUTOINC', '@PRSERV_PV_AUTOINC@') + d.setVar('EXTENDPRAUTO', '@EXTENDPRAUTO@') +} + +LOCALEBASEPN ??= "${PN}" + +python package_do_split_locales() { + if (d.getVar('PACKAGE_NO_LOCALE') == '1'): + bb.debug(1, "package requested not splitting locales") + return + + packages = (d.getVar('PACKAGES') or "").split() + + datadir = d.getVar('datadir') + if not datadir: + bb.note("datadir not defined") + return + + dvar = d.getVar('PKGD') + pn = d.getVar('LOCALEBASEPN') + + if pn + '-locale' in packages: + packages.remove(pn + '-locale') + + localedir = os.path.join(dvar + datadir, 'locale') + + if not cpath.isdir(localedir): + bb.debug(1, "No locale files in this package") + return + + locales = os.listdir(localedir) + + summary = d.getVar('SUMMARY') or pn + description = d.getVar('DESCRIPTION') or "" + locale_section = d.getVar('LOCALE_SECTION') + mlprefix = d.getVar('MLPREFIX') or "" + for l in sorted(locales): + ln = legitimize_package_name(l) + pkg = pn + '-locale-' + ln + packages.append(pkg) + d.setVar('FILES:' + pkg, os.path.join(datadir, 'locale', l)) + d.setVar('RRECOMMENDS:' + pkg, '%svirtual-locale-%s' % (mlprefix, ln)) + d.setVar('RPROVIDES:' + pkg, '%s-locale %s%s-translation' % (pn, mlprefix, ln)) + d.setVar('SUMMARY:' + pkg, '%s - %s translations' % (summary, l)) + d.setVar('DESCRIPTION:' + pkg, '%s This package contains language translation files for the %s locale.' % (description, l)) + if locale_section: + d.setVar('SECTION:' + pkg, locale_section) + + d.setVar('PACKAGES', ' '.join(packages)) + + # Disabled by RP 18/06/07 + # Wildcards aren't supported in debian + # They break with ipkg since glibc-locale* will mean that + # glibc-localedata-translit* won't install as a dependency + # for some other package which breaks meta-toolchain + # Probably breaks since virtual-locale- isn't provided anywhere + #rdep = (d.getVar('RDEPENDS:%s' % pn) or "").split() + #rdep.append('%s-locale*' % pn) + #d.setVar('RDEPENDS:%s' % pn, ' '.join(rdep)) +} + +python perform_packagecopy () { + import subprocess + import shutil + + dest = d.getVar('D') + dvar = d.getVar('PKGD') + + # Start by package population by taking a copy of the installed + # files to operate on + # Preserve sparse files and hard links + cmd = 'tar --exclude=./sysroot-only -cf - -C %s -p -S . | tar -xf - -C %s' % (dest, dvar) + subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT) + + # replace RPATHs for the nativesdk binaries, to make them relocatable + if bb.data.inherits_class('nativesdk', d) or bb.data.inherits_class('cross-canadian', d): + rpath_replace (dvar, d) +} +perform_packagecopy[cleandirs] = "${PKGD}" +perform_packagecopy[dirs] = "${PKGD}" + +# We generate a master list of directories to process, we start by +# seeding this list with reasonable defaults, then load from +# the fs-perms.txt files +python fixup_perms () { + import pwd, grp + + # init using a string with the same format as a line as documented in + # the fs-perms.txt file + # <path> <mode> <uid> <gid> <walk> <fmode> <fuid> <fgid> + # <path> link <link target> + # + # __str__ can be used to print out an entry in the input format + # + # if fs_perms_entry.path is None: + # an error occurred + # if fs_perms_entry.link, you can retrieve: + # fs_perms_entry.path = path + # fs_perms_entry.link = target of link + # if not fs_perms_entry.link, you can retrieve: + # fs_perms_entry.path = path + # fs_perms_entry.mode = expected dir mode or None + # fs_perms_entry.uid = expected uid or -1 + # fs_perms_entry.gid = expected gid or -1 + # fs_perms_entry.walk = 'true' or something else + # fs_perms_entry.fmode = expected file mode or None + # fs_perms_entry.fuid = expected file uid or -1 + # fs_perms_entry_fgid = expected file gid or -1 + class fs_perms_entry(): + def __init__(self, line): + lsplit = line.split() + if len(lsplit) == 3 and lsplit[1].lower() == "link": + self._setlink(lsplit[0], lsplit[2]) + elif len(lsplit) == 8: + self._setdir(lsplit[0], lsplit[1], lsplit[2], lsplit[3], lsplit[4], lsplit[5], lsplit[6], lsplit[7]) + else: + msg = "Fixup Perms: invalid config line %s" % line + oe.qa.handle_error("perm-config", msg, d) + self.path = None + self.link = None + + def _setdir(self, path, mode, uid, gid, walk, fmode, fuid, fgid): + self.path = os.path.normpath(path) + self.link = None + self.mode = self._procmode(mode) + self.uid = self._procuid(uid) + self.gid = self._procgid(gid) + self.walk = walk.lower() + self.fmode = self._procmode(fmode) + self.fuid = self._procuid(fuid) + self.fgid = self._procgid(fgid) + + def _setlink(self, path, link): + self.path = os.path.normpath(path) + self.link = link + + def _procmode(self, mode): + if not mode or (mode and mode == "-"): + return None + else: + return int(mode,8) + + # Note uid/gid -1 has special significance in os.lchown + def _procuid(self, uid): + if uid is None or uid == "-": + return -1 + elif uid.isdigit(): + return int(uid) + else: + return pwd.getpwnam(uid).pw_uid + + def _procgid(self, gid): + if gid is None or gid == "-": + return -1 + elif gid.isdigit(): + return int(gid) + else: + return grp.getgrnam(gid).gr_gid + + # Use for debugging the entries + def __str__(self): + if self.link: + return "%s link %s" % (self.path, self.link) + else: + mode = "-" + if self.mode: + mode = "0%o" % self.mode + fmode = "-" + if self.fmode: + fmode = "0%o" % self.fmode + uid = self._mapugid(self.uid) + gid = self._mapugid(self.gid) + fuid = self._mapugid(self.fuid) + fgid = self._mapugid(self.fgid) + return "%s %s %s %s %s %s %s %s" % (self.path, mode, uid, gid, self.walk, fmode, fuid, fgid) + + def _mapugid(self, id): + if id is None or id == -1: + return "-" + else: + return "%d" % id + + # Fix the permission, owner and group of path + def fix_perms(path, mode, uid, gid, dir): + if mode and not os.path.islink(path): + #bb.note("Fixup Perms: chmod 0%o %s" % (mode, dir)) + os.chmod(path, mode) + # -1 is a special value that means don't change the uid/gid + # if they are BOTH -1, don't bother to lchown + if not (uid == -1 and gid == -1): + #bb.note("Fixup Perms: lchown %d:%d %s" % (uid, gid, dir)) + os.lchown(path, uid, gid) + + # Return a list of configuration files based on either the default + # files/fs-perms.txt or the contents of FILESYSTEM_PERMS_TABLES + # paths are resolved via BBPATH + def get_fs_perms_list(d): + str = "" + bbpath = d.getVar('BBPATH') + fs_perms_tables = d.getVar('FILESYSTEM_PERMS_TABLES') or "" + for conf_file in fs_perms_tables.split(): + confpath = bb.utils.which(bbpath, conf_file) + if confpath: + str += " %s" % bb.utils.which(bbpath, conf_file) + else: + bb.warn("cannot find %s specified in FILESYSTEM_PERMS_TABLES" % conf_file) + return str + + + + dvar = d.getVar('PKGD') + + fs_perms_table = {} + fs_link_table = {} + + # By default all of the standard directories specified in + # bitbake.conf will get 0755 root:root. + target_path_vars = [ 'base_prefix', + 'prefix', + 'exec_prefix', + 'base_bindir', + 'base_sbindir', + 'base_libdir', + 'datadir', + 'sysconfdir', + 'servicedir', + 'sharedstatedir', + 'localstatedir', + 'infodir', + 'mandir', + 'docdir', + 'bindir', + 'sbindir', + 'libexecdir', + 'libdir', + 'includedir', + 'oldincludedir' ] + + for path in target_path_vars: + dir = d.getVar(path) or "" + if dir == "": + continue + fs_perms_table[dir] = fs_perms_entry(d.expand("%s 0755 root root false - - -" % (dir))) + + # Now we actually load from the configuration files + for conf in get_fs_perms_list(d).split(): + if not os.path.exists(conf): + continue + with open(conf) as f: + for line in f: + if line.startswith('#'): + continue + lsplit = line.split() + if len(lsplit) == 0: + continue + if len(lsplit) != 8 and not (len(lsplit) == 3 and lsplit[1].lower() == "link"): + msg = "Fixup perms: %s invalid line: %s" % (conf, line) + oe.qa.handle_error("perm-line", msg, d) + continue + entry = fs_perms_entry(d.expand(line)) + if entry and entry.path: + if entry.link: + fs_link_table[entry.path] = entry + if entry.path in fs_perms_table: + fs_perms_table.pop(entry.path) + else: + fs_perms_table[entry.path] = entry + if entry.path in fs_link_table: + fs_link_table.pop(entry.path) + + # Debug -- list out in-memory table + #for dir in fs_perms_table: + # bb.note("Fixup Perms: %s: %s" % (dir, str(fs_perms_table[dir]))) + #for link in fs_link_table: + # bb.note("Fixup Perms: %s: %s" % (link, str(fs_link_table[link]))) + + # We process links first, so we can go back and fixup directory ownership + # for any newly created directories + # Process in sorted order so /run gets created before /run/lock, etc. + for entry in sorted(fs_link_table.values(), key=lambda x: x.link): + link = entry.link + dir = entry.path + origin = dvar + dir + if not (cpath.exists(origin) and cpath.isdir(origin) and not cpath.islink(origin)): + continue + + if link[0] == "/": + target = dvar + link + ptarget = link + else: + target = os.path.join(os.path.dirname(origin), link) + ptarget = os.path.join(os.path.dirname(dir), link) + if os.path.exists(target): + msg = "Fixup Perms: Unable to correct directory link, target already exists: %s -> %s" % (dir, ptarget) + oe.qa.handle_error("perm-link", msg, d) + continue + + # Create path to move directory to, move it, and then setup the symlink + bb.utils.mkdirhier(os.path.dirname(target)) + #bb.note("Fixup Perms: Rename %s -> %s" % (dir, ptarget)) + bb.utils.rename(origin, target) + #bb.note("Fixup Perms: Link %s -> %s" % (dir, link)) + os.symlink(link, origin) + + for dir in fs_perms_table: + origin = dvar + dir + if not (cpath.exists(origin) and cpath.isdir(origin)): + continue + + fix_perms(origin, fs_perms_table[dir].mode, fs_perms_table[dir].uid, fs_perms_table[dir].gid, dir) + + if fs_perms_table[dir].walk == 'true': + for root, dirs, files in os.walk(origin): + for dr in dirs: + each_dir = os.path.join(root, dr) + fix_perms(each_dir, fs_perms_table[dir].mode, fs_perms_table[dir].uid, fs_perms_table[dir].gid, dir) + for f in files: + each_file = os.path.join(root, f) + fix_perms(each_file, fs_perms_table[dir].fmode, fs_perms_table[dir].fuid, fs_perms_table[dir].fgid, dir) +} + +def package_debug_vars(d): + # We default to '.debug' style + if d.getVar('PACKAGE_DEBUG_SPLIT_STYLE') == 'debug-file-directory': + # Single debug-file-directory style debug info + debug_vars = { + "append": ".debug", + "staticappend": "", + "dir": "", + "staticdir": "", + "libdir": "/usr/lib/debug", + "staticlibdir": "/usr/lib/debug-static", + "srcdir": "/usr/src/debug", + } + elif d.getVar('PACKAGE_DEBUG_SPLIT_STYLE') == 'debug-without-src': + # Original OE-core, a.k.a. ".debug", style debug info, but without sources in /usr/src/debug + debug_vars = { + "append": "", + "staticappend": "", + "dir": "/.debug", + "staticdir": "/.debug-static", + "libdir": "", + "staticlibdir": "", + "srcdir": "", + } + elif d.getVar('PACKAGE_DEBUG_SPLIT_STYLE') == 'debug-with-srcpkg': + debug_vars = { + "append": "", + "staticappend": "", + "dir": "/.debug", + "staticdir": "/.debug-static", + "libdir": "", + "staticlibdir": "", + "srcdir": "/usr/src/debug", + } + else: + # Original OE-core, a.k.a. ".debug", style debug info + debug_vars = { + "append": "", + "staticappend": "", + "dir": "/.debug", + "staticdir": "/.debug-static", + "libdir": "", + "staticlibdir": "", + "srcdir": "/usr/src/debug", + } + + return debug_vars + +python split_and_strip_files () { + import stat, errno + import subprocess + + dvar = d.getVar('PKGD') + pn = d.getVar('PN') + hostos = d.getVar('HOST_OS') + + oldcwd = os.getcwd() + os.chdir(dvar) + + dv = package_debug_vars(d) + + # + # First lets figure out all of the files we may have to process ... do this only once! + # + elffiles = {} + symlinks = {} + staticlibs = [] + inodes = {} + libdir = os.path.abspath(dvar + os.sep + d.getVar("libdir")) + baselibdir = os.path.abspath(dvar + os.sep + d.getVar("base_libdir")) + skipfiles = (d.getVar("INHIBIT_PACKAGE_STRIP_FILES") or "").split() + if (d.getVar('INHIBIT_PACKAGE_STRIP') != '1' or \ + d.getVar('INHIBIT_PACKAGE_DEBUG_SPLIT') != '1'): + checkelf = {} + checkelflinks = {} + for root, dirs, files in cpath.walk(dvar): + for f in files: + file = os.path.join(root, f) + + # Skip debug files + if dv["append"] and file.endswith(dv["append"]): + continue + if dv["dir"] and dv["dir"] in os.path.dirname(file[len(dvar):]): + continue + + if file in skipfiles: + continue + + if oe.package.is_static_lib(file): + staticlibs.append(file) + continue + + try: + ltarget = cpath.realpath(file, dvar, False) + s = cpath.lstat(ltarget) + except OSError as e: + (err, strerror) = e.args + if err != errno.ENOENT: + raise + # Skip broken symlinks + continue + if not s: + continue + # Check its an executable + if (s[stat.ST_MODE] & stat.S_IXUSR) or (s[stat.ST_MODE] & stat.S_IXGRP) \ + or (s[stat.ST_MODE] & stat.S_IXOTH) \ + or ((file.startswith(libdir) or file.startswith(baselibdir)) \ + and (".so" in f or ".node" in f)) \ + or (f.startswith('vmlinux') or ".ko" in f): + + if cpath.islink(file): + checkelflinks[file] = ltarget + continue + # Use a reference of device ID and inode number to identify files + file_reference = "%d_%d" % (s.st_dev, s.st_ino) + checkelf[file] = (file, file_reference) + + results = oe.utils.multiprocess_launch(oe.package.is_elf, checkelflinks.values(), d) + results_map = {} + for (ltarget, elf_file) in results: + results_map[ltarget] = elf_file + for file in checkelflinks: + ltarget = checkelflinks[file] + # If it's a symlink, and points to an ELF file, we capture the readlink target + if results_map[ltarget]: + target = os.readlink(file) + #bb.note("Sym: %s (%d)" % (ltarget, results_map[ltarget])) + symlinks[file] = target + + results = oe.utils.multiprocess_launch(oe.package.is_elf, checkelf.keys(), d) + + # Sort results by file path. This ensures that the files are always + # processed in the same order, which is important to make sure builds + # are reproducible when dealing with hardlinks + results.sort(key=lambda x: x[0]) + + for (file, elf_file) in results: + # It's a file (or hardlink), not a link + # ...but is it ELF, and is it already stripped? + if elf_file & 1: + if elf_file & 2: + if 'already-stripped' in (d.getVar('INSANE_SKIP:' + pn) or "").split(): + bb.note("Skipping file %s from %s for already-stripped QA test" % (file[len(dvar):], pn)) + else: + msg = "File '%s' from %s was already stripped, this will prevent future debugging!" % (file[len(dvar):], pn) + oe.qa.handle_error("already-stripped", msg, d) + continue + + # At this point we have an unstripped elf file. We need to: + # a) Make sure any file we strip is not hardlinked to anything else outside this tree + # b) Only strip any hardlinked file once (no races) + # c) Track any hardlinks between files so that we can reconstruct matching debug file hardlinks + + # Use a reference of device ID and inode number to identify files + file_reference = checkelf[file][1] + if file_reference in inodes: + os.unlink(file) + os.link(inodes[file_reference][0], file) + inodes[file_reference].append(file) + else: + inodes[file_reference] = [file] + # break hardlink + bb.utils.break_hardlinks(file) + elffiles[file] = elf_file + # Modified the file so clear the cache + cpath.updatecache(file) + + def strip_pkgd_prefix(f): + nonlocal dvar + + if f.startswith(dvar): + return f[len(dvar):] + + return f + + # + # First lets process debug splitting + # + if (d.getVar('INHIBIT_PACKAGE_DEBUG_SPLIT') != '1'): + results = oe.utils.multiprocess_launch(splitdebuginfo, list(elffiles), d, extraargs=(dvar, dv, d)) + + if dv["srcdir"] and not hostos.startswith("mingw"): + if (d.getVar('PACKAGE_DEBUG_STATIC_SPLIT') == '1'): + results = oe.utils.multiprocess_launch(splitstaticdebuginfo, staticlibs, d, extraargs=(dvar, dv, d)) + else: + for file in staticlibs: + results.append( (file,source_info(file, d)) ) + + d.setVar("PKGDEBUGSOURCES", {strip_pkgd_prefix(f): sorted(s) for f, s in results}) + + sources = set() + for r in results: + sources.update(r[1]) + + # Hardlink our debug symbols to the other hardlink copies + for ref in inodes: + if len(inodes[ref]) == 1: + continue + + target = inodes[ref][0][len(dvar):] + for file in inodes[ref][1:]: + src = file[len(dvar):] + dest = dv["libdir"] + os.path.dirname(src) + dv["dir"] + "/" + os.path.basename(target) + dv["append"] + fpath = dvar + dest + ftarget = dvar + dv["libdir"] + os.path.dirname(target) + dv["dir"] + "/" + os.path.basename(target) + dv["append"] + bb.utils.mkdirhier(os.path.dirname(fpath)) + # Only one hardlink of separated debug info file in each directory + if not os.access(fpath, os.R_OK): + #bb.note("Link %s -> %s" % (fpath, ftarget)) + os.link(ftarget, fpath) + + # Create symlinks for all cases we were able to split symbols + for file in symlinks: + src = file[len(dvar):] + dest = dv["libdir"] + os.path.dirname(src) + dv["dir"] + "/" + os.path.basename(src) + dv["append"] + fpath = dvar + dest + # Skip it if the target doesn't exist + try: + s = os.stat(fpath) + except OSError as e: + (err, strerror) = e.args + if err != errno.ENOENT: + raise + continue + + ltarget = symlinks[file] + lpath = os.path.dirname(ltarget) + lbase = os.path.basename(ltarget) + ftarget = "" + if lpath and lpath != ".": + ftarget += lpath + dv["dir"] + "/" + ftarget += lbase + dv["append"] + if lpath.startswith(".."): + ftarget = os.path.join("..", ftarget) + bb.utils.mkdirhier(os.path.dirname(fpath)) + #bb.note("Symlink %s -> %s" % (fpath, ftarget)) + os.symlink(ftarget, fpath) + + # Process the dv["srcdir"] if requested... + # This copies and places the referenced sources for later debugging... + copydebugsources(dv["srcdir"], sources, d) + # + # End of debug splitting + # + + # + # Now lets go back over things and strip them + # + if (d.getVar('INHIBIT_PACKAGE_STRIP') != '1'): + strip = d.getVar("STRIP") + sfiles = [] + for file in elffiles: + elf_file = int(elffiles[file]) + #bb.note("Strip %s" % file) + sfiles.append((file, elf_file, strip)) + if (d.getVar('PACKAGE_STRIP_STATIC') == '1' or d.getVar('PACKAGE_DEBUG_STATIC_SPLIT') == '1'): + for f in staticlibs: + sfiles.append((f, 16, strip)) + + oe.utils.multiprocess_launch(oe.package.runstrip, sfiles, d) + + # Build "minidebuginfo" and reinject it back into the stripped binaries + if d.getVar('PACKAGE_MINIDEBUGINFO') == '1': + oe.utils.multiprocess_launch(inject_minidebuginfo, list(elffiles), d, + extraargs=(dvar, dv, d)) + + # + # End of strip + # + os.chdir(oldcwd) +} + +python populate_packages () { + import glob, re + + workdir = d.getVar('WORKDIR') + outdir = d.getVar('DEPLOY_DIR') + dvar = d.getVar('PKGD') + packages = d.getVar('PACKAGES').split() + pn = d.getVar('PN') + + bb.utils.mkdirhier(outdir) + os.chdir(dvar) + + autodebug = not (d.getVar("NOAUTOPACKAGEDEBUG") or False) + + split_source_package = (d.getVar('PACKAGE_DEBUG_SPLIT_STYLE') == 'debug-with-srcpkg') + + # If debug-with-srcpkg mode is enabled then add the source package if it + # doesn't exist and add the source file contents to the source package. + if split_source_package: + src_package_name = ('%s-src' % d.getVar('PN')) + if not src_package_name in packages: + packages.append(src_package_name) + d.setVar('FILES:%s' % src_package_name, '/usr/src/debug') + + # Sanity check PACKAGES for duplicates + # Sanity should be moved to sanity.bbclass once we have the infrastructure + package_dict = {} + + for i, pkg in enumerate(packages): + if pkg in package_dict: + msg = "%s is listed in PACKAGES multiple times, this leads to packaging errors." % pkg + oe.qa.handle_error("packages-list", msg, d) + # Ensure the source package gets the chance to pick up the source files + # before the debug package by ordering it first in PACKAGES. Whether it + # actually picks up any source files is controlled by + # PACKAGE_DEBUG_SPLIT_STYLE. + elif pkg.endswith("-src"): + package_dict[pkg] = (10, i) + elif autodebug and pkg.endswith("-dbg"): + package_dict[pkg] = (30, i) + else: + package_dict[pkg] = (50, i) + packages = sorted(package_dict.keys(), key=package_dict.get) + d.setVar('PACKAGES', ' '.join(packages)) + pkgdest = d.getVar('PKGDEST') + + seen = [] + + # os.mkdir masks the permissions with umask so we have to unset it first + oldumask = os.umask(0) + + debug = [] + for root, dirs, files in cpath.walk(dvar): + dir = root[len(dvar):] + if not dir: + dir = os.sep + for f in (files + dirs): + path = "." + os.path.join(dir, f) + if "/.debug/" in path or "/.debug-static/" in path or path.endswith("/.debug"): + debug.append(path) + + for pkg in packages: + root = os.path.join(pkgdest, pkg) + bb.utils.mkdirhier(root) + + filesvar = d.getVar('FILES:%s' % pkg) or "" + if "//" in filesvar: + msg = "FILES variable for package %s contains '//' which is invalid. Attempting to fix this but you should correct the metadata.\n" % pkg + oe.qa.handle_error("files-invalid", msg, d) + filesvar.replace("//", "/") + + origfiles = filesvar.split() + files, symlink_paths = files_from_filevars(origfiles) + + if autodebug and pkg.endswith("-dbg"): + files.extend(debug) + + for file in files: + if (not cpath.islink(file)) and (not cpath.exists(file)): + continue + if file in seen: + continue + seen.append(file) + + def mkdir(src, dest, p): + src = os.path.join(src, p) + dest = os.path.join(dest, p) + fstat = cpath.stat(src) + os.mkdir(dest) + os.chmod(dest, fstat.st_mode) + os.chown(dest, fstat.st_uid, fstat.st_gid) + if p not in seen: + seen.append(p) + cpath.updatecache(dest) + + def mkdir_recurse(src, dest, paths): + if cpath.exists(dest + '/' + paths): + return + while paths.startswith("./"): + paths = paths[2:] + p = "." + for c in paths.split("/"): + p = os.path.join(p, c) + if not cpath.exists(os.path.join(dest, p)): + mkdir(src, dest, p) + + if cpath.isdir(file) and not cpath.islink(file): + mkdir_recurse(dvar, root, file) + continue + + mkdir_recurse(dvar, root, os.path.dirname(file)) + fpath = os.path.join(root,file) + if not cpath.islink(file): + os.link(file, fpath) + continue + ret = bb.utils.copyfile(file, fpath) + if ret is False or ret == 0: + bb.fatal("File population failed") + + # Check if symlink paths exist + for file in symlink_paths: + if not os.path.exists(os.path.join(root,file)): + bb.fatal("File '%s' cannot be packaged into '%s' because its " + "parent directory structure does not exist. One of " + "its parent directories is a symlink whose target " + "directory is not included in the package." % + (file, pkg)) + + os.umask(oldumask) + os.chdir(workdir) + + # Handle excluding packages with incompatible licenses + package_list = [] + for pkg in packages: + licenses = d.getVar('_exclude_incompatible-' + pkg) + if licenses: + msg = "Excluding %s from packaging as it has incompatible license(s): %s" % (pkg, licenses) + oe.qa.handle_error("incompatible-license", msg, d) + else: + package_list.append(pkg) + d.setVar('PACKAGES', ' '.join(package_list)) + + unshipped = [] + for root, dirs, files in cpath.walk(dvar): + dir = root[len(dvar):] + if not dir: + dir = os.sep + for f in (files + dirs): + path = os.path.join(dir, f) + if ('.' + path) not in seen: + unshipped.append(path) + + if unshipped != []: + msg = pn + ": Files/directories were installed but not shipped in any package:" + if "installed-vs-shipped" in (d.getVar('INSANE_SKIP:' + pn) or "").split(): + bb.note("Package %s skipping QA tests: installed-vs-shipped" % pn) + else: + for f in unshipped: + msg = msg + "\n " + f + msg = msg + "\nPlease set FILES such that these items are packaged. Alternatively if they are unneeded, avoid installing them or delete them within do_install.\n" + msg = msg + "%s: %d installed and not shipped files." % (pn, len(unshipped)) + oe.qa.handle_error("installed-vs-shipped", msg, d) +} +populate_packages[dirs] = "${D}" + +python package_fixsymlinks () { + import errno + pkgdest = d.getVar('PKGDEST') + packages = d.getVar("PACKAGES", False).split() + + dangling_links = {} + pkg_files = {} + for pkg in packages: + dangling_links[pkg] = [] + pkg_files[pkg] = [] + inst_root = os.path.join(pkgdest, pkg) + for path in pkgfiles[pkg]: + rpath = path[len(inst_root):] + pkg_files[pkg].append(rpath) + rtarget = cpath.realpath(path, inst_root, True, assume_dir = True) + if not cpath.lexists(rtarget): + dangling_links[pkg].append(os.path.normpath(rtarget[len(inst_root):])) + + newrdepends = {} + for pkg in dangling_links: + for l in dangling_links[pkg]: + found = False + bb.debug(1, "%s contains dangling link %s" % (pkg, l)) + for p in packages: + if l in pkg_files[p]: + found = True + bb.debug(1, "target found in %s" % p) + if p == pkg: + break + if pkg not in newrdepends: + newrdepends[pkg] = [] + newrdepends[pkg].append(p) + break + if found == False: + bb.note("%s contains dangling symlink to %s" % (pkg, l)) + + for pkg in newrdepends: + rdepends = bb.utils.explode_dep_versions2(d.getVar('RDEPENDS:' + pkg) or "") + for p in newrdepends[pkg]: + if p not in rdepends: + rdepends[p] = [] + d.setVar('RDEPENDS:' + pkg, bb.utils.join_deps(rdepends, commasep=False)) +} + + +python package_package_name_hook() { + """ + A package_name_hook function can be used to rewrite the package names by + changing PKG. For an example, see debian.bbclass. + """ + pass +} + +EXPORT_FUNCTIONS package_name_hook + + +PKGDESTWORK = "${WORKDIR}/pkgdata" + +PKGDATA_VARS = "PN PE PV PR PKGE PKGV PKGR LICENSE DESCRIPTION SUMMARY RDEPENDS RPROVIDES RRECOMMENDS RSUGGESTS RREPLACES RCONFLICTS SECTION PKG ALLOW_EMPTY FILES CONFFILES FILES_INFO PACKAGE_ADD_METADATA pkg_postinst pkg_postrm pkg_preinst pkg_prerm" + +python emit_pkgdata() { + from glob import glob + import json + import bb.compress.zstd + + def process_postinst_on_target(pkg, mlprefix): + pkgval = d.getVar('PKG:%s' % pkg) + if pkgval is None: + pkgval = pkg + + defer_fragment = """ +if [ -n "$D" ]; then + $INTERCEPT_DIR/postinst_intercept delay_to_first_boot %s mlprefix=%s + exit 0 +fi +""" % (pkgval, mlprefix) + + postinst = d.getVar('pkg_postinst:%s' % pkg) + postinst_ontarget = d.getVar('pkg_postinst_ontarget:%s' % pkg) + + if postinst_ontarget: + bb.debug(1, 'adding deferred pkg_postinst_ontarget() to pkg_postinst() for %s' % pkg) + if not postinst: + postinst = '#!/bin/sh\n' + postinst += defer_fragment + postinst += postinst_ontarget + d.setVar('pkg_postinst:%s' % pkg, postinst) + + def add_set_e_to_scriptlets(pkg): + for scriptlet_name in ('pkg_preinst', 'pkg_postinst', 'pkg_prerm', 'pkg_postrm'): + scriptlet = d.getVar('%s:%s' % (scriptlet_name, pkg)) + if scriptlet: + scriptlet_split = scriptlet.split('\n') + if scriptlet_split[0].startswith("#!"): + scriptlet = scriptlet_split[0] + "\nset -e\n" + "\n".join(scriptlet_split[1:]) + else: + scriptlet = "set -e\n" + "\n".join(scriptlet_split[0:]) + d.setVar('%s:%s' % (scriptlet_name, pkg), scriptlet) + + def write_if_exists(f, pkg, var): + def encode(str): + import codecs + c = codecs.getencoder("unicode_escape") + return c(str)[0].decode("latin1") + + val = d.getVar('%s:%s' % (var, pkg)) + if val: + f.write('%s:%s: %s\n' % (var, pkg, encode(val))) + return val + val = d.getVar('%s' % (var)) + if val: + f.write('%s: %s\n' % (var, encode(val))) + return val + + def write_extra_pkgs(variants, pn, packages, pkgdatadir): + for variant in variants: + with open("%s/%s-%s" % (pkgdatadir, variant, pn), 'w') as fd: + fd.write("PACKAGES: %s\n" % ' '.join( + map(lambda pkg: '%s-%s' % (variant, pkg), packages.split()))) + + def write_extra_runtime_pkgs(variants, packages, pkgdatadir): + for variant in variants: + for pkg in packages.split(): + ml_pkg = "%s-%s" % (variant, pkg) + subdata_file = "%s/runtime/%s" % (pkgdatadir, ml_pkg) + with open(subdata_file, 'w') as fd: + fd.write("PKG:%s: %s" % (ml_pkg, pkg)) + + packages = d.getVar('PACKAGES') + pkgdest = d.getVar('PKGDEST') + pkgdatadir = d.getVar('PKGDESTWORK') + + data_file = pkgdatadir + d.expand("/${PN}") + with open(data_file, 'w') as fd: + fd.write("PACKAGES: %s\n" % packages) + + pkgdebugsource = d.getVar("PKGDEBUGSOURCES") or [] + + pn = d.getVar('PN') + global_variants = (d.getVar('MULTILIB_GLOBAL_VARIANTS') or "").split() + variants = (d.getVar('MULTILIB_VARIANTS') or "").split() + + if bb.data.inherits_class('kernel', d) or bb.data.inherits_class('module-base', d): + write_extra_pkgs(variants, pn, packages, pkgdatadir) + + if bb.data.inherits_class('allarch', d) and not variants \ + and not bb.data.inherits_class('packagegroup', d): + write_extra_pkgs(global_variants, pn, packages, pkgdatadir) + + workdir = d.getVar('WORKDIR') + + for pkg in packages.split(): + pkgval = d.getVar('PKG:%s' % pkg) + if pkgval is None: + pkgval = pkg + d.setVar('PKG:%s' % pkg, pkg) + + extended_data = { + "files_info": {} + } + + pkgdestpkg = os.path.join(pkgdest, pkg) + files = {} + files_extra = {} + total_size = 0 + seen = set() + for f in pkgfiles[pkg]: + fpath = os.sep + os.path.relpath(f, pkgdestpkg) + + fstat = os.lstat(f) + files[fpath] = fstat.st_size + + extended_data["files_info"].setdefault(fpath, {}) + extended_data["files_info"][fpath]['size'] = fstat.st_size + + if fstat.st_ino not in seen: + seen.add(fstat.st_ino) + total_size += fstat.st_size + + if fpath in pkgdebugsource: + extended_data["files_info"][fpath]['debugsrc'] = pkgdebugsource[fpath] + del pkgdebugsource[fpath] + + d.setVar('FILES_INFO:' + pkg , json.dumps(files, sort_keys=True)) + + process_postinst_on_target(pkg, d.getVar("MLPREFIX")) + add_set_e_to_scriptlets(pkg) + + subdata_file = pkgdatadir + "/runtime/%s" % pkg + with open(subdata_file, 'w') as sf: + for var in (d.getVar('PKGDATA_VARS') or "").split(): + val = write_if_exists(sf, pkg, var) + + write_if_exists(sf, pkg, 'FILERPROVIDESFLIST') + for dfile in sorted((d.getVar('FILERPROVIDESFLIST:' + pkg) or "").split()): + write_if_exists(sf, pkg, 'FILERPROVIDES:' + dfile) + + write_if_exists(sf, pkg, 'FILERDEPENDSFLIST') + for dfile in sorted((d.getVar('FILERDEPENDSFLIST:' + pkg) or "").split()): + write_if_exists(sf, pkg, 'FILERDEPENDS:' + dfile) + + sf.write('%s:%s: %d\n' % ('PKGSIZE', pkg, total_size)) + + subdata_extended_file = pkgdatadir + "/extended/%s.json.zstd" % pkg + num_threads = int(d.getVar("BB_NUMBER_THREADS")) + with bb.compress.zstd.open(subdata_extended_file, "wt", encoding="utf-8", num_threads=num_threads) as f: + json.dump(extended_data, f, sort_keys=True, separators=(",", ":")) + + # Symlinks needed for rprovides lookup + rprov = d.getVar('RPROVIDES:%s' % pkg) or d.getVar('RPROVIDES') + if rprov: + for p in bb.utils.explode_deps(rprov): + subdata_sym = pkgdatadir + "/runtime-rprovides/%s/%s" % (p, pkg) + bb.utils.mkdirhier(os.path.dirname(subdata_sym)) + oe.path.symlink("../../runtime/%s" % pkg, subdata_sym, True) + + allow_empty = d.getVar('ALLOW_EMPTY:%s' % pkg) + if not allow_empty: + allow_empty = d.getVar('ALLOW_EMPTY') + root = "%s/%s" % (pkgdest, pkg) + os.chdir(root) + g = glob('*') + if g or allow_empty == "1": + # Symlinks needed for reverse lookups (from the final package name) + subdata_sym = pkgdatadir + "/runtime-reverse/%s" % pkgval + oe.path.symlink("../runtime/%s" % pkg, subdata_sym, True) + + packagedfile = pkgdatadir + '/runtime/%s.packaged' % pkg + open(packagedfile, 'w').close() + + if bb.data.inherits_class('kernel', d) or bb.data.inherits_class('module-base', d): + write_extra_runtime_pkgs(variants, packages, pkgdatadir) + + if bb.data.inherits_class('allarch', d) and not variants \ + and not bb.data.inherits_class('packagegroup', d): + write_extra_runtime_pkgs(global_variants, packages, pkgdatadir) + +} +emit_pkgdata[dirs] = "${PKGDESTWORK}/runtime ${PKGDESTWORK}/runtime-reverse ${PKGDESTWORK}/runtime-rprovides ${PKGDESTWORK}/extended" +emit_pkgdata[vardepsexclude] = "BB_NUMBER_THREADS" + +ldconfig_postinst_fragment() { +if [ x"$D" = "x" ]; then + if [ -x /sbin/ldconfig ]; then /sbin/ldconfig ; fi +fi +} + +RPMDEPS = "${STAGING_LIBDIR_NATIVE}/rpm/rpmdeps --alldeps --define '__font_provides %{nil}'" + +# Collect perfile run-time dependency metadata +# Output: +# FILERPROVIDESFLIST:pkg - list of all files w/ deps +# FILERPROVIDES:filepath:pkg - per file dep +# +# FILERDEPENDSFLIST:pkg - list of all files w/ deps +# FILERDEPENDS:filepath:pkg - per file dep + +python package_do_filedeps() { + if d.getVar('SKIP_FILEDEPS') == '1': + return + + pkgdest = d.getVar('PKGDEST') + packages = d.getVar('PACKAGES') + rpmdeps = d.getVar('RPMDEPS') + + def chunks(files, n): + return [files[i:i+n] for i in range(0, len(files), n)] + + pkglist = [] + for pkg in packages.split(): + if d.getVar('SKIP_FILEDEPS:' + pkg) == '1': + continue + if pkg.endswith('-dbg') or pkg.endswith('-doc') or pkg.find('-locale-') != -1 or pkg.find('-localedata-') != -1 or pkg.find('-gconv-') != -1 or pkg.find('-charmap-') != -1 or pkg.startswith('kernel-module-') or pkg.endswith('-src'): + continue + for files in chunks(pkgfiles[pkg], 100): + pkglist.append((pkg, files, rpmdeps, pkgdest)) + + processed = oe.utils.multiprocess_launch(oe.package.filedeprunner, pkglist, d) + + provides_files = {} + requires_files = {} + + for result in processed: + (pkg, provides, requires) = result + + if pkg not in provides_files: + provides_files[pkg] = [] + if pkg not in requires_files: + requires_files[pkg] = [] + + for file in sorted(provides): + provides_files[pkg].append(file) + key = "FILERPROVIDES:" + file + ":" + pkg + d.appendVar(key, " " + " ".join(provides[file])) + + for file in sorted(requires): + requires_files[pkg].append(file) + key = "FILERDEPENDS:" + file + ":" + pkg + d.appendVar(key, " " + " ".join(requires[file])) + + for pkg in requires_files: + d.setVar("FILERDEPENDSFLIST:" + pkg, " ".join(sorted(requires_files[pkg]))) + for pkg in provides_files: + d.setVar("FILERPROVIDESFLIST:" + pkg, " ".join(sorted(provides_files[pkg]))) +} + +SHLIBSDIRS = "${WORKDIR_PKGDATA}/${MLPREFIX}shlibs2" +SHLIBSWORKDIR = "${PKGDESTWORK}/${MLPREFIX}shlibs2" + +python package_do_shlibs() { + import itertools + import re, pipes + import subprocess + + exclude_shlibs = d.getVar('EXCLUDE_FROM_SHLIBS', False) + if exclude_shlibs: + bb.note("not generating shlibs") + return + + lib_re = re.compile(r"^.*\.so") + libdir_re = re.compile(r".*/%s$" % d.getVar('baselib')) + + packages = d.getVar('PACKAGES') + + shlib_pkgs = [] + exclusion_list = d.getVar("EXCLUDE_PACKAGES_FROM_SHLIBS") + if exclusion_list: + for pkg in packages.split(): + if pkg not in exclusion_list.split(): + shlib_pkgs.append(pkg) + else: + bb.note("not generating shlibs for %s" % pkg) + else: + shlib_pkgs = packages.split() + + hostos = d.getVar('HOST_OS') + + workdir = d.getVar('WORKDIR') + + ver = d.getVar('PKGV') + if not ver: + msg = "PKGV not defined" + oe.qa.handle_error("pkgv-undefined", msg, d) + return + + pkgdest = d.getVar('PKGDEST') + + shlibswork_dir = d.getVar('SHLIBSWORKDIR') + + def linux_so(file, pkg, pkgver, d): + needs_ldconfig = False + needed = set() + sonames = set() + renames = [] + ldir = os.path.dirname(file).replace(pkgdest + "/" + pkg, '') + cmd = d.getVar('OBJDUMP') + " -p " + pipes.quote(file) + " 2>/dev/null" + fd = os.popen(cmd) + lines = fd.readlines() + fd.close() + rpath = tuple() + for l in lines: + m = re.match(r"\s+RPATH\s+([^\s]*)", l) + if m: + rpaths = m.group(1).replace("$ORIGIN", ldir).split(":") + rpath = tuple(map(os.path.normpath, rpaths)) + for l in lines: + m = re.match(r"\s+NEEDED\s+([^\s]*)", l) + if m: + dep = m.group(1) + if dep not in needed: + needed.add((dep, file, rpath)) + m = re.match(r"\s+SONAME\s+([^\s]*)", l) + if m: + this_soname = m.group(1) + prov = (this_soname, ldir, pkgver) + if not prov in sonames: + # if library is private (only used by package) then do not build shlib for it + import fnmatch + if not private_libs or len([i for i in private_libs if fnmatch.fnmatch(this_soname, i)]) == 0: + sonames.add(prov) + if libdir_re.match(os.path.dirname(file)): + needs_ldconfig = True + if needs_ldconfig and snap_symlinks and (os.path.basename(file) != this_soname): + renames.append((file, os.path.join(os.path.dirname(file), this_soname))) + return (needs_ldconfig, needed, sonames, renames) + + def darwin_so(file, needed, sonames, renames, pkgver): + if not os.path.exists(file): + return + ldir = os.path.dirname(file).replace(pkgdest + "/" + pkg, '') + + def get_combinations(base): + # + # Given a base library name, find all combinations of this split by "." and "-" + # + combos = [] + options = base.split(".") + for i in range(1, len(options) + 1): + combos.append(".".join(options[0:i])) + options = base.split("-") + for i in range(1, len(options) + 1): + combos.append("-".join(options[0:i])) + return combos + + if (file.endswith('.dylib') or file.endswith('.so')) and not pkg.endswith('-dev') and not pkg.endswith('-dbg') and not pkg.endswith('-src'): + # Drop suffix + name = os.path.basename(file).rsplit(".",1)[0] + # Find all combinations + combos = get_combinations(name) + for combo in combos: + if not combo in sonames: + prov = (combo, ldir, pkgver) + sonames.add(prov) + if file.endswith('.dylib') or file.endswith('.so'): + rpath = [] + p = subprocess.Popen([d.expand("${HOST_PREFIX}otool"), '-l', file], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) + out, err = p.communicate() + # If returned successfully, process stdout for results + if p.returncode == 0: + for l in out.split("\n"): + l = l.strip() + if l.startswith('path '): + rpath.append(l.split()[1]) + + p = subprocess.Popen([d.expand("${HOST_PREFIX}otool"), '-L', file], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) + out, err = p.communicate() + # If returned successfully, process stdout for results + if p.returncode == 0: + for l in out.split("\n"): + l = l.strip() + if not l or l.endswith(":"): + continue + if "is not an object file" in l: + continue + name = os.path.basename(l.split()[0]).rsplit(".", 1)[0] + if name and name not in needed[pkg]: + needed[pkg].add((name, file, tuple())) + + def mingw_dll(file, needed, sonames, renames, pkgver): + if not os.path.exists(file): + return + + if file.endswith(".dll"): + # assume all dlls are shared objects provided by the package + sonames.add((os.path.basename(file), os.path.dirname(file).replace(pkgdest + "/" + pkg, ''), pkgver)) + + if (file.endswith(".dll") or file.endswith(".exe")): + # use objdump to search for "DLL Name: .*\.dll" + p = subprocess.Popen([d.expand("${HOST_PREFIX}objdump"), "-p", file], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + out, err = p.communicate() + # process the output, grabbing all .dll names + if p.returncode == 0: + for m in re.finditer(r"DLL Name: (.*?\.dll)$", out.decode(), re.MULTILINE | re.IGNORECASE): + dllname = m.group(1) + if dllname: + needed[pkg].add((dllname, file, tuple())) + + if d.getVar('PACKAGE_SNAP_LIB_SYMLINKS') == "1": + snap_symlinks = True + else: + snap_symlinks = False + + needed = {} + + shlib_provider = oe.package.read_shlib_providers(d) + + for pkg in shlib_pkgs: + private_libs = d.getVar('PRIVATE_LIBS:' + pkg) or d.getVar('PRIVATE_LIBS') or "" + private_libs = private_libs.split() + needs_ldconfig = False + bb.debug(2, "calculating shlib provides for %s" % pkg) + + pkgver = d.getVar('PKGV:' + pkg) + if not pkgver: + pkgver = d.getVar('PV_' + pkg) + if not pkgver: + pkgver = ver + + needed[pkg] = set() + sonames = set() + renames = [] + linuxlist = [] + for file in pkgfiles[pkg]: + soname = None + if cpath.islink(file): + continue + if hostos == "darwin" or hostos == "darwin21": + darwin_so(file, needed, sonames, renames, pkgver) + elif hostos.startswith("mingw"): + mingw_dll(file, needed, sonames, renames, pkgver) + elif os.access(file, os.X_OK) or lib_re.match(file): + linuxlist.append(file) + + if linuxlist: + results = oe.utils.multiprocess_launch(linux_so, linuxlist, d, extraargs=(pkg, pkgver, d)) + for r in results: + ldconfig = r[0] + needed[pkg] |= r[1] + sonames |= r[2] + renames.extend(r[3]) + needs_ldconfig = needs_ldconfig or ldconfig + + for (old, new) in renames: + bb.note("Renaming %s to %s" % (old, new)) + bb.utils.rename(old, new) + pkgfiles[pkg].remove(old) + + shlibs_file = os.path.join(shlibswork_dir, pkg + ".list") + if len(sonames): + with open(shlibs_file, 'w') as fd: + for s in sorted(sonames): + if s[0] in shlib_provider and s[1] in shlib_provider[s[0]]: + (old_pkg, old_pkgver) = shlib_provider[s[0]][s[1]] + if old_pkg != pkg: + bb.warn('%s-%s was registered as shlib provider for %s, changing it to %s-%s because it was built later' % (old_pkg, old_pkgver, s[0], pkg, pkgver)) + bb.debug(1, 'registering %s-%s as shlib provider for %s' % (pkg, pkgver, s[0])) + fd.write(s[0] + ':' + s[1] + ':' + s[2] + '\n') + if s[0] not in shlib_provider: + shlib_provider[s[0]] = {} + shlib_provider[s[0]][s[1]] = (pkg, pkgver) + if needs_ldconfig: + bb.debug(1, 'adding ldconfig call to postinst for %s' % pkg) + postinst = d.getVar('pkg_postinst:%s' % pkg) + if not postinst: + postinst = '#!/bin/sh\n' + postinst += d.getVar('ldconfig_postinst_fragment') + d.setVar('pkg_postinst:%s' % pkg, postinst) + bb.debug(1, 'LIBNAMES: pkg %s sonames %s' % (pkg, sonames)) + + assumed_libs = d.getVar('ASSUME_SHLIBS') + if assumed_libs: + libdir = d.getVar("libdir") + for e in assumed_libs.split(): + l, dep_pkg = e.split(":") + lib_ver = None + dep_pkg = dep_pkg.rsplit("_", 1) + if len(dep_pkg) == 2: + lib_ver = dep_pkg[1] + dep_pkg = dep_pkg[0] + if l not in shlib_provider: + shlib_provider[l] = {} + shlib_provider[l][libdir] = (dep_pkg, lib_ver) + + libsearchpath = [d.getVar('libdir'), d.getVar('base_libdir')] + + for pkg in shlib_pkgs: + bb.debug(2, "calculating shlib requirements for %s" % pkg) + + private_libs = d.getVar('PRIVATE_LIBS:' + pkg) or d.getVar('PRIVATE_LIBS') or "" + private_libs = private_libs.split() + + deps = list() + for n in needed[pkg]: + # if n is in private libraries, don't try to search provider for it + # this could cause problem in case some abc.bb provides private + # /opt/abc/lib/libfoo.so.1 and contains /usr/bin/abc depending on system library libfoo.so.1 + # but skipping it is still better alternative than providing own + # version and then adding runtime dependency for the same system library + import fnmatch + if private_libs and len([i for i in private_libs if fnmatch.fnmatch(n[0], i)]) > 0: + bb.debug(2, '%s: Dependency %s covered by PRIVATE_LIBS' % (pkg, n[0])) + continue + if n[0] in shlib_provider.keys(): + shlib_provider_map = shlib_provider[n[0]] + matches = set() + for p in itertools.chain(list(n[2]), sorted(shlib_provider_map.keys()), libsearchpath): + if p in shlib_provider_map: + matches.add(p) + if len(matches) > 1: + matchpkgs = ', '.join([shlib_provider_map[match][0] for match in matches]) + bb.error("%s: Multiple shlib providers for %s: %s (used by files: %s)" % (pkg, n[0], matchpkgs, n[1])) + elif len(matches) == 1: + (dep_pkg, ver_needed) = shlib_provider_map[matches.pop()] + + bb.debug(2, '%s: Dependency %s requires package %s (used by files: %s)' % (pkg, n[0], dep_pkg, n[1])) + + if dep_pkg == pkg: + continue + + if ver_needed: + dep = "%s (>= %s)" % (dep_pkg, ver_needed) + else: + dep = dep_pkg + if not dep in deps: + deps.append(dep) + continue + bb.note("Couldn't find shared library provider for %s, used by files: %s" % (n[0], n[1])) + + deps_file = os.path.join(pkgdest, pkg + ".shlibdeps") + if os.path.exists(deps_file): + os.remove(deps_file) + if deps: + with open(deps_file, 'w') as fd: + for dep in sorted(deps): + fd.write(dep + '\n') +} + +python package_do_pkgconfig () { + import re + + packages = d.getVar('PACKAGES') + workdir = d.getVar('WORKDIR') + pkgdest = d.getVar('PKGDEST') + + shlibs_dirs = d.getVar('SHLIBSDIRS').split() + shlibswork_dir = d.getVar('SHLIBSWORKDIR') + + pc_re = re.compile(r'(.*)\.pc$') + var_re = re.compile(r'(.*)=(.*)') + field_re = re.compile(r'(.*): (.*)') + + pkgconfig_provided = {} + pkgconfig_needed = {} + for pkg in packages.split(): + pkgconfig_provided[pkg] = [] + pkgconfig_needed[pkg] = [] + for file in sorted(pkgfiles[pkg]): + m = pc_re.match(file) + if m: + pd = bb.data.init() + name = m.group(1) + pkgconfig_provided[pkg].append(os.path.basename(name)) + if not os.access(file, os.R_OK): + continue + with open(file, 'r') as f: + lines = f.readlines() + for l in lines: + m = var_re.match(l) + if m: + name = m.group(1) + val = m.group(2) + pd.setVar(name, pd.expand(val)) + continue + m = field_re.match(l) + if m: + hdr = m.group(1) + exp = pd.expand(m.group(2)) + if hdr == 'Requires': + pkgconfig_needed[pkg] += exp.replace(',', ' ').split() + + for pkg in packages.split(): + pkgs_file = os.path.join(shlibswork_dir, pkg + ".pclist") + if pkgconfig_provided[pkg] != []: + with open(pkgs_file, 'w') as f: + for p in sorted(pkgconfig_provided[pkg]): + f.write('%s\n' % p) + + # Go from least to most specific since the last one found wins + for dir in reversed(shlibs_dirs): + if not os.path.exists(dir): + continue + for file in sorted(os.listdir(dir)): + m = re.match(r'^(.*)\.pclist$', file) + if m: + pkg = m.group(1) + with open(os.path.join(dir, file)) as fd: + lines = fd.readlines() + pkgconfig_provided[pkg] = [] + for l in lines: + pkgconfig_provided[pkg].append(l.rstrip()) + + for pkg in packages.split(): + deps = [] + for n in pkgconfig_needed[pkg]: + found = False + for k in pkgconfig_provided.keys(): + if n in pkgconfig_provided[k]: + if k != pkg and not (k in deps): + deps.append(k) + found = True + if found == False: + bb.note("couldn't find pkgconfig module '%s' in any package" % n) + deps_file = os.path.join(pkgdest, pkg + ".pcdeps") + if len(deps): + with open(deps_file, 'w') as fd: + for dep in deps: + fd.write(dep + '\n') +} + +def read_libdep_files(d): + pkglibdeps = {} + packages = d.getVar('PACKAGES').split() + for pkg in packages: + pkglibdeps[pkg] = {} + for extension in ".shlibdeps", ".pcdeps", ".clilibdeps": + depsfile = d.expand("${PKGDEST}/" + pkg + extension) + if os.access(depsfile, os.R_OK): + with open(depsfile) as fd: + lines = fd.readlines() + for l in lines: + l.rstrip() + deps = bb.utils.explode_dep_versions2(l) + for dep in deps: + if not dep in pkglibdeps[pkg]: + pkglibdeps[pkg][dep] = deps[dep] + return pkglibdeps + +python read_shlibdeps () { + pkglibdeps = read_libdep_files(d) + + packages = d.getVar('PACKAGES').split() + for pkg in packages: + rdepends = bb.utils.explode_dep_versions2(d.getVar('RDEPENDS:' + pkg) or "") + for dep in sorted(pkglibdeps[pkg]): + # Add the dep if it's not already there, or if no comparison is set + if dep not in rdepends: + rdepends[dep] = [] + for v in pkglibdeps[pkg][dep]: + if v not in rdepends[dep]: + rdepends[dep].append(v) + d.setVar('RDEPENDS:' + pkg, bb.utils.join_deps(rdepends, commasep=False)) +} + +python package_depchains() { + """ + For a given set of prefix and postfix modifiers, make those packages + RRECOMMENDS on the corresponding packages for its RDEPENDS. + + Example: If package A depends upon package B, and A's .bb emits an + A-dev package, this would make A-dev Recommends: B-dev. + + If only one of a given suffix is specified, it will take the RRECOMMENDS + based on the RDEPENDS of *all* other packages. If more than one of a given + suffix is specified, its will only use the RDEPENDS of the single parent + package. + """ + + packages = d.getVar('PACKAGES') + postfixes = (d.getVar('DEPCHAIN_POST') or '').split() + prefixes = (d.getVar('DEPCHAIN_PRE') or '').split() + + def pkg_adddeprrecs(pkg, base, suffix, getname, depends, d): + + #bb.note('depends for %s is %s' % (base, depends)) + rreclist = bb.utils.explode_dep_versions2(d.getVar('RRECOMMENDS:' + pkg) or "") + + for depend in sorted(depends): + if depend.find('-native') != -1 or depend.find('-cross') != -1 or depend.startswith('virtual/'): + #bb.note("Skipping %s" % depend) + continue + if depend.endswith('-dev'): + depend = depend[:-4] + if depend.endswith('-dbg'): + depend = depend[:-4] + pkgname = getname(depend, suffix) + #bb.note("Adding %s for %s" % (pkgname, depend)) + if pkgname not in rreclist and pkgname != pkg: + rreclist[pkgname] = [] + + #bb.note('setting: RRECOMMENDS:%s=%s' % (pkg, ' '.join(rreclist))) + d.setVar('RRECOMMENDS:%s' % pkg, bb.utils.join_deps(rreclist, commasep=False)) + + def pkg_addrrecs(pkg, base, suffix, getname, rdepends, d): + + #bb.note('rdepends for %s is %s' % (base, rdepends)) + rreclist = bb.utils.explode_dep_versions2(d.getVar('RRECOMMENDS:' + pkg) or "") + + for depend in sorted(rdepends): + if depend.find('virtual-locale-') != -1: + #bb.note("Skipping %s" % depend) + continue + if depend.endswith('-dev'): + depend = depend[:-4] + if depend.endswith('-dbg'): + depend = depend[:-4] + pkgname = getname(depend, suffix) + #bb.note("Adding %s for %s" % (pkgname, depend)) + if pkgname not in rreclist and pkgname != pkg: + rreclist[pkgname] = [] + + #bb.note('setting: RRECOMMENDS:%s=%s' % (pkg, ' '.join(rreclist))) + d.setVar('RRECOMMENDS:%s' % pkg, bb.utils.join_deps(rreclist, commasep=False)) + + def add_dep(list, dep): + if dep not in list: + list.append(dep) + + depends = [] + for dep in bb.utils.explode_deps(d.getVar('DEPENDS') or ""): + add_dep(depends, dep) + + rdepends = [] + for pkg in packages.split(): + for dep in bb.utils.explode_deps(d.getVar('RDEPENDS:' + pkg) or ""): + add_dep(rdepends, dep) + + #bb.note('rdepends is %s' % rdepends) + + def post_getname(name, suffix): + return '%s%s' % (name, suffix) + def pre_getname(name, suffix): + return '%s%s' % (suffix, name) + + pkgs = {} + for pkg in packages.split(): + for postfix in postfixes: + if pkg.endswith(postfix): + if not postfix in pkgs: + pkgs[postfix] = {} + pkgs[postfix][pkg] = (pkg[:-len(postfix)], post_getname) + + for prefix in prefixes: + if pkg.startswith(prefix): + if not prefix in pkgs: + pkgs[prefix] = {} + pkgs[prefix][pkg] = (pkg[:-len(prefix)], pre_getname) + + if "-dbg" in pkgs: + pkglibdeps = read_libdep_files(d) + pkglibdeplist = [] + for pkg in pkglibdeps: + for k in pkglibdeps[pkg]: + add_dep(pkglibdeplist, k) + dbgdefaultdeps = ((d.getVar('DEPCHAIN_DBGDEFAULTDEPS') == '1') or (bb.data.inherits_class('packagegroup', d))) + + for suffix in pkgs: + for pkg in pkgs[suffix]: + if d.getVarFlag('RRECOMMENDS:' + pkg, 'nodeprrecs'): + continue + (base, func) = pkgs[suffix][pkg] + if suffix == "-dev": + pkg_adddeprrecs(pkg, base, suffix, func, depends, d) + elif suffix == "-dbg": + if not dbgdefaultdeps: + pkg_addrrecs(pkg, base, suffix, func, pkglibdeplist, d) + continue + if len(pkgs[suffix]) == 1: + pkg_addrrecs(pkg, base, suffix, func, rdepends, d) + else: + rdeps = [] + for dep in bb.utils.explode_deps(d.getVar('RDEPENDS:' + base) or ""): + add_dep(rdeps, dep) + pkg_addrrecs(pkg, base, suffix, func, rdeps, d) +} + +# Since bitbake can't determine which variables are accessed during package +# iteration, we need to list them here: +PACKAGEVARS = "FILES RDEPENDS RRECOMMENDS SUMMARY DESCRIPTION RSUGGESTS RPROVIDES RCONFLICTS PKG ALLOW_EMPTY pkg_postinst pkg_postrm pkg_postinst_ontarget INITSCRIPT_NAME INITSCRIPT_PARAMS DEBIAN_NOAUTONAME ALTERNATIVE PKGE PKGV PKGR USERADD_PARAM GROUPADD_PARAM CONFFILES SYSTEMD_SERVICE LICENSE SECTION pkg_preinst pkg_prerm RREPLACES GROUPMEMS_PARAM SYSTEMD_AUTO_ENABLE SKIP_FILEDEPS PRIVATE_LIBS PACKAGE_ADD_METADATA" + +def gen_packagevar(d, pkgvars="PACKAGEVARS"): + ret = [] + pkgs = (d.getVar("PACKAGES") or "").split() + vars = (d.getVar(pkgvars) or "").split() + for v in vars: + ret.append(v) + for p in pkgs: + for v in vars: + ret.append(v + ":" + p) + + # Ensure that changes to INCOMPATIBLE_LICENSE re-run do_package for + # affected recipes. + ret.append('_exclude_incompatible-%s' % p) + return " ".join(ret) + +PACKAGE_PREPROCESS_FUNCS ?= "" +# Functions for setting up PKGD +PACKAGEBUILDPKGD ?= " \ + package_prepare_pkgdata \ + perform_packagecopy \ + ${PACKAGE_PREPROCESS_FUNCS} \ + split_and_strip_files \ + fixup_perms \ + " +# Functions which split PKGD up into separate packages +PACKAGESPLITFUNCS ?= " \ + package_do_split_locales \ + populate_packages" +# Functions which process metadata based on split packages +PACKAGEFUNCS += " \ + package_fixsymlinks \ + package_name_hook \ + package_do_filedeps \ + package_do_shlibs \ + package_do_pkgconfig \ + read_shlibdeps \ + package_depchains \ + emit_pkgdata" + +python do_package () { + # Change the following version to cause sstate to invalidate the package + # cache. This is useful if an item this class depends on changes in a + # way that the output of this class changes. rpmdeps is a good example + # as any change to rpmdeps requires this to be rerun. + # PACKAGE_BBCLASS_VERSION = "4" + + # Init cachedpath + global cpath + cpath = oe.cachedpath.CachedPath() + + ########################################################################### + # Sanity test the setup + ########################################################################### + + packages = (d.getVar('PACKAGES') or "").split() + if len(packages) < 1: + bb.debug(1, "No packages to build, skipping do_package") + return + + workdir = d.getVar('WORKDIR') + outdir = d.getVar('DEPLOY_DIR') + dest = d.getVar('D') + dvar = d.getVar('PKGD') + pn = d.getVar('PN') + + if not workdir or not outdir or not dest or not dvar or not pn: + msg = "WORKDIR, DEPLOY_DIR, D, PN and PKGD all must be defined, unable to package" + oe.qa.handle_error("var-undefined", msg, d) + return + + bb.build.exec_func("package_convert_pr_autoinc", d) + + ########################################################################### + # Optimisations + ########################################################################### + + # Continually expanding complex expressions is inefficient, particularly + # when we write to the datastore and invalidate the expansion cache. This + # code pre-expands some frequently used variables + + def expandVar(x, d): + d.setVar(x, d.getVar(x)) + + for x in 'PN', 'PV', 'BPN', 'TARGET_SYS', 'EXTENDPRAUTO': + expandVar(x, d) + + ########################################################################### + # Setup PKGD (from D) + ########################################################################### + + for f in (d.getVar('PACKAGEBUILDPKGD') or '').split(): + bb.build.exec_func(f, d) + + ########################################################################### + # Split up PKGD into PKGDEST + ########################################################################### + + cpath = oe.cachedpath.CachedPath() + + for f in (d.getVar('PACKAGESPLITFUNCS') or '').split(): + bb.build.exec_func(f, d) + + ########################################################################### + # Process PKGDEST + ########################################################################### + + # Build global list of files in each split package + global pkgfiles + pkgfiles = {} + packages = d.getVar('PACKAGES').split() + pkgdest = d.getVar('PKGDEST') + for pkg in packages: + pkgfiles[pkg] = [] + for walkroot, dirs, files in cpath.walk(pkgdest + "/" + pkg): + for file in files: + pkgfiles[pkg].append(walkroot + os.sep + file) + + for f in (d.getVar('PACKAGEFUNCS') or '').split(): + bb.build.exec_func(f, d) + + oe.qa.exit_if_errors(d) +} + +do_package[dirs] = "${SHLIBSWORKDIR} ${D}" +do_package[vardeps] += "${PACKAGEBUILDPKGD} ${PACKAGESPLITFUNCS} ${PACKAGEFUNCS} ${@gen_packagevar(d)}" +addtask package after do_install + +SSTATETASKS += "do_package" +do_package[cleandirs] = "${PKGDEST} ${PKGDESTWORK}" +do_package[sstate-plaindirs] = "${PKGD} ${PKGDEST} ${PKGDESTWORK}" +do_package_setscene[dirs] = "${STAGING_DIR}" + +python do_package_setscene () { + sstate_setscene(d) +} +addtask do_package_setscene + +# Copy from PKGDESTWORK to tempdirectory as tempdirectory can be cleaned at both +# do_package_setscene and do_packagedata_setscene leading to races +python do_packagedata () { + bb.build.exec_func("package_get_auto_pr", d) + + src = d.expand("${PKGDESTWORK}") + dest = d.expand("${WORKDIR}/pkgdata-pdata-input") + oe.path.copyhardlinktree(src, dest) + + bb.build.exec_func("packagedata_translate_pr_autoinc", d) +} +do_packagedata[cleandirs] += "${WORKDIR}/pkgdata-pdata-input" + +# Translate the EXTENDPRAUTO and AUTOINC to the final values +packagedata_translate_pr_autoinc() { + find ${WORKDIR}/pkgdata-pdata-input -type f | xargs --no-run-if-empty \ + sed -e 's,@PRSERV_PV_AUTOINC@,${PRSERV_PV_AUTOINC},g' \ + -e 's,@EXTENDPRAUTO@,${EXTENDPRAUTO},g' -i +} + +addtask packagedata before do_build after do_package + +SSTATETASKS += "do_packagedata" +do_packagedata[sstate-inputdirs] = "${WORKDIR}/pkgdata-pdata-input" +do_packagedata[sstate-outputdirs] = "${PKGDATA_DIR}" +do_packagedata[stamp-extra-info] = "${MACHINE_ARCH}" + +python do_packagedata_setscene () { + sstate_setscene(d) +} +addtask do_packagedata_setscene + +# +# Helper functions for the package writing classes +# + +def mapping_rename_hook(d): + """ + Rewrite variables to account for package renaming in things + like debian.bbclass or manual PKG variable name changes + """ + pkg = d.getVar("PKG") + runtime_mapping_rename("RDEPENDS", pkg, d) + runtime_mapping_rename("RRECOMMENDS", pkg, d) + runtime_mapping_rename("RSUGGESTS", pkg, d) diff --git a/classes/siteinfo.bbclass b/classes/siteinfo.bbclass new file mode 100644 index 0000000..34ca9bb --- /dev/null +++ b/classes/siteinfo.bbclass @@ -0,0 +1,226 @@ +# This class exists to provide information about the targets that +# may be needed by other classes and/or recipes. If you add a new +# target this will probably need to be updated. + +# +# Returns information about 'what' for the named target 'target' +# where 'target' == "<arch>-<os>" +# +# 'what' can be one of +# * target: Returns the target name ("<arch>-<os>") +# * endianness: Return "be" for big endian targets, "le" for little endian +# * bits: Returns the bit size of the target, either "32" or "64" +# * libc: Returns the name of the c library used by the target +# +# It is an error for the target not to exist. +# If 'what' doesn't exist then an empty value is returned +# +def siteinfo_data_for_machine(arch, os, d): + archinfo = { + "allarch": "endian-little bit-32", # bogus, but better than special-casing the checks below for allarch + "aarch64": "endian-little bit-64 arm-common arm-64", + "aarch64_be": "endian-big bit-64 arm-common arm-64", + "arc": "endian-little bit-32 arc-common", + "arceb": "endian-big bit-32 arc-common", + "arm": "endian-little bit-32 arm-common arm-32", + "armeb": "endian-big bit-32 arm-common arm-32", + "avr32": "endian-big bit-32 avr32-common", + "bfin": "endian-little bit-32 bfin-common", + "epiphany": "endian-little bit-32", + "i386": "endian-little bit-32 ix86-common", + "i486": "endian-little bit-32 ix86-common", + "i586": "endian-little bit-32 ix86-common", + "i686": "endian-little bit-32 ix86-common", + "ia64": "endian-little bit-64", + "lm32": "endian-big bit-32", + "m68k": "endian-big bit-32", + "microblaze": "endian-big bit-32 microblaze-common", + "microblazeel": "endian-little bit-32 microblaze-common", + "mips": "endian-big bit-32 mips-common", + "mips64": "endian-big bit-64 mips-common", + "mips64el": "endian-little bit-64 mips-common", + "mipsisa64r6": "endian-big bit-64 mips-common", + "mipsisa64r6el": "endian-little bit-64 mips-common", + "mipsel": "endian-little bit-32 mips-common", + "mipsisa32r6": "endian-big bit-32 mips-common", + "mipsisa32r6el": "endian-little bit-32 mips-common", + "powerpc": "endian-big bit-32 powerpc-common", + "powerpcle": "endian-little bit-32 powerpc-common", + "nios2": "endian-little bit-32 nios2-common", + "powerpc64": "endian-big bit-64 powerpc-common", + "powerpc64le": "endian-little bit-64 powerpc-common", + "ppc": "endian-big bit-32 powerpc-common", + "ppc64": "endian-big bit-64 powerpc-common", + "ppc64le" : "endian-little bit-64 powerpc-common", + "riscv32": "endian-little bit-32 riscv-common", + "riscv64": "endian-little bit-64 riscv-common", + "sh3": "endian-little bit-32 sh-common", + "sh3eb": "endian-big bit-32 sh-common", + "sh4": "endian-little bit-32 sh-common", + "sh4eb": "endian-big bit-32 sh-common", + "sparc": "endian-big bit-32", + "viac3": "endian-little bit-32 ix86-common", + "x86_64": "endian-little", # bitinfo specified in targetinfo + } + osinfo = { + "darwin": "common-darwin", + "darwin21": "common-darwin", + "linux": "common-linux common-glibc", + "linux-gnu": "common-linux common-glibc", + "linux-gnu_ilp32": "common-linux common-glibc", + "linux-gnux32": "common-linux common-glibc", + "linux-gnun32": "common-linux common-glibc", + "linux-gnueabi": "common-linux common-glibc", + "linux-gnuspe": "common-linux common-glibc", + "linux-musl": "common-linux common-musl", + "linux-muslx32": "common-linux common-musl", + "linux-musleabi": "common-linux common-musl", + "linux-muslspe": "common-linux common-musl", + "uclinux-uclibc": "common-uclibc", + "cygwin": "common-cygwin", + "mingw32": "common-mingw", + } + targetinfo = { + "aarch64-linux-gnu": "aarch64-linux", + "aarch64_be-linux-gnu": "aarch64_be-linux", + "aarch64-linux-gnu_ilp32": "bit-32 aarch64_be-linux arm-32", + "aarch64_be-linux-gnu_ilp32": "bit-32 aarch64_be-linux arm-32", + "aarch64-linux-musl": "aarch64-linux", + "aarch64_be-linux-musl": "aarch64_be-linux", + "arm-linux-gnueabi": "arm-linux", + "arm-linux-musleabi": "arm-linux", + "armeb-linux-gnueabi": "armeb-linux", + "armeb-linux-musleabi": "armeb-linux", + "microblazeel-linux" : "microblaze-linux", + "microblazeel-linux-musl" : "microblaze-linux", + "mips-linux-musl": "mips-linux", + "mipsel-linux-musl": "mipsel-linux", + "mips64-linux-musl": "mips64-linux", + "mips64el-linux-musl": "mips64el-linux", + "mips64-linux-gnun32": "mips-linux bit-32", + "mips64el-linux-gnun32": "mipsel-linux bit-32", + "mipsisa64r6-linux-gnun32": "mipsisa32r6-linux bit-32", + "mipsisa64r6el-linux-gnun32": "mipsisa32r6el-linux bit-32", + "powerpc-linux": "powerpc32-linux powerpc32-linux-glibc", + "powerpc-linux-musl": "powerpc-linux powerpc32-linux powerpc32-linux-musl", + "powerpcle-linux": "powerpc32-linux powerpc32-linux-glibc", + "powerpcle-linux-musl": "powerpc-linux powerpc32-linux powerpc32-linux-musl", + "powerpc-linux-gnuspe": "powerpc-linux powerpc32-linux powerpc32-linux-glibc", + "powerpc-linux-muslspe": "powerpc-linux powerpc32-linux powerpc32-linux-musl", + "powerpc64-linux-gnuspe": "powerpc-linux powerpc64-linux powerpc64-linux-glibc", + "powerpc64-linux-muslspe": "powerpc-linux powerpc64-linux powerpc64-linux-musl", + "powerpc64-linux": "powerpc-linux powerpc64-linux powerpc64-linux-glibc", + "powerpc64-linux-musl": "powerpc-linux powerpc64-linux powerpc64-linux-musl", + "powerpc64le-linux": "powerpc-linux powerpc64-linux powerpc64-linux-glibc", + "powerpc64le-linux-musl": "powerpc-linux powerpc64-linux powerpc64-linux-musl", + "riscv32-linux": "riscv32-linux", + "riscv32-linux-musl": "riscv32-linux", + "riscv64-linux": "riscv64-linux", + "riscv64-linux-musl": "riscv64-linux", + "x86_64-cygwin": "bit-64", + "x86_64-darwin": "bit-64", + "x86_64-darwin21": "bit-64", + "x86_64-linux": "bit-64", + "x86_64-linux-musl": "x86_64-linux bit-64", + "x86_64-linux-muslx32": "bit-32 ix86-common x32-linux", + "x86_64-elf": "bit-64", + "x86_64-linux-gnu": "bit-64 x86_64-linux", + "x86_64-linux-gnux32": "bit-32 ix86-common x32-linux", + "x86_64-mingw32": "bit-64", + } + + # Add in any extra user supplied data which may come from a BSP layer, removing the + # need to always change this class directly + extra_siteinfo = (d.getVar("SITEINFO_EXTRA_DATAFUNCS") or "").split() + for m in extra_siteinfo: + call = m + "(archinfo, osinfo, targetinfo, d)" + locs = { "archinfo" : archinfo, "osinfo" : osinfo, "targetinfo" : targetinfo, "d" : d} + archinfo, osinfo, targetinfo = bb.utils.better_eval(call, locs) + + target = "%s-%s" % (arch, os) + + sitedata = [] + if arch in archinfo: + sitedata.extend(archinfo[arch].split()) + if os in osinfo: + sitedata.extend(osinfo[os].split()) + if target in targetinfo: + sitedata.extend(targetinfo[target].split()) + sitedata.append(target) + sitedata.append("common") + + bb.debug(1, "SITE files %s" % sitedata); + return sitedata + +def siteinfo_data(d): + return siteinfo_data_for_machine(d.getVar("HOST_ARCH"), d.getVar("HOST_OS"), d) + +python () { + sitedata = set(siteinfo_data(d)) + if "endian-little" in sitedata: + d.setVar("SITEINFO_ENDIANNESS", "le") + elif "endian-big" in sitedata: + d.setVar("SITEINFO_ENDIANNESS", "be") + else: + bb.error("Unable to determine endianness for architecture '%s'" % + d.getVar("HOST_ARCH")) + bb.fatal("Please add your architecture to siteinfo.bbclass") + + if "bit-32" in sitedata: + d.setVar("SITEINFO_BITS", "32") + elif "bit-64" in sitedata: + d.setVar("SITEINFO_BITS", "64") + else: + bb.error("Unable to determine bit size for architecture '%s'" % + d.getVar("HOST_ARCH")) + bb.fatal("Please add your architecture to siteinfo.bbclass") +} + +# Layers with siteconfig need to add a replacement path to this variable so the +# sstate isn't path specific +SITEINFO_PATHVARS = "COREBASE" + +def siteinfo_get_files(d, sysrootcache=False): + sitedata = siteinfo_data(d) + sitefiles = [] + searched = [] + for path in d.getVar("BBPATH").split(":"): + for element in sitedata: + filename = os.path.join(path, "site", element) + if os.path.exists(filename): + searched.append(filename + ":True") + sitefiles.append(filename) + else: + searched.append(filename + ":False") + + # Have to parameterise out hardcoded paths such as COREBASE for the main site files + for var in d.getVar("SITEINFO_PATHVARS").split(): + searched2 = [] + replace = os.path.normpath(d.getVar(var)) + for s in searched: + searched2.append(s.replace(replace, "${" + var + "}")) + searched = searched2 + + if bb.data.inherits_class('native', d) or bb.data.inherits_class('cross', d) or bb.data.inherits_class('crosssdk', d): + # We need sstate sigs for native/cross not to vary upon arch so we can't depend on the site files. + # In future we may want to depend upon all site files? + # This would show up as breaking sstatetests.SStateTests.test_sstate_32_64_same_hash for example + searched = [] + + if not sysrootcache: + return sitefiles, searched + + # Now check for siteconfig cache files in sysroots + path_siteconfig = d.getVar('SITECONFIG_SYSROOTCACHE') + if path_siteconfig and os.path.isdir(path_siteconfig): + for i in os.listdir(path_siteconfig): + if not i.endswith("_config"): + continue + filename = os.path.join(path_siteconfig, i) + sitefiles.append(filename) + return sitefiles, searched + +# +# Make some information available via variables +# +SITECONFIG_SYSROOTCACHE = "${STAGING_DATADIR}/${TARGET_SYS}_config_site.d" diff --git a/conf/layer.conf b/conf/layer.conf index 53eb9d1..cdac803 100644 --- a/conf/layer.conf +++ b/conf/layer.conf @@ -1,6 +1,8 @@ # We have a conf and classes directory, add to BBPATH BBPATH := "${BBPATH}:${LAYERDIR}" +LAYERSERIES_COMPAT_meta-darwin = "kirkstone" + # We have a packages directory, add to BBFILES BBFILES += "${LAYERDIR}/recipes*/*/*.bb ${LAYERDIR}/recipes*/*/*.bbappend" diff --git a/conf/machine-sdk/i386-darwin.conf b/conf/machine-sdk/i386-darwin.conf deleted file mode 100644 index 17e0020..0000000 --- a/conf/machine-sdk/i386-darwin.conf +++ /dev/null @@ -1,30 +0,0 @@ -SDK_ARCH = "i386" -SDK_OS = "darwin" - -#GCCTHREADS_mingw32 = "win32" - -PREFERRED_PROVIDER_virtual/nativesdk-${SDK_PREFIX}libc-for-gcc = "nativesdk-osx-runtime" -PREFERRED_PROVIDER_virtual/${SDK_PREFIX}binutils-crosssdk = "odcctools2-crosssdk" -PREFERRED_PROVIDER_virtual/nativesdk-libc = "nativesdk-osx-runtime" -PREFERRED_PROVIDER_virtual/nativesdk-libintl = "nativesdk-osx-runtime" -PREFERRED_PROVIDER_virtual/nativesdk-libiconv = "nativesdk-osx-runtime" - -USE_NLS_darwin = "no" - -# Do what amounts to a NOOP -SDK_PACKAGING_FUNC = "do_compile" - -SDKPKGSUFFIX = "nativesdk-darwin" - -BUILDSDK_CFLAGS += "-mmacosx-version-min=10.5" - -# Remove -rpath-link -BUILDSDK_LDFLAGS = "-mmacosx-version-min=10.5 \ - -L${STAGING_LIBDIR} \ - -Wl,-rpath,${libdir} \ - -L${STAGING_DIR_HOST}${base_libdir} \ - -Wl,-rpath,${base_libdir}" - -SDKUSE_NLS = "no" - -MACHINEOVERRIDES .= ":darwinsdk"
\ No newline at end of file diff --git a/conf/machine-sdk/x86_64-darwin.conf b/conf/machine-sdk/x86_64-darwin.conf new file mode 100644 index 0000000..c4a111d --- /dev/null +++ b/conf/machine-sdk/x86_64-darwin.conf @@ -0,0 +1,40 @@ +SDK_ARCH = "x86_64" +SDK_OS = "darwin21" + +SOLIBS:darwin21 = ".dylib" +SOLIBSDEV:darwin21 = ".dylibbroken" + +PREFERRED_PROVIDER_virtual/nativesdk-${SDK_PREFIX}libc-for-gcc = "nativesdk-osx-runtime" +PREFERRED_PROVIDER_virtual/nativesdk-${SDK_PREFIX}libc-initial = "nativesdk-osx-runtime" +PREFERRED_PROVIDER_virtual/${SDK_PREFIX}binutils-crosssdk = "cctools-port-crosssdk" +PREFERRED_PROVIDER_virtual/nativesdk-libc = "nativesdk-osx-runtime" +PREFERRED_PROVIDER_virtual/nativesdk-libintl = "nativesdk-osx-runtime" +PREFERRED_PROVIDER_virtual/nativesdk-libiconv = "nativesdk-osx-runtime" + +SDKUSE_NLS = "no" +SDKIMAGE_LINGUAS = "" +SDK_DEPENDS:remove = "nativesdk-glibc-locale nativesdk-qemuwrapper-cross" + +SDKPKGSUFFIX = "nativesdk-darwin" + +OSX_TOOLCHAIN_OPTIONS = " \ + -mmacosx-version-min=12.3 \ + -L${STAGING_DIR_TARGET}${SDKPATHNATIVE}/usr/lib \ + -L${STAGING_DIR_TARGET}${SDKPATHNATIVE}/runtime/usr/lib \ + -L${STAGING_DIR_TARGET}${SDKPATHNATIVE}/runtime/usr/lib/system \ +" + +TOOLCHAIN_OPTIONS:append:darwin21 = " \ + ${OSX_TOOLCHAIN_OPTIONS}" +TOOLCHAIN_OPTIONS:append:class-cross-canadian = " \ + ${OSX_TOOLCHAIN_OPTIONS}" + +# Remove -rpath-link +BUILDSDK_LDFLAGS = " \ + -L${STAGING_LIBDIR} \ + -Wl,-rpath,${libdir} \ + -L${STAGING_DIR_HOST}${base_libdir} \ + -Wl,-rpath,${base_libdir} \ +" + +MACHINEOVERRIDES .= ":darwinsdk" diff --git a/recipes-core/glib-2.0/glib-2.0_%.bbappend b/recipes-core/glib-2.0/glib-2.0_%.bbappend deleted file mode 100644 index a383441..0000000 --- a/recipes-core/glib-2.0/glib-2.0_%.bbappend +++ /dev/null @@ -1,2 +0,0 @@ -EXTRA_OECONF_darwin = "--enable-included-printf=yes ${CORECONF}" -FILES_${PN}_append_darwin = " ${libdir}/charset.alias" diff --git a/recipes-core/meta/meta-environment.bbappend b/recipes-core/meta/meta-environment.bbappend new file mode 100644 index 0000000..e3719f9 --- /dev/null +++ b/recipes-core/meta/meta-environment.bbappend @@ -0,0 +1 @@ +EXCLUDE_FROM_SHLIBS = "1" diff --git a/recipes-core/packagegroups/nativesdk-packagegroup-sdk-host.bbappend b/recipes-core/packagegroups/nativesdk-packagegroup-sdk-host.bbappend index 63b4fc5..170a8c1 100644 --- a/recipes-core/packagegroups/nativesdk-packagegroup-sdk-host.bbappend +++ b/recipes-core/packagegroups/nativesdk-packagegroup-sdk-host.bbappend @@ -1,4 +1,6 @@ -RDEPENDS_${PN}_darwin = "\ - nativesdk-libtool \ - nativesdk-qemu \ +RDEPENDS:${PN}:darwin21 = "\ + nativesdk-flex \ + nativesdk-ninja \ + nativesdk-bison \ + nativesdk-sdk-provides-dummy \ " diff --git a/recipes-core/packagegroups/packagegroup-cross-canadian.bbappend b/recipes-core/packagegroups/packagegroup-cross-canadian.bbappend index 928f9a5..de29f47 100644 --- a/recipes-core/packagegroups/packagegroup-cross-canadian.bbappend +++ b/recipes-core/packagegroups/packagegroup-cross-canadian.bbappend @@ -1,5 +1,9 @@ -RDEPENDS_${PN}_darwinsdk = "\ - binutils-cross-canadian-${TRANSLATED_TARGET_ARCH} \ - gcc-cross-canadian-${TRANSLATED_TARGET_ARCH} \ +# Use indirection to stop these being expanded prematurely +BINUTILS = "binutils-cross-canadian-${TRANSLATED_TARGET_ARCH}" +GCC = "gcc-cross-canadian-${TRANSLATED_TARGET_ARCH}" + +RDEPENDS:${PN}:darwinsdk = "\ + ${@all_multilib_tune_values(d, 'BINUTILS')} \ + ${@all_multilib_tune_values(d, 'GCC')} \ meta-environment-${MACHINE} \ " diff --git a/recipes-core/zlib/files/0001-fix-wrong-libtool-path.patch b/recipes-core/zlib/files/0001-fix-wrong-libtool-path.patch new file mode 100644 index 0000000..528b46b --- /dev/null +++ b/recipes-core/zlib/files/0001-fix-wrong-libtool-path.patch @@ -0,0 +1,33 @@ +From 3b7dfa06c12eb605ae244bbdf37a5c502f63a035 Mon Sep 17 00:00:00 2001 +From: Dominik Schnitzer <dominik@snap.com> +Date: Fri, 12 May 2023 10:11:56 +0000 +Subject: [PATCH] fix wrong libtool path + +Upstream-Status: Inappropriate [OE specific] +Signed-off-by: Dominik Schnitzer <dominik@snap.com> +--- + configure | 8 +------- + 1 file changed, 1 insertion(+), 7 deletions(-) + +diff --git a/configure b/configure +index 69dfa3f..dcd0e75 100755 +--- a/configure ++++ b/configure +@@ -240,13 +240,7 @@ if test "$gcc" -eq 1 && ($cc -c $test.c) >> configure.log 2>&1; then + SHAREDLIB=libz$shared_ext + SHAREDLIBV=libz.$VER$shared_ext + SHAREDLIBM=libz.$VER1$shared_ext +- LDSHARED=${LDSHARED-"$cc -dynamiclib -install_name $libdir/$SHAREDLIBM -compatibility_version $VER1 -current_version $VER3"} +- if libtool -V 2>&1 | grep Apple > /dev/null; then +- AR="libtool" +- else +- AR="/usr/bin/libtool" +- fi +- ARFLAGS="-o" ;; ++ LDSHARED=${LDSHARED-"$cc -dynamiclib -install_name $libdir/$SHAREDLIBM -compatibility_version $VER1 -current_version $VER3"} ;; + *) LDSHARED=${LDSHARED-"$cc -shared"} ;; + esac + else +-- +2.36.1.vfs.0.0 + diff --git a/recipes-core/zlib/zlib_1.2.%.bbappend b/recipes-core/zlib/zlib_1.2.%.bbappend new file mode 100644 index 0000000..8738b98 --- /dev/null +++ b/recipes-core/zlib/zlib_1.2.%.bbappend @@ -0,0 +1,8 @@ +FILESEXTRAPATHS:prepend := "${THISDIR}/files:" + +SRC_URI += "\ + file://0001-fix-wrong-libtool-path.patch \ +" +do_configure:darwin21 () { + uname=darwin ./configure --prefix=${prefix} --shared --libdir=${libdir} +} diff --git a/recipes-core/zlib/zlib_1.2.8.bbappend b/recipes-core/zlib/zlib_1.2.8.bbappend deleted file mode 100644 index 70dfb14..0000000 --- a/recipes-core/zlib/zlib_1.2.8.bbappend +++ /dev/null @@ -1,11 +0,0 @@ -do_configure_darwin (){ - uname=darwin ./configure --prefix=${prefix} --shared --libdir=${libdir} -} - -do_compile_prepend_darwin () { - export ARFLAGS=rc -} - -do_install_prepend_darwin () { - export ARFLAGS=rc -} diff --git a/recipes-devtools/binutils/binutils-cross-canadian_2.%.bbappend b/recipes-devtools/binutils/binutils-cross-canadian_2.%.bbappend new file mode 100644 index 0000000..d3cf881 --- /dev/null +++ b/recipes-devtools/binutils/binutils-cross-canadian_2.%.bbappend @@ -0,0 +1,2 @@ +# Remove -rpath-link and -rpath +LDFLAGS:darwinsdk = "${BUILDSDK_LDFLAGS}" diff --git a/recipes-devtools/binutils/binutils-cross-canadian_2.24.bbappend b/recipes-devtools/binutils/binutils-cross-canadian_2.24.bbappend deleted file mode 100644 index 13e5371..0000000 --- a/recipes-devtools/binutils/binutils-cross-canadian_2.24.bbappend +++ /dev/null @@ -1,4 +0,0 @@ -#Remove -rpath-link and -rpath -LDFLAGS_darwinsdk = "${BUILDSDK_LDFLAGS} -L${libdir}/.." - - diff --git a/recipes-devtools/binutils/binutils/0001-OS-1142-Do-not-use-nm-B-for-Darwin-s-nm.patch b/recipes-devtools/binutils/binutils/0001-OS-1142-Do-not-use-nm-B-for-Darwin-s-nm.patch new file mode 100644 index 0000000..6d28872 --- /dev/null +++ b/recipes-devtools/binutils/binutils/0001-OS-1142-Do-not-use-nm-B-for-Darwin-s-nm.patch @@ -0,0 +1,51 @@ +From ae737b4496ce5a80a2dec68640f92f6b891af7ee Mon Sep 17 00:00:00 2001 +From: Etienne Cordonnier <ecordonnier@snap.com> +Date: Thu, 25 Aug 2022 16:08:58 +0200 +Subject: [PATCH] [OS-1142] Do not use nm -B for Darwin's nm + +The cross-compiled tool "x86_64-pokysdk-darwin21-nm" does not support +the option -B, however the configure script wrongly detects that this +option is supported. +This causes compilation failures down the line, because configure then +uses "nm -B" to assign the variable "global_symbol_pipe", and this variable +becomes empty because "nm -B" fails. + +The emptyness of "global_symbol_pipe" causes some libtool link script to be executed with +two pipes and to fail due to syntax error: "| |" + +Upstream-Status: Pending [would require proper fix instead of this workaround] +Signed-off-by: Etienne Cordonnier <ecordonnier@snap.com> +--- + libbacktrace/configure | 2 +- + libctf/configure | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/libbacktrace/configure b/libbacktrace/configure +index 90667680701..dec8d96771b 100755 +--- a/libbacktrace/configure ++++ b/libbacktrace/configure +@@ -5846,7 +5846,7 @@ else + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + case `"$tmp_nm" -B "$tmp_nm" 2>&1 | grep -v '^ *$' | sed '1q'` in +- *$tmp_nm*) lt_cv_path_NM="$tmp_nm -B" ++ *$tmp_nm*) lt_cv_path_NM="$tmp_nm" + break + ;; + *) +diff --git a/libctf/configure b/libctf/configure +index 1b0ee0d32c6..f77ae01e21a 100755 +--- a/libctf/configure ++++ b/libctf/configure +@@ -5982,7 +5982,7 @@ else + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + case `"$tmp_nm" -B "$tmp_nm" 2>&1 | grep -v '^ *$' | sed '1q'` in +- *$tmp_nm*) lt_cv_path_NM="$tmp_nm -B" ++ *$tmp_nm*) lt_cv_path_NM="$tmp_nm" + break + ;; + *) +-- +2.36.1.vfs.0.0 + diff --git a/recipes-devtools/binutils/binutils_%.bbappend b/recipes-devtools/binutils/binutils_%.bbappend new file mode 100644 index 0000000..d6827ab --- /dev/null +++ b/recipes-devtools/binutils/binutils_%.bbappend @@ -0,0 +1,14 @@ +FILESEXTRAPATHS:prepend := "${THISDIR}/binutils:" + +SRC_URI:append = " \ + file://0001-OS-1142-Do-not-use-nm-B-for-Darwin-s-nm.patch \ +" + +# Add dylib files to package nativesdk-binutils +FILES:${PN} += " \ + ${libdir} \ +" + +# TODO: Needs to be fixed by packaging this right +# We should filter .debug out to the dbg package +INSANE_SKIP:nativesdk-binutils = "debug-files" diff --git a/recipes-devtools/cctools-port/cctools-port-crosssdk_973.0.1.bb b/recipes-devtools/cctools-port/cctools-port-crosssdk_973.0.1.bb new file mode 100644 index 0000000..4082150 --- /dev/null +++ b/recipes-devtools/cctools-port/cctools-port-crosssdk_973.0.1.bb @@ -0,0 +1,41 @@ +DESCRIPTION = "Linux port of Apple CCTools" +SECTION = "devel" +LICENSE = "ApplePSLicense-2.0" +LIC_FILES_CHKSUM = "file://cctools/APPLE_LICENSE;md5=dacaafbaf91483700da837d31213a1e8" + +SRCREV = "f28fb5e9c31efd3d0552afcce2d2c03cae25c1ca" +SRC_URI = "git://github.com/tpoechtrager/cctools-port.git;branch=master;protocol=https" + +PR = "r2" + +inherit autotools crosssdk + +DEPENDS += "util-linux-native openssl-native xar-native libtapi-native" +PROVIDES = "virtual/${TARGET_PREFIX}binutils-crosssdk" + +DEPENDS += "clang-native libcxx-native" + +TOOLCHAIN:class-crosssdk = "clang" +COMPILER_RT:class-crosssdk = "-rtlib=libgcc --unwindlib=libgcc" +LIBCPLUSPLUS:class-crosssdk = "-stdlib=libc++ -lc++abi" + +EXTRA_OECONF:append = " \ + --with-llvm-config=${STAGING_DIR_NATIVE}/usr/bin/llvm-config \ + --enable-lto-support \ + --enable-xar-support \ + --with-libxar=${STAGING_DIR_NATIVE}/usr \ + --enable-tapi-support \ + --with-libtapi=${STAGING_DIR_NATIVE}/usr \ +" + +S = "${WORKDIR}/git" +B = "${WORKDIR}/build" + +AUTOTOOLS_SCRIPT_PATH = "${S}/cctools" + +do_configure:prepend() { + PWD_CUR=$(pwd) + cd ${AUTOTOOLS_SCRIPT_PATH} + libtoolize + cd ${PWD_CUR} +} diff --git a/recipes-devtools/clang/clang-crosssdk_%.bbappend b/recipes-devtools/clang/clang-crosssdk_%.bbappend new file mode 100644 index 0000000..158b3ed --- /dev/null +++ b/recipes-devtools/clang/clang-crosssdk_%.bbappend @@ -0,0 +1 @@ +PN = "clang-crosssdk-${SDK_SYS}" diff --git a/recipes-devtools/clang/clang/0037-Fixes_for_Darwin_SDKs.patch b/recipes-devtools/clang/clang/0037-Fixes_for_Darwin_SDKs.patch new file mode 100644 index 0000000..c6db8d9 --- /dev/null +++ b/recipes-devtools/clang/clang/0037-Fixes_for_Darwin_SDKs.patch @@ -0,0 +1,67 @@ +From cb9b87097803b4444ec9aa52b5054ba88e4da01e Mon Sep 17 00:00:00 2001 +From: Dominik Schnitzer <dominik@snap.com> +Date: Wed, 27 Apr 2022 11:22:17 +0000 +Subject: [PATCH] Fixes for Darwin SDKs + +Upstream-Status: Inappropriate [OE specific] +Signed-off-by: Dominik Schnitzer <dominik@snap.com> +--- + clang/lib/Driver/ToolChains/Darwin.cpp | 17 ++++++++++++----- + llvm/cmake/modules/AddLLVM.cmake | 1 - + llvm/cmake/modules/CrossCompile.cmake | 2 +- + 3 files changed, 13 insertions(+), 7 deletions(-) + +diff --git a/clang/lib/Driver/ToolChains/Darwin.cpp b/clang/lib/Driver/ToolChains/Darwin.cpp +index f7da3f187814..0656f5cbad69 100644 +--- a/clang/lib/Driver/ToolChains/Darwin.cpp ++++ b/clang/lib/Driver/ToolChains/Darwin.cpp +@@ -2299,12 +2299,19 @@ void DarwinClang::AddClangCXXStdlibIncludeArgs( + case llvm::Triple::x86: + case llvm::Triple::x86_64: + IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx, +- "4.2.1", +- "i686-apple-darwin10", +- arch == llvm::Triple::x86_64 ? "x86_64" : ""); ++ "11.4.0", ++ "x86_64#SDK_VENDOR#-darwin21", ++ ""); + IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx, +- "4.0.0", "i686-apple-darwin8", +- ""); ++ "11.4.0", "", ""); ++ { ++ const char *S = ::getenv("YOCTO_SDKPATH"); ++ if (S && (S[0] != '\0')) { ++ llvm::SmallString<128> Runtime; ++ llvm::sys::path::append(Runtime, S); ++ addSystemInclude(DriverArgs, CC1Args, Runtime); ++ } ++ } + break; + + case llvm::Triple::arm: +diff --git a/llvm/cmake/modules/AddLLVM.cmake b/llvm/cmake/modules/AddLLVM.cmake +index d34083fa52ec..477dc1ade3fc 100644 +--- a/llvm/cmake/modules/AddLLVM.cmake ++++ b/llvm/cmake/modules/AddLLVM.cmake +@@ -2137,7 +2137,6 @@ function(llvm_setup_rpath name) + endif() + + if (APPLE) +- set(_install_name_dir INSTALL_NAME_DIR "@rpath") + set(_install_rpath "@loader_path/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir}) + elseif(${CMAKE_SYSTEM_NAME} MATCHES "AIX" AND BUILD_SHARED_LIBS) + # $ORIGIN is not interpreted at link time by aix ld. +diff --git a/llvm/cmake/modules/CrossCompile.cmake b/llvm/cmake/modules/CrossCompile.cmake +index 8a441729c943..8e19e4c93d9f 100644 +--- a/llvm/cmake/modules/CrossCompile.cmake ++++ b/llvm/cmake/modules/CrossCompile.cmake +@@ -68,7 +68,7 @@ function(llvm_create_cross_target project_name target_name toolchain buildtype) + endforeach() + + add_custom_command(OUTPUT ${${project_name}_${target_name}_BUILD}/CMakeCache.txt +- COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" ++ COMMAND ${CMAKE_COMMAND} -E env --unset=LDFLAGS --unset=CFLAGS --unset=CXXFLAGS --unset=CC --unset=LD --unset=CXX ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" + -DCMAKE_MAKE_PROGRAM="${CMAKE_MAKE_PROGRAM}" + -DCMAKE_C_COMPILER_LAUNCHER="${CMAKE_C_COMPILER_LAUNCHER}" + -DCMAKE_CXX_COMPILER_LAUNCHER="${CMAKE_CXX_COMPILER_LAUNCHER}" diff --git a/recipes-devtools/clang/clang_%.bbappend b/recipes-devtools/clang/clang_%.bbappend new file mode 100644 index 0000000..ce2a3b3 --- /dev/null +++ b/recipes-devtools/clang/clang_%.bbappend @@ -0,0 +1,86 @@ +DEPENDS:remove:class-nativesdk:darwin21 = "nativesdk-python3" +DEPENDS:remove:class-nativesdk:darwin21 = "libxml2" +DEPENDS:remove:class-nativesdk:darwin21 = "libffi" +DEPENDS:append:class-nativesdk:darwin21 = " xz" +PACKAGECONFIG:remove:class-nativesdk:darwin21 = "libedit" +PACKAGECONFIG:remove:class-nativesdk:darwin21 = "shared-libs" + +DEPENDS:remove:class-nativesdk = "clang-crosssdk-${SDK_ARCH}" +DEPENDS:append:class-nativesdk = " clang-crosssdk-${SDK_SYS}" + +# perl tries to call readelf, which does not exist on darwin (it would need +# to call objdump instead but the detection logic does not work for some reason) +RDEPENDS:${PN}:remove:class-nativesdk:darwin21 = " \ + perl-module-digest-md5 \ + perl-module-file-basename \ + perl-module-file-copy \ + perl-module-file-find \ + perl-module-file-path \ + perl-module-findbin \ + perl-module-hash-util \ + perl-module-sys-hostname \ + perl-module-term-ansicolor \ +" + +COMPILER_RT:class-nativesdk:toolchain-clang:runtime-llvm:darwin21 = "" +LIBCPLUSPLUS:class-nativesdk:toolchain-clang:darwin21 = " -stdlib=libstdc++" + +OSXSDK:class-nativesdk:darwin21 = "${STAGING_DIR_TARGET}${SDKPATHNATIVE}/runtime" +do_compile:prepend:class-nativesdk:darwin21() { + export YOCTO_SDKPATH="${OSXSDK}/usr/include" +} + +LDFLAGS:toolchain-clang:class-nativesdk:darwin21 = " \ + ${BUILDSDK_LDFLAGS} \ + -lgcc_s \ +" +LDFLAGS:remove:toolchain-clang:class-nativesdk:x86-64:darwin21 = " -Wl,-dynamic-linker,${base_libdir}/ld-linux-x86-64.so.2" +LDFLAGS:remove:toolchain-clang:class-nativesdk:x86:darwin21 = " -Wl,-dynamic-linker,${base_libdir}/ld-linux.so.2" +LDFLAGS:remove:toolchain-clang:class-nativesdk:aarch64:darwin21 = " -Wl,-dynamic-linker,${base_libdir}/ld-linux-aarch64.so.1" + +CFLAGS:append:class-nativesdk:darwin21 = " \ + -femulated-tls \ + -I${OSXSDK}/usr/include \ + -include TargetConditionals.h \ +" + +CXXFLAGS:append:class-nativesdk:darwin21 = " \ + -femulated-tls \ + -Wno-elaborated-enum-base \ + -I${OSXSDK}/usr/include \ + -include TargetConditionals.h \ + -F${OSXSDK}/System/Library/Frameworks \ + -F${OSXSDK}/System/Library/Frameworks/CoreServices.framework/Frameworks \ +" + +EXTRA_OECMAKE:remove:class-nativesdk:darwin21 = "-DPYTHON_LIBRARY=${STAGING_LIBDIR}/lib${PYTHON_DIR}${PYTHON_ABI}.so" +EXTRA_OECMAKE:remove:class-nativesdk:darwin21 = "-DPYTHON_INCLUDE_DIR=${STAGING_INCDIR}/${PYTHON_DIR}${PYTHON_ABI}" +EXTRA_OECMAKE:remove:class-nativesdk:darwin21 = "-DPYTHON_EXECUTABLE='${PYTHON}'" +EXTRA_OECMAKE:append:class-nativesdk:darwin21 = " \ + -DCMAKE_FRAMEWORK_PATH='${OSXSDK}/System/Library/Frameworks'\ + -DLLDB_USE_SYSTEM_DEBUGSERVER=ON \ + -DLLDB_INCLUDE_TESTS=OFF \ + -DLLDB_ENABLE_PYTHON=OFF \ + \ + -DLLDB_ENABLE_LZMA=ON \ + \ + -DLLVM_ENABLE_LIBEDIT=ON -DLLDB_ENABLE_LIBEDIT=ON \ + -DLibEdit_LIBRARIES=${OSXSDK}/usr/lib/libedit.tbd \ + -DLibEdit_INCLUDE_DIRS=${OSXSDK}/usr/include \ + \ + -DCURSES_INCLUDE_DIRS=${OSXSDK}/usr/include \ + -DCURSES_LIBRARIES=${OSXSDK}/usr/lib/libcurses.tbd \ + -DPANEL_LIBRARIES=${OSXSDK}/usr/lib/libpanel.tbd \ + \ + -DLIBXML2_INCLUDE_DIR=${OSXSDK}/usr/include/libxml2 \ + -DLIBXML2_LIBRARY=${OSXSDK}/usr/lib/libxml2.tbd \ + \ + -DFFI_LIBRARY_PATH=${OSXSDK}/usr/lib/libffi.tbd \ + -DFFI_INCLUDE_PATH=${OSXSDK}/usr/include \ +" + +FILES:${PN} += " \ + ${libdir}/LLVMgold.dylib \ +" + +INSANE_SKIP:${PN}:class-nativesdk:darwin21 += " file-rdeps" diff --git a/recipes-devtools/clang/llvm-project-source.bbappend b/recipes-devtools/clang/llvm-project-source.bbappend new file mode 100644 index 0000000..3fa69d0 --- /dev/null +++ b/recipes-devtools/clang/llvm-project-source.bbappend @@ -0,0 +1,13 @@ +FILESEXTRAPATHS:prepend := "${THISDIR}/clang:" +SRC_URI:append = " \ + file://0037-Fixes_for_Darwin_SDKs.patch \ +" + +python replace_sdk_vendor() { + import subprocess + bb.note("SDK_VENDOR: %s" % d.getVar('SDK_VENDOR')) + cmd = d.expand("sed -i 's/#SDK_VENDOR#/%s/g' ${S}/clang/lib/Driver/ToolChains/Darwin.cpp" % d.getVar('SDK_VENDOR')) + subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True) +} + +do_patch[postfuncs] += "replace_sdk_vendor" diff --git a/recipes-devtools/erofs-utils/erofs-utils_%.bbappend b/recipes-devtools/erofs-utils/erofs-utils_%.bbappend new file mode 100644 index 0000000..1d65a81 --- /dev/null +++ b/recipes-devtools/erofs-utils/erofs-utils_%.bbappend @@ -0,0 +1,3 @@ +CPPFLAGS:append:class-nativesdk:darwin21 = " \ + -I${STAGING_INCDIR} \ +" diff --git a/recipes-devtools/flex/files/0001-scanner-include-flexdevh-at-top-block-of-scanl.patch b/recipes-devtools/flex/files/0001-scanner-include-flexdevh-at-top-block-of-scanl.patch new file mode 100644 index 0000000..e86e771 --- /dev/null +++ b/recipes-devtools/flex/files/0001-scanner-include-flexdevh-at-top-block-of-scanl.patch @@ -0,0 +1,53 @@ +From 4b5111d9772b5c160340ca96f08d30d7f6db5cda Mon Sep 17 00:00:00 2001 +From: Explorer09 <explorer09@gmail.com> +Date: Mon, 4 Sep 2017 08:28:53 +0800 +Subject: [PATCH] scanner: Include flexdef.h at %top block of scan.l + +config.h may define macros that alter the API of the standard library +funtions, and so it should be included before any other standard +header, even before the skeleton's standard header inclusion. + +For example: config.h may #define _GNU_SOURCE that would expose the +reallocarray() prototype from <stdlib.h> on glibc 2.26+ systems. If we +include <stdlib.h> before config.h, reallocarray() would not be +available for use in lex file since the second include doesn't help +due to header guard. + +For now our config.h might `#define malloc rpl_malloc` -- this +substitution must work before including stdlib.h, or else the compiler +will complain about missing prototypes, and may result in incorrect +code in scan.l (gcc warning: return makes pointer from integer without +a cast [-Wint-conversion]). + +Fixes #247. + +Upstream-Status: Backport [https://github.com/westes/flex/commit/4b5111d9772b5c160340ca96f08d30d7f6db5cda] +Signed-off-by: Dominik Schnitzer <dominik@snap.com> +--- + src/scan.l | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +diff --git a/src/scan.l b/src/scan.l +index 3995bcf1..4f497acd 100644 +--- a/src/scan.l ++++ b/src/scan.l +@@ -1,5 +1,11 @@ + /* scan.l - scanner for flex input -*-C-*- */ + ++%top{ ++/* flexdef.h includes config.h, which may contain macros that alter the API */ ++/* of libc functions. Must include first before any libc header. */ ++#include "flexdef.h" ++} ++ + %{ + /* Copyright (c) 1990 The Regents of the University of California. */ + /* All rights reserved. */ +@@ -32,7 +38,6 @@ + /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */ + /* PURPOSE. */ + +-#include "flexdef.h" + #include "parse.h" + extern bool tablesverify, tablesext; + extern int trlcontxt; /* Set in parse.y for each rule. */ diff --git a/recipes-devtools/flex/flex_%.bbappend b/recipes-devtools/flex/flex_%.bbappend index c87d919..93fa850 100644 --- a/recipes-devtools/flex/flex_%.bbappend +++ b/recipes-devtools/flex/flex_%.bbappend @@ -1,7 +1,5 @@ -do_configure_prepend_darwin () { - sed -i -e '3d' -e 's/lib.c/lib.c malloc.c realloc.c/' ${S}/lib/Makefile.am -} +FILESEXTRAPATHS:prepend := "${THISDIR}/files:" -do_compile_prepend_darwin () { - sed -i ${B}/Makefile -e 's/-no-undefined//;' -}
\ No newline at end of file +SRC_URI:append:class-nativesdk:darwin21 = "\ + file://0001-scanner-include-flexdevh-at-top-block-of-scanl.patch \ + " diff --git a/recipes-devtools/gcc/files/0017-handle-sysroot-support-for-nativesdk-gcc.patch b/recipes-devtools/gcc/files/0017-handle-sysroot-support-for-nativesdk-gcc.patch new file mode 100644 index 0000000..d423e62 --- /dev/null +++ b/recipes-devtools/gcc/files/0017-handle-sysroot-support-for-nativesdk-gcc.patch @@ -0,0 +1,332 @@ +diff --git a/gcc/c-family/c-opts.c b/gcc/c-family/c-opts.c +index 89e05a4c551..5577383665d 100644 +--- a/gcc/c-family/c-opts.c ++++ b/gcc/c-family/c-opts.c +@@ -1436,8 +1436,8 @@ add_prefixed_path (const char *suffix, incpath_kind chain) + size_t prefix_len, suffix_len; + + suffix_len = strlen (suffix); +- prefix = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR; +- prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len; ++ prefix = iprefix ? iprefix : GCC_INCLUDE_DIRVAR; ++ prefix_len = iprefix ? strlen (iprefix) : strlen(GCC_INCLUDE_DIRVAR) - 7; + + path = (char *) xmalloc (prefix_len + suffix_len + 1); + memcpy (path, prefix, prefix_len); +diff --git a/gcc/cppdefault.c b/gcc/cppdefault.c +index d54d6ce0076..7e8e8141ad8 100644 +--- a/gcc/cppdefault.c ++++ b/gcc/cppdefault.c +@@ -35,6 +35,38 @@ + # undef CROSS_INCLUDE_DIR + #endif + ++#ifdef __APPLE__ ++#define GCCRELOCPREFIX __attribute__ ((section (".gccrelocprefix,.gccrelocprefix"))) ++#else ++#define GCCRELOCPREFIX __attribute__ ((section (".gccrelocprefix"))) ++#endif ++static char GPLUSPLUS_INCLUDE_DIRVAR[4096] GCCRELOCPREFIX = GPLUSPLUS_INCLUDE_DIR; ++char GCC_INCLUDE_DIRVAR[4096] GCCRELOCPREFIX = GCC_INCLUDE_DIR; ++static char GPLUSPLUS_TOOL_INCLUDE_DIRVAR[4096] GCCRELOCPREFIX = GPLUSPLUS_TOOL_INCLUDE_DIR; ++static char GPLUSPLUS_BACKWARD_INCLUDE_DIRVAR[4096] GCCRELOCPREFIX = GPLUSPLUS_BACKWARD_INCLUDE_DIR; ++static char STANDARD_STARTFILE_PREFIX_2VAR[4096] GCCRELOCPREFIX = STANDARD_STARTFILE_PREFIX_2 GCC_INCLUDE_SUBDIR_TARGET; ++#ifdef LOCAL_INCLUDE_DIR ++static char LOCAL_INCLUDE_DIRVAR[4096] GCCRELOCPREFIX = LOCAL_INCLUDE_DIR; ++#endif ++#ifdef PREFIX_INCLUDE_DIR ++static char PREFIX_INCLUDE_DIRVAR[4096] GCCRELOCPREFIX = PREFIX_INCLUDE_DIR; ++#endif ++#ifdef FIXED_INCLUDE_DIR ++static char FIXED_INCLUDE_DIRVAR[4096] GCCRELOCPREFIX = FIXED_INCLUDE_DIR; ++#endif ++#ifdef CROSS_INCLUDE_DIR ++static char CROSS_INCLUDE_DIRVAR[4096] GCCRELOCPREFIX = CROSS_INCLUDE_DIR; ++#endif ++#ifdef TOOL_INCLUDE_DIR ++static char TOOL_INCLUDE_DIRVAR[4096] GCCRELOCPREFIX = TOOL_INCLUDE_DIR; ++#endif ++#ifdef GPLUSPLUS_LIBCXX_INCLUDE_DIR ++static char GPLUSPLUS_LIBCXX_INCLUDE_DIRVAR[4096] GCCRELOCPREFIX = GPLUSPLUS_LIBCXX_INCLUDE_DIR; ++#endif ++#ifdef NATIVE_SYSTEM_HEADER_DIR ++static char NATIVE_SYSTEM_HEADER_DIRVAR[4096] GCCRELOCPREFIX = NATIVE_SYSTEM_HEADER_DIR; ++#endif ++ + const struct default_include cpp_include_defaults[] + #ifdef INCLUDE_DEFAULTS + = INCLUDE_DEFAULTS; +@@ -42,27 +74,27 @@ const struct default_include cpp_include_defaults[] + = { + #ifdef GPLUSPLUS_INCLUDE_DIR + /* Pick up GNU C++ generic include files. */ +- { GPLUSPLUS_INCLUDE_DIR, "G++", 1, 1, ++ { GPLUSPLUS_INCLUDE_DIRVAR, "G++", 1, 1, + GPLUSPLUS_INCLUDE_DIR_ADD_SYSROOT, 0 }, + #endif + #ifdef GPLUSPLUS_TOOL_INCLUDE_DIR + /* Pick up GNU C++ target-dependent include files. */ +- { GPLUSPLUS_TOOL_INCLUDE_DIR, "G++", 1, 1, ++ { GPLUSPLUS_TOOL_INCLUDE_DIRVAR, "G++", 1, 1, + GPLUSPLUS_INCLUDE_DIR_ADD_SYSROOT, 1 }, + #endif + #ifdef GPLUSPLUS_BACKWARD_INCLUDE_DIR + /* Pick up GNU C++ backward and deprecated include files. */ +- { GPLUSPLUS_BACKWARD_INCLUDE_DIR, "G++", 1, 1, ++ { GPLUSPLUS_BACKWARD_INCLUDE_DIRVAR, "G++", 1, 1, + GPLUSPLUS_INCLUDE_DIR_ADD_SYSROOT, 0 }, + #endif + #ifdef GPLUSPLUS_LIBCXX_INCLUDE_DIR + /* Pick up libc++ include files, if we have -stdlib=libc++. */ +- { GPLUSPLUS_LIBCXX_INCLUDE_DIR, "G++", 2, 1, ++ { GPLUSPLUS_LIBCXX_INCLUDE_DIRVAR, "G++", 2, 1, + GPLUSPLUS_LIBCXX_INCLUDE_DIR_ADD_SYSROOT, 0 }, + #endif + #ifdef GCC_INCLUDE_DIR + /* This is the dir for gcc's private headers. */ +- { GCC_INCLUDE_DIR, "GCC", 0, 0, 0, 0 }, ++ { GCC_INCLUDE_DIRVAR, "GCC", 0, 0, 0, 0 }, + #endif + #ifdef GCC_INCLUDE_SUBDIR_TARGET + /* This is the dir for gcc's private headers under the specified sysroot. */ +@@ -70,15 +102,15 @@ const struct default_include cpp_include_defaults[] + #endif + #ifdef LOCAL_INCLUDE_DIR + /* /usr/local/include comes before the fixincluded header files. */ +- { LOCAL_INCLUDE_DIR, 0, 0, 1, 1, 2 }, +- { LOCAL_INCLUDE_DIR, 0, 0, 1, 1, 0 }, ++ { LOCAL_INCLUDE_DIRVAR, 0, 0, 1, 1, 2 }, ++ { LOCAL_INCLUDE_DIRVAR, 0, 0, 1, 1, 0 }, + #endif + #ifdef PREFIX_INCLUDE_DIR +- { PREFIX_INCLUDE_DIR, 0, 0, 1, 0, 0 }, ++ { PREFIX_INCLUDE_DIRVAR, 0, 0, 1, 0, 0 }, + #endif + #ifdef FIXED_INCLUDE_DIR + /* This is the dir for fixincludes. */ +- { FIXED_INCLUDE_DIR, "GCC", 0, 0, 0, ++ { FIXED_INCLUDE_DIRVAR, "GCC", 0, 0, 0, + /* A multilib suffix needs adding if different multilibs use + different headers. */ + #ifdef SYSROOT_HEADERS_SUFFIX_SPEC +@@ -90,33 +122,24 @@ const struct default_include cpp_include_defaults[] + #endif + #ifdef CROSS_INCLUDE_DIR + /* One place the target system's headers might be. */ +- { CROSS_INCLUDE_DIR, "GCC", 0, 0, 0, 0 }, ++ { CROSS_INCLUDE_DIRVAR, "GCC", 0, 0, 0, 0 }, + #endif + #ifdef TOOL_INCLUDE_DIR + /* Another place the target system's headers might be. */ +- { TOOL_INCLUDE_DIR, "BINUTILS", 0, 1, 0, 0 }, ++ { TOOL_INCLUDE_DIRVAR, "BINUTILS", 0, 1, 0, 0 }, + #endif + #ifdef NATIVE_SYSTEM_HEADER_DIR + /* /usr/include comes dead last. */ +- { NATIVE_SYSTEM_HEADER_DIR, NATIVE_SYSTEM_HEADER_COMPONENT, 0, 0, 1, 2 }, +- { NATIVE_SYSTEM_HEADER_DIR, NATIVE_SYSTEM_HEADER_COMPONENT, 0, 0, 1, 0 }, ++ { NATIVE_SYSTEM_HEADER_DIRVAR, NATIVE_SYSTEM_HEADER_COMPONENT, 0, 0, 1, 2 }, ++ { NATIVE_SYSTEM_HEADER_DIRVAR, NATIVE_SYSTEM_HEADER_COMPONENT, 0, 0, 1, 0 }, + #endif + { 0, 0, 0, 0, 0, 0 } + }; + #endif /* no INCLUDE_DEFAULTS */ + +-#ifdef GCC_INCLUDE_DIR +-const char cpp_GCC_INCLUDE_DIR[] = GCC_INCLUDE_DIR; +-const size_t cpp_GCC_INCLUDE_DIR_len = sizeof GCC_INCLUDE_DIR - 8; +-#else +-const char cpp_GCC_INCLUDE_DIR[] = ""; +-const size_t cpp_GCC_INCLUDE_DIR_len = 0; +-#endif +- + /* The configured prefix. */ +-const char cpp_PREFIX[] = PREFIX; +-const size_t cpp_PREFIX_len = sizeof PREFIX - 1; +-const char cpp_EXEC_PREFIX[] = STANDARD_EXEC_PREFIX; ++char PREFIXVAR[4096] GCCRELOCPREFIX = PREFIX; ++char EXEC_PREFIXVAR[4096] GCCRELOCPREFIX = STANDARD_EXEC_PREFIX; + + /* This value is set by cpp_relocated at runtime */ + const char *gcc_exec_prefix; +diff --git a/gcc/cppdefault.h b/gcc/cppdefault.h +index fd3c655db1c..fd730aaf9cf 100644 +--- a/gcc/cppdefault.h ++++ b/gcc/cppdefault.h +@@ -33,7 +33,8 @@ + + struct default_include + { +- const char *const fname; /* The name of the directory. */ ++ const char *fname; /* The name of the directory. */ ++ + const char *const component; /* The component containing the directory + (see update_path in prefix.c) */ + const char cplusplus; /* When this is non-zero, we should only +@@ -55,17 +56,18 @@ struct default_include + }; + + extern const struct default_include cpp_include_defaults[]; +-extern const char cpp_GCC_INCLUDE_DIR[]; +-extern const size_t cpp_GCC_INCLUDE_DIR_len; ++#ifdef __APPLE__ ++#define GCCRELOCPREFIX __attribute__ ((section (".gccrelocprefix,.gccrelocprefix"))) ++#else ++#define GCCRELOCPREFIX __attribute__ ((section (".gccrelocprefix"))) ++#endif ++extern char GCC_INCLUDE_DIRVAR[] GCCRELOCPREFIX; + + /* The configure-time prefix, i.e., the value supplied as the argument + to --prefix=. */ +-extern const char cpp_PREFIX[]; ++extern char PREFIXVAR[] GCCRELOCPREFIX; + /* The length of the configure-time prefix. */ +-extern const size_t cpp_PREFIX_len; +-/* The configure-time execution prefix. This is typically the lib/gcc +- subdirectory of cpp_PREFIX. */ +-extern const char cpp_EXEC_PREFIX[]; ++extern char EXEC_PREFIXVAR[] GCCRELOCPREFIX; + /* The run-time execution prefix. This is typically the lib/gcc + subdirectory of the actual installation. */ + extern const char *gcc_exec_prefix; +diff --git a/gcc/gcc.c b/gcc/gcc.c +index 584122486cb..c9800046566 100644 +--- a/gcc/gcc.c ++++ b/gcc/gcc.c +@@ -252,6 +252,13 @@ FILE *report_times_to_file = NULL; + #endif + static const char *target_system_root = DEFAULT_TARGET_SYSTEM_ROOT; + ++#ifdef __APPLE__ ++#define GCCRELOCPREFIX __attribute__ ((section (".gccrelocprefix,.gccrelocprefix"))) ++#else ++#define GCCRELOCPREFIX __attribute__ ((section (".gccrelocprefix"))) ++#endif ++static char target_relocatable_prefix[4096] GCCRELOCPREFIX = SYSTEMLIBS_DIR; ++ + /* Nonzero means pass the updated target_system_root to the compiler. */ + + static int target_system_root_changed; +@@ -568,6 +575,7 @@ or with constant text in a single argument. + %G process LIBGCC_SPEC as a spec. + %R Output the concatenation of target_system_root and + target_sysroot_suffix. ++ %r Output the base path target_relocatable_prefix + %S process STARTFILE_SPEC as a spec. A capital S is actually used here. + %E process ENDFILE_SPEC as a spec. A capital E is actually used here. + %C process CPP_SPEC as a spec. +@@ -1620,10 +1628,10 @@ static const char *gcc_libexec_prefix; + gcc_exec_prefix is set because, in that case, we know where the + compiler has been installed, and use paths relative to that + location instead. */ +-static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX; +-static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX; +-static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX; +-static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX; ++static char standard_exec_prefix[4096] GCCRELOCPREFIX = STANDARD_EXEC_PREFIX; ++static char standard_libexec_prefix[4096] GCCRELOCPREFIX = STANDARD_LIBEXEC_PREFIX; ++static char standard_bindir_prefix[4096] GCCRELOCPREFIX = STANDARD_BINDIR_PREFIX; ++static char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX; + + /* For native compilers, these are well-known paths containing + components that may be provided by the system. For cross +@@ -1631,9 +1639,9 @@ static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX; + static const char *md_exec_prefix = MD_EXEC_PREFIX; + static const char *md_startfile_prefix = MD_STARTFILE_PREFIX; + static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1; +-static const char *const standard_startfile_prefix_1 ++static char standard_startfile_prefix_1[4096] GCCRELOCPREFIX + = STANDARD_STARTFILE_PREFIX_1; +-static const char *const standard_startfile_prefix_2 ++static char standard_startfile_prefix_2[4096] GCCRELOCPREFIX + = STANDARD_STARTFILE_PREFIX_2; + + /* A relative path to be used in finding the location of tools +@@ -6564,6 +6572,11 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part) + } + break; + ++ case 'r': ++ obstack_grow (&obstack, target_relocatable_prefix, ++ strlen (target_relocatable_prefix)); ++ break; ++ + case 'S': + value = do_spec_1 (startfile_spec, 0, NULL); + if (value != 0) +diff --git a/gcc/incpath.c b/gcc/incpath.c +index fbfc0ce03b8..a82e543428b 100644 +--- a/gcc/incpath.c ++++ b/gcc/incpath.c +@@ -131,7 +131,7 @@ add_standard_paths (const char *sysroot, const char *iprefix, + int relocated = cpp_relocated (); + size_t len; + +- if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0) ++ if (iprefix && (len = strlen(GCC_INCLUDE_DIRVAR) - 7) != 0) + { + /* Look for directories that start with the standard prefix. + "Translate" them, i.e. replace /usr/local/lib/gcc... with +@@ -146,7 +146,7 @@ add_standard_paths (const char *sysroot, const char *iprefix, + now. */ + if (sysroot && p->add_sysroot) + continue; +- if (!filename_ncmp (p->fname, cpp_GCC_INCLUDE_DIR, len)) ++ if (!filename_ncmp (p->fname, GCC_INCLUDE_DIRVAR, len)) + { + char *str = concat (iprefix, p->fname + len, NULL); + if (p->multilib == 1 && imultilib) +@@ -187,7 +187,7 @@ add_standard_paths (const char *sysroot, const char *iprefix, + free (sysroot_no_trailing_dir_separator); + } + else if (!p->add_sysroot && relocated +- && !filename_ncmp (p->fname, cpp_PREFIX, cpp_PREFIX_len)) ++ && !filename_ncmp (p->fname, PREFIXVAR, strlen(PREFIXVAR))) + { + static const char *relocated_prefix; + char *ostr; +@@ -204,12 +204,12 @@ add_standard_paths (const char *sysroot, const char *iprefix, + dummy = concat (gcc_exec_prefix, "dummy", NULL); + relocated_prefix + = make_relative_prefix (dummy, +- cpp_EXEC_PREFIX, +- cpp_PREFIX); ++ EXEC_PREFIXVAR, ++ PREFIXVAR); + free (dummy); + } + ostr = concat (relocated_prefix, +- p->fname + cpp_PREFIX_len, ++ p->fname + strlen(PREFIXVAR), + NULL); + str = update_path (ostr, p->component); + free (ostr); +diff --git a/gcc/prefix.c b/gcc/prefix.c +index 747c09de638..da598c43a52 100644 +--- a/gcc/prefix.c ++++ b/gcc/prefix.c +@@ -72,7 +72,14 @@ License along with GCC; see the file COPYING3. If not see + #include "prefix.h" + #include "common/common-target.h" + +-static const char *std_prefix = PREFIX; ++#ifdef __APPLE__ ++#define GCCRELOCPREFIX __attribute__ ((section (".gccrelocprefix,.gccrelocprefix"))) ++#else ++#define GCCRELOCPREFIX __attribute__ ((section (".gccrelocprefix"))) ++#endif ++static const char PREFIXVAR[4096] GCCRELOCPREFIX = PREFIX; ++ ++static const char *std_prefix = PREFIXVAR; + + static const char *get_key_value (char *); + static char *translate_name (char *); +@@ -212,7 +219,7 @@ translate_name (char *name) + prefix = getenv (key); + + if (prefix == 0) +- prefix = PREFIX; ++ prefix = PREFIXVAR; + + /* We used to strip trailing DIR_SEPARATORs here, but that can + sometimes yield a result with no separator when one was coded diff --git a/recipes-devtools/gcc/files/0020-Add-ssp_nonshared-to-link-commandline-for-musl-targe.patch b/recipes-devtools/gcc/files/0020-Add-ssp_nonshared-to-link-commandline-for-musl-targe.patch new file mode 100644 index 0000000..0307e32 --- /dev/null +++ b/recipes-devtools/gcc/files/0020-Add-ssp_nonshared-to-link-commandline-for-musl-targe.patch @@ -0,0 +1,78 @@ +From 745a2ac7825c73102b888226c54397d21512f86b Mon Sep 17 00:00:00 2001 +From: Khem Raj <raj.khem@gmail.com> +Date: Tue, 27 Jun 2017 18:10:54 -0700 +Subject: [PATCH] Add ssp_nonshared to link commandline for musl targets + +when -fstack-protector options are enabled we need to +link with ssp_shared on musl since it does not provide +the __stack_chk_fail_local() so essentially it provides +libssp but not libssp_nonshared something like +TARGET_LIBC_PROVIDES_SSP_BUT_NOT_SSP_NONSHARED + where-as for glibc the needed symbols +are already present in libc_nonshared library therefore +we do not need any library helper on glibc based systems +but musl needs the libssp_noshared from gcc + +Upstream-Status: Pending + +Signed-off-by: Khem Raj <raj.khem@gmail.com> +--- + gcc/config/linux.h | 7 +++++++ + gcc/config/rs6000/linux.h | 10 ++++++++++ + gcc/config/rs6000/linux64.h | 10 ++++++++++ + 3 files changed, 27 insertions(+) + +--- a/gcc/config/linux.h ++++ b/gcc/config/linux.h +@@ -203,6 +203,13 @@ see the files COPYING3 and COPYING.RUNTI + { GCC_INCLUDE_DIR, "GCC", 0, 1, 0, 0 }, \ + { 0, 0, 0, 0, 0, 0 } \ + } ++#ifdef TARGET_LIBC_PROVIDES_SSP ++#undef LINK_SSP_SPEC ++#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \ ++ "|fstack-protector-strong|fstack-protector-explicit" \ ++ ":-lssp_nonshared}" ++#endif ++ + #endif + + #if (DEFAULT_LIBC == LIBC_UCLIBC) && defined (SINGLE_LIBC) /* uClinux */ +--- a/gcc/config/rs6000/linux.h ++++ b/gcc/config/rs6000/linux.h +@@ -94,6 +94,16 @@ + " -m elf32ppclinux") + #endif + ++/* link libssp_nonshared.a with musl */ ++#if DEFAULT_LIBC == LIBC_MUSL ++#ifdef TARGET_LIBC_PROVIDES_SSP ++#undef LINK_SSP_SPEC ++#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \ ++ "|fstack-protector-strong|fstack-protector-explicit" \ ++ ":-lssp_nonshared}" ++#endif ++#endif ++ + #undef LINK_OS_LINUX_SPEC + #define LINK_OS_LINUX_SPEC LINK_OS_LINUX_EMUL " %{!shared: %{!static: \ + %{!static-pie: \ +--- a/gcc/config/rs6000/linux64.h ++++ b/gcc/config/rs6000/linux64.h +@@ -369,6 +369,16 @@ extern int dot_symbols; + " -m elf64ppc") + #endif + ++/* link libssp_nonshared.a with musl */ ++#if DEFAULT_LIBC == LIBC_MUSL ++#ifdef TARGET_LIBC_PROVIDES_SSP ++#undef LINK_SSP_SPEC ++#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \ ++ "|fstack-protector-strong|fstack-protector-explicit" \ ++ ":-lssp_nonshared}" ++#endif ++#endif ++ + #define LINK_OS_LINUX_SPEC32 LINK_OS_LINUX_EMUL32 " %{!shared: %{!static: \ + %{!static-pie: \ + %{rdynamic:-export-dynamic} \ diff --git a/recipes-devtools/gcc/files/0099-nativesdk-gcc-darwin.patch b/recipes-devtools/gcc/files/0099-nativesdk-gcc-darwin.patch new file mode 100644 index 0000000..77419c0 --- /dev/null +++ b/recipes-devtools/gcc/files/0099-nativesdk-gcc-darwin.patch @@ -0,0 +1,54 @@ +From 06f75c32bc364d607f103622deb59e1a4ebd9caf Mon Sep 17 00:00:00 2001 +From: Etienne Cordonnier <ecordonnier@snap.com> +Date: Wed, 3 Aug 2022 13:37:20 +0200 +Subject: [PATCH] rebase patch "0099-nativesdk-gcc-darwin.patch" from + meta-darwin + +Upstream-Status: Inappropriate [OE specific] +Signed-off-by: Etienne Cordonnier <ecordonnier@snap.com> +--- + gcc/config/darwin-c.c | 4 ++-- + gcc/config/darwin.h | 5 +---- + 2 files changed, 3 insertions(+), 6 deletions(-) + +diff --git a/gcc/config/darwin-c.c b/gcc/config/darwin-c.c +index 8b3dec25476..a3c71f109a8 100644 +--- a/gcc/config/darwin-c.c ++++ b/gcc/config/darwin-c.c +@@ -479,8 +479,8 @@ darwin_register_objc_includes (const char *sysroot ATTRIBUTE_UNUSED, + /* See if our directory starts with the standard prefix. + "Translate" them, i.e. replace /usr/local/lib/gcc... with + IPREFIX and search them first. */ +- if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0 +- && !strncmp (fname, cpp_GCC_INCLUDE_DIR, len)) ++ if (iprefix && (len = strlen(GCC_INCLUDE_DIRVAR) - 7) != 0 ++ && !strncmp (fname, GCC_INCLUDE_DIRVAR, len)) + { + str = concat (iprefix, fname + len, NULL); + add_path (str, INC_SYSTEM, /*c++aware=*/true, false); +diff --git a/gcc/config/darwin.h b/gcc/config/darwin.h +index 3206b70c7c2..59c25c88035 100644 +--- a/gcc/config/darwin.h ++++ b/gcc/config/darwin.h +@@ -384,6 +384,7 @@ extern GTY(()) int darwin_ms_struct; + %:version-compare(>= 10.11 asm_macosx_version_min= ___emutls_register_common) \ + }} \ + }}}\ ++ %{!nostdlib++:}\ + %{!r:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} %{F*} "\ + DARWIN_PIE_SPEC \ + DARWIN_NOPIE_SPEC \ +@@ -427,10 +428,6 @@ extern GTY(()) int darwin_ms_struct; + isysroot is specified. */ + #define LINK_SYSROOT_SPEC "%{isysroot*:-syslibroot %*} " + +-/* Suppress the addition of extra prefix paths when a sysroot is in use. */ +-#define STANDARD_STARTFILE_PREFIX_1 "" +-#define STANDARD_STARTFILE_PREFIX_2 "" +- + + /* Please keep the random linker options in alphabetical order. + Note that options taking arguments may appear multiple times on a command +-- +2.36.1.vfs.0.0 + diff --git a/recipes-devtools/gcc/files/0100-change-macosx-version-min-to-12.3.patch b/recipes-devtools/gcc/files/0100-change-macosx-version-min-to-12.3.patch new file mode 100644 index 0000000..d1f22b9 --- /dev/null +++ b/recipes-devtools/gcc/files/0100-change-macosx-version-min-to-12.3.patch @@ -0,0 +1,27 @@ +From 8f7f5820b24f57460e26440e770c8407ec11e10d Mon Sep 17 00:00:00 2001 +From: Etienne Cordonnier <ecordonnier@snap.com> +Date: Thu, 11 Aug 2022 15:39:44 +0200 +Subject: [PATCH] change macosx-version-min to 12.3 + +Upstream-Status: Inappropriate [OE specific] +Signed-off-by: Etienne Cordonnier <ecordonnier@snap.com> +--- + libgcc/config/t-darwin | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/libgcc/config/t-darwin b/libgcc/config/t-darwin +index a3bb70c6a0a..8923a375c68 100644 +--- a/libgcc/config/t-darwin ++++ b/libgcc/config/t-darwin +@@ -1,5 +1,8 @@ + # Set this as a minimum (unless overriden by arch t-files) since it's a + # reasonable lowest common denominator that works for all our archs. ++DARWIN_MIN_CRT_VERSION="-mmacosx-version-min=12.3" ++DARWIN_MIN_LIB_VERSION="-mmacosx-version-min=12.3" ++ + HOST_LIBGCC2_CFLAGS += $(DARWIN_MIN_LIB_VERSION) + + crt3.o: $(srcdir)/config/darwin-crt3.c +-- +2.36.1.vfs.0.0 + diff --git a/recipes-devtools/gcc/files/0101-optional-libstdc.patch b/recipes-devtools/gcc/files/0101-optional-libstdc.patch new file mode 100644 index 0000000..1c62c96 --- /dev/null +++ b/recipes-devtools/gcc/files/0101-optional-libstdc.patch @@ -0,0 +1,118 @@ +From: Richard Purdie <richard.purdie@linuxfoundation.org> +Subject: [PATCH 3/5] gcc: Add --nostdlib++ option + +[gcc-runtime builds libstdc++ separately from gcc-cross-*. Its configure tests using g++ +will not run correctly since by default the linker will try to link against libstdc++ +which shouldn't exist yet. We need an option to disable -lstdc++ +option whilst leaving -lc, -lgcc and other automatic library dependencies added by gcc +driver. This patch adds such an option which only disables the -lstdc++.] + +[A "standard" gcc build uses xgcc and hence avoids this. We should ask upstream how to +do this officially, the likely answer is don't build libstdc++ separately.] + +OpenEmbedded/Yocto Project builds libgcc and the other gcc runtime libraries +separately from the compiler and slightly differently to the standard gcc build. + +In general this works well but in trying to build them separately we run into +an issue since we're using our gcc, not xgcc and there is no way to tell configure +to use libgcc but not look for libstdc++. + +This adds such an option allowing such configurations to work. + +2021-10-26 Richard Purdie <richard.purdie@linuxfoundation.org> + +gcc/c-family/ChangeLog: + + * c.opt: Add --nostdlib++ option + +gcc/cp/ChangeLog: + + * g++spec.c (lang_specific_driver): Add --nostdlib++ option + +gcc/ChangeLog: + + * doc/invoke.texi: Document --nostdlib++ option + * gcc.c: Add --nostdlib++ option + +Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org> + +Upstream-Status: Submitted [https://gcc.gnu.org/pipermail/gcc-patches/2021-October/582724.html] +--- + gcc/c-family/c.opt | 4 ++++ + gcc/cp/g++spec.c | 1 + + gcc/doc/invoke.texi | 8 +++++++- + gcc/gcc.c | 1 + + 4 files changed, 13 insertions(+), 1 deletion(-) + +Index: gcc-11.3.0/gcc/c-family/c.opt +=================================================================== +--- gcc-11.3.0.orig/gcc/c-family/c.opt ++++ gcc-11.3.0/gcc/c-family/c.opt +@@ -2153,6 +2153,10 @@ nostdinc++ + C++ ObjC++ + Do not search standard system include directories for C++. + ++nostdlib++ ++Driver ++Do not link standard C++ runtime library ++ + o + C ObjC C++ ObjC++ Joined Separate + ; Documented in common.opt +Index: gcc-11.3.0/gcc/cp/g++spec.c +=================================================================== +--- gcc-11.3.0.orig/gcc/cp/g++spec.c ++++ gcc-11.3.0/gcc/cp/g++spec.c +@@ -159,6 +159,7 @@ lang_specific_driver (struct cl_decoded_ + switch (decoded_options[i].opt_index) + { + case OPT_nostdlib: ++ case OPT_nostdlib__: + case OPT_nodefaultlibs: + library = -1; + break; +Index: gcc-11.3.0/gcc/doc/invoke.texi +=================================================================== +--- gcc-11.3.0.orig/gcc/doc/invoke.texi ++++ gcc-11.3.0/gcc/doc/invoke.texi +@@ -239,6 +239,7 @@ in the following sections. + -fno-weak -nostdinc++ @gol + -fvisibility-inlines-hidden @gol + -fvisibility-ms-compat @gol ++-nostdlib++ @gol + -fext-numeric-literals @gol + -flang-info-include-translate@r{[}=@var{header}@r{]} @gol + -flang-info-include-translate-not @gol +@@ -632,7 +633,7 @@ Objective-C and Objective-C++ Dialects}. + -pie -pthread -r -rdynamic @gol + -s -static -static-pie -static-libgcc -static-libstdc++ @gol + -static-libasan -static-libtsan -static-liblsan -static-libubsan @gol +--shared -shared-libgcc -symbolic @gol ++-shared -shared-libgcc -symbolic -nostdlib++ @gol + -T @var{script} -Wl,@var{option} -Xlinker @var{option} @gol + -u @var{symbol} -z @var{keyword}} + +@@ -15721,6 +15722,11 @@ Specify that the program entry point is + interpreted by the linker; the GNU linker accepts either a symbol name + or an address. + ++@item -nostdlib++ ++@opindex nostdlib++ ++Do not use the standard system C++ runtime libraries when linking. ++Only the libraries you specify will be passed to the linker. ++ + @item -pie + @opindex pie + Produce a dynamically linked position independent executable on targets +Index: gcc-11.3.0/gcc/gcc.c +=================================================================== +--- gcc-11.3.0.orig/gcc/gcc.c ++++ gcc-11.3.0/gcc/gcc.c +@@ -1162,6 +1162,7 @@ proper position among the other output f + %(mflib) " STACK_SPLIT_SPEC "\ + %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \ + %{!nostdlib:%{!r:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}}\ ++ %{!nostdlib++:}\ + %{!nostdlib:%{!r:%{!nostartfiles:%E}}} %{T*} \n%(post_link) }}}}}}" + #endif + diff --git a/recipes-devtools/gcc/gcc-cross-canadian_%.bbappend b/recipes-devtools/gcc/gcc-cross-canadian_%.bbappend new file mode 100644 index 0000000..192ee0d --- /dev/null +++ b/recipes-devtools/gcc/gcc-cross-canadian_%.bbappend @@ -0,0 +1,14 @@ +LTO:darwinsdk = "--disable-lto" +ELFUTILS:darwinsdk = "" + +EXTRA_OECONF:append:darwinsdk = " \ + --with-gmp=${STAGING_EXECPREFIXDIR} \ + --with-mpft=${STAGING_EXECPREFIXDIR} \ + --with-mpc=${STAGING_EXECPREFIXDIR} \ +" + +EXTRA_OECONF:remove:darwinsdk = "--enable-clocale=gnu" +EXTRA_OECONF:remove:darwinsdk = "--enable-clocale=generic" + +# Remove -rpath-link and -rpath +LDFLAGS:darwinsdk = "${BUILDSDK_LDFLAGS}" diff --git a/recipes-devtools/gcc/gcc-cross-canadian_4.9.bbappend b/recipes-devtools/gcc/gcc-cross-canadian_4.9.bbappend deleted file mode 100644 index ddcc3fc..0000000 --- a/recipes-devtools/gcc/gcc-cross-canadian_4.9.bbappend +++ /dev/null @@ -1,14 +0,0 @@ -INSANE_SKIP_${PN}_append_darwinsdk = " staticdev" -EXTRA_OECONF_append_darwinsdk = " --disable-nls" -ELFUTILS_darwinsdk = "" - -#Remove -rpath-link and -rpath -LDFLAGS_darwinsdk = "${BUILDSDK_LDFLAGS} -L${libdir}/.." - -# Change gxx-include-dir -EXTRA_OECONF_PATHS_darwinsdk = "--with-gxx-include-dir=${SDKPATH}/sysroots/${TUNE_PKGARCH}${TARGET_VENDOR}-${TARGET_OS}/usr/include/c++ \ - --with-build-time-tools=${STAGING_DIR_NATIVE}${prefix_native}/${TARGET_SYS}/bin \ - --with-sysroot=${SDKPATH}/sysroots/${TUNE_PKGARCH}${TARGET_VENDOR}-${TARGET_OS} \ - --with-build-sysroot=${STAGING_DIR_TARGET}" - -RDEPENDS_${PN}_append_darwinsdk = " nativesdk-gettext nativesdk-gmp" diff --git a/recipes-devtools/gcc/gcc-crosssdk-initial_4.9.bbappend b/recipes-devtools/gcc/gcc-crosssdk-initial_4.9.bbappend deleted file mode 100644 index cdbac0d..0000000 --- a/recipes-devtools/gcc/gcc-crosssdk-initial_4.9.bbappend +++ /dev/null @@ -1,19 +0,0 @@ - -LTO_darwin = "--disable-lto" - -do_install_append_darwin () { - ln -s ${STAGING_DIR_TARGET}/${target_exec_prefix}/ ${D}/${exec_prefix}/${TARGET_SYS} -} - -sysroot_stage_all_append_darwin () { - sysroot_stage_dir ${D}${exec_prefix}/${TARGET_SYS} ${SYSROOT_DESTDIR}${exec_prefix}/${TARGET_SYS} -} - - -do_compile_append_darwin () { - oe_runmake all-target-libgcc -} -do_install_append_darwin () { - oe_runmake 'DESTDIR=${D}' install-target-libgcc -} - diff --git a/recipes-devtools/gcc/gcc-crosssdk_%.bbappend b/recipes-devtools/gcc/gcc-crosssdk_%.bbappend new file mode 100644 index 0000000..361e6bd --- /dev/null +++ b/recipes-devtools/gcc/gcc-crosssdk_%.bbappend @@ -0,0 +1,23 @@ +SYSTEMHEADERS:darwin21 = "${SDKPATHNATIVE}/runtime/usr/include/" + +LINKER_HASH_STYLE:darwin21 = "" + +EXTRA_OECONF:remove:darwin21 = "--enable-clocale=gnu" +EXTRA_OECONF:remove:darwin21 = "--enable-clocale=generic" + +EXTRA_OECONF:remove:darwin21 = "--enable-initfini-array" +EXTRA_OECONF:append:darwin21 = " --disable-initfini-array" + +LTO:darwin21 = "--disable-lto" +EXTRA_OECONF:remove:darwin21 = "--enable-lto" +EXTRA_OECONF:append:darwin21 = " --disable-lto" + +DEPENDS:append:darwin21 = " nativesdk-osx-runtime" + +do_configure:prepend:darwin21 () { + export ARCH_FLAGS_FOR_TARGET=" $ARCH_FLAGS_FOR_TARGET \ + -L${SDKPATHNATIVE}/usr/lib \ + -L${SDKPATHNATIVE}/runtime/usr/lib \ + -L${SDKPATHNATIVE}/runtime/usr/lib/system \ + " +} diff --git a/recipes-devtools/gcc/gcc-crosssdk_4.9.bbappend b/recipes-devtools/gcc/gcc-crosssdk_4.9.bbappend deleted file mode 100644 index 3808232..0000000 --- a/recipes-devtools/gcc/gcc-crosssdk_4.9.bbappend +++ /dev/null @@ -1,18 +0,0 @@ -LTO_darwin = "--disable-lto" -SYSTEMHEADERS_darwin = "/usr/include/" - -LANGUAGES_append_darwin = ",objc" - -EXTRA_OECONF_darwin := "${@oe_filter_out('--with-linker-hash-style=${LINKER_HASH_STYLE}', '${EXTRA_OECONF}', d)}" -EXTRA_OECONF_darwin := "${@oe_filter_out('--with-gnu-ld', '${EXTRA_OECONF}', d)}" -EXTRA_OECONF_darwin := "${@oe_filter_out('--enable-libssp', '${EXTRA_OECONF}', d)}" -EXTRA_OECONF_darwin := "${@oe_filter_out('--with-gxx-include-dir=${STAGING_DIR_TARGET}${target_includedir}/c\+\+', '${EXTRA_OECONF}', d)}" -EXTRA_OECONF_append_darwin = " --disable-libssp" -EXTRA_OECONF_append_darwin = " --with-gxx-include-dir=${STAGING_DIR_TARGET}/usr/include/c++/4.2.1" - -do_compile_append_darwin () { - oe_runmake all-target-libgcc -} -do_install_append_darwin () { - oe_runmake 'DESTDIR=${D}' install-target-libgcc -} diff --git a/recipes-devtools/gcc/gcc-runtime_%.bbappend b/recipes-devtools/gcc/gcc-runtime_%.bbappend new file mode 100644 index 0000000..90e4ff0 --- /dev/null +++ b/recipes-devtools/gcc/gcc-runtime_%.bbappend @@ -0,0 +1,47 @@ +EXTRA_OECONF:remove:darwin21 = "--enable-clocale=gnu" +EXTRA_OECONF:remove:darwin21 = "--enable-clocale=generic" + +RUNTIMETARGET:remove:darwin21 = "libmpx" + +FILES:libssp:append:darwin21 = " ${libdir}/libssp*.dylib" +FILES:libstdc++:append:darwin21 = " ${libdir}/libstdc++*.dylib" +FILES:libitm:append:darwin21 = " ${libdir}/libitm*.dylib" +FILES:libatomic:append:darwin21 = " ${libdir}/libatomic*.dylib" +FILES:libgomp:append:darwin21 = " ${libdir}/libgomp*.dylib" +FILES:${PN}-dbg:append:darwin21 = " ${libdir}/libstdc++.a-gdb.py" + +# Replace do_configure and do_check from poky. We can't link libstdc++.dylib to +# a dummy libstdc++.so, because this adds a dependency to the generated libstdc++.dylib. +# This basically reverts 2d940dd5bf68aec from poky. +do_configure () { + export CXX="${CXX} -nostdinc++ -nostdlib++" + for d in libgcc ${RUNTIMETARGET}; do + echo "Configuring $d" + rm -rf ${B}/${TARGET_SYS}/$d/ + mkdir -p ${B}/${TARGET_SYS}/$d/ + cd ${B}/${TARGET_SYS}/$d/ + chmod a+x ${S}/$d/configure + relpath=${@os.path.relpath("${S}/$d", "${B}/${TARGET_SYS}/$d")} + $relpath/configure ${CONFIGUREOPTS} ${EXTRA_OECONF} + if [ "$d" = "libgcc" ]; then + (cd ${B}/${TARGET_SYS}/libgcc; oe_runmake enable-execute-stack.c unwind.h md-unwind-support.h sfp-machine.h gthr-default.h) + fi + done +} + +do_check() { + export DEJAGNU="${WORKDIR}/dejagnu/site.exp" + + # HACK: this works around the configure setting CXX with -nostd* args + sed -i 's/-nostdinc++ -nostdlib++//g' $(find ${B} -name testsuite_flags | head -1) + + if [ "${TOOLCHAIN_TEST_TARGET}" = "user" ]; then + # qemu user has issues allocating large amounts of memory + export G_SLICE=always-malloc + # no test should need more that 10G of memory, this prevents tests like pthread7-rope from leaking memory + ulimit -m 4194304 + ulimit -v 10485760 + fi + + oe_runmake -i ${MAKE_CHECK_TARGETS} RUNTESTFLAGS="${MAKE_CHECK_RUNTESTFLAGS}" +} diff --git a/recipes-devtools/gcc/gcc-runtime_4.9.bbappend b/recipes-devtools/gcc/gcc-runtime_4.9.bbappend deleted file mode 100644 index 5ce492c..0000000 --- a/recipes-devtools/gcc/gcc-runtime_4.9.bbappend +++ /dev/null @@ -1,13 +0,0 @@ -do_configure_prepend+darwin () { - export lt_cv_ld_exported_symbols_list = "yes" - export ac_cv_lib_dl_dlopen = "yes" -} - -do_compile_prepend+darwin () { - export lt_cv_ld_exported_symbols_list = "yes" - export ac_cv_lib_dl_dlopen = "yes" -} - -RUNTIMETARGET_darwin = "libssp" - -FILES_libssp_append_darwin = " ${libdir}/libssp*.dylib"
\ No newline at end of file diff --git a/recipes-devtools/gcc/gcc-source_%.bbappend b/recipes-devtools/gcc/gcc-source_%.bbappend new file mode 100644 index 0000000..110462d --- /dev/null +++ b/recipes-devtools/gcc/gcc-source_%.bbappend @@ -0,0 +1,7 @@ +FILESEXTRAPATHS:prepend := "${THISDIR}/files:" + +SRC_URI:append = "\ + file://0099-nativesdk-gcc-darwin.patch \ + file://0100-change-macosx-version-min-to-12.3.patch \ + file://0101-optional-libstdc.patch \ +" diff --git a/recipes-devtools/gcc/libgcc_%.bbappend b/recipes-devtools/gcc/libgcc_%.bbappend new file mode 100644 index 0000000..2b824fb --- /dev/null +++ b/recipes-devtools/gcc/libgcc_%.bbappend @@ -0,0 +1,18 @@ +SYSTEMHEADERS:darwin21 = "${SDKPATHNATIVE}/runtime/usr/include/" + +do_compile:darwin21() { + oe_runmake all-target-libgcc MULTIBUILDTOP=${B}/${TARGET_SYS}/${BPN} +} + +# See file gcc/config/darwin.h in the gcc repository to understand which library is being linked against, +# depending on the minimum version of os-x targetted (parameter "mmacosx-version-min"). +do_install:darwin21 () { + install -d ${D}${libdir} + cp ${B}/${TARGET_SYS}/${BPN}/libgcc_s.1.1.dylib ${D}${libdir} + cp ${B}/${TARGET_SYS}/${BPN}/libemutls_w.a ${D}${libdir} + ln -s libgcc_s.1.1.dylib ${D}${libdir}/libgcc.dylib + ln -s libgcc_s.1.1.dylib ${D}${libdir}/libgcc_s.dylib + ${TARGET_SYS}-install_name_tool -id ${libdir}/libgcc_s.1.1.dylib ${D}/${libdir}/libgcc_s.1.1.dylib +} + +FILES:${PN}:append:darwin21 = " ${libdir}" diff --git a/recipes-devtools/gcc/libgcc_4.9.bbappend b/recipes-devtools/gcc/libgcc_4.9.bbappend deleted file mode 100644 index 790ade7..0000000 --- a/recipes-devtools/gcc/libgcc_4.9.bbappend +++ /dev/null @@ -1,7 +0,0 @@ -do_install_append_darwin () { - install -d ${D}${libdir} - cp ${B}/${TARGET_SYS}/${BPN}/*.dylib ${D}${libdir} - rmdir ${D}${base_libdir} -} - -FILES_${PN}_append_darwin = " ${libdir}/libgcc*.dylib" diff --git a/recipes-devtools/libtapi/libtapi-native_git.bb b/recipes-devtools/libtapi/libtapi-native_git.bb new file mode 100644 index 0000000..3c09387 --- /dev/null +++ b/recipes-devtools/libtapi/libtapi-native_git.bb @@ -0,0 +1,49 @@ +# Copyright (C) 2020 Dominik Schnitzer <dominik@snap.com> +# Released under the MIT license (see COPYING.MIT for the terms) + +TAPI_REPOSITORY="1100.0.11" +TAPI_VERSION="11.0.0" + +SUMMARY = "Apple libtapi for tdb support" +HOMEPAGE = "https://github.com/tpoechtrager/apple-libtapi" +LICENSE = "NCSA" +LIC_FILES_CHKSUM = "file://${WORKDIR}/git/LICENSE.APPLE-LIBTAPI.txt;md5=ecd05d65aa93d096452d196dcd233f1e" + +SECTION = "devel" + +SRCREV = "b7b5bdbfda9e8062d405b48da3b811afad98ae76" +SRC_URI = "git://github.com/tpoechtrager/apple-libtapi.git;nobranch=1;protocol=https" + +PACKAGES = "${PN}-dbg ${PN} ${PN}-dev" + +OECMAKE_GENERATOR = "Unix Makefiles" + +inherit cmake native + +S = "${WORKDIR}/git/src/llvm" +B = "${WORKDIR}/build" + +DEPENDS += "clang-native libcxx-native" + +TOOLCHAIN:class-native = "clang" +COMPILER_RT:class-native = "-rtlib=libgcc --unwindlib=libgcc" +LIBCPLUSPLUS:class-native = "-stdlib=libc++ -lc++abi" + +CXXFLAGS:append = " -I${WORKDIR}/git/src/llvm/projects/clang/include -I${B}/projects/clang/include" + +EXTRA_OECMAKE:append = " \ + -DLLVM_INCLUDE_TESTS=OFF \ + -DTAPI_REPOSITORY_STRING=${TAPI_REPOSITORY} \ + -DTAPI_FULL_VERSION=${TAPI_VERSION} \ + -DCMAKE_POSITION_INDEPENDENT_CODE=ON \ +" + +do_compile() { + cd ${B} + make -j clangBasic + make -j libtapi +} + +do_install() { + DESTDIR='${D}' make install-libtapi install-tapi-headers +} diff --git a/recipes-devtools/ninja/ninja_%.bbappend b/recipes-devtools/ninja/ninja_%.bbappend new file mode 100644 index 0000000..ae692cd --- /dev/null +++ b/recipes-devtools/ninja/ninja_%.bbappend @@ -0,0 +1,4 @@ +do_compile:darwin21() { + python3 ./configure.py --platform darwin + ninja +} diff --git a/recipes-devtools/odcctools/files/apple-x86-odcctools_758.159-0flosoft11.tar.gz b/recipes-devtools/odcctools/files/apple-x86-odcctools_758.159-0flosoft11.tar.gz Binary files differdeleted file mode 100644 index 9c66677..0000000 --- a/recipes-devtools/odcctools/files/apple-x86-odcctools_758.159-0flosoft11.tar.gz +++ /dev/null diff --git a/recipes-devtools/odcctools/files/arch_c.patch b/recipes-devtools/odcctools/files/arch_c.patch deleted file mode 100755 index 1b52895..0000000 --- a/recipes-devtools/odcctools/files/arch_c.patch +++ /dev/null @@ -1,15 +0,0 @@ ---- apple-x86-odcctools-758.159/libmacho/arch.c 2011-04-07 11:41:05.275621999 +0200 -+++ apple-x86-odcctools-758.159/libmacho/arch.c 2011-04-07 11:41:13.855701000 +0200 -@@ -230,7 +230,11 @@ - (cpusubtype == CPU_SUBTYPE_MULTIPLE || - ((ai->cpusubtype & ~CPU_SUBTYPE_MASK) == - (cpusubtype & ~CPU_SUBTYPE_MASK)))) -- return(ai); -+ { -+ q = malloc(sizeof(NXArchInfo)); -+ *q = *ai; -+ return((const NXArchInfo *)q); -+ } - - if(cputype == CPU_TYPE_I386){ - q = malloc(sizeof(NXArchInfo)); diff --git a/recipes-devtools/odcctools/files/as.patch b/recipes-devtools/odcctools/files/as.patch deleted file mode 100755 index f79a1d6..0000000 --- a/recipes-devtools/odcctools/files/as.patch +++ /dev/null @@ -1,18 +0,0 @@ ---- apple-x86-odcctools-758.159/as/input-scrub.c 2010-02-24 11:17:32.000000000 +0100 -+++ apple-x86-odcctools-758.159-patched/as/input-scrub.c 2010-02-24 11:40:04.000000000 +0100 -@@ -335,6 +335,7 @@ - char **directory, - int *line) - { -+#if OLD_PROJECTBUILDER_INTERFACE - char *p, *q; - static char directory_buf[MAXPATHLEN]; - -@@ -357,6 +358,7 @@ - *fileName = p + 1; - strncat(directory_buf, p, q - p); - } -+#endif - } - - /* diff --git a/recipes-devtools/odcctools/files/cctools-287-1.patch b/recipes-devtools/odcctools/files/cctools-287-1.patch deleted file mode 100644 index 6ababd5..0000000 --- a/recipes-devtools/odcctools/files/cctools-287-1.patch +++ /dev/null @@ -1,3208 +0,0 @@ -Index: odcctools-9.2-ld/libmacho/arch.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/arch.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/arch.c 2013-09-03 13:41:28.785830066 +0000 -@@ -73,6 +73,8 @@ - "PowerPC 64-bit"}, - {"sparc", CPU_TYPE_SPARC, CPU_SUBTYPE_SPARC_ALL, NX_BigEndian, - "SPARC"}, -+ {"arm", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_ALL, NX_LittleEndian, -+ "ARM"}, - {"any", CPU_TYPE_ANY, CPU_SUBTYPE_MULTIPLE, NX_UnknownByteOrder, - "Architecture Independent"}, - {"veo", CPU_TYPE_VEO, CPU_SUBTYPE_VEO_ALL, NX_BigEndian, -@@ -124,6 +126,22 @@ - "PowerPC 970" }, - {"ppc970-64", CPU_TYPE_POWERPC64, CPU_SUBTYPE_POWERPC_970, NX_BigEndian, - "PowerPC 970 64-bit"}, -+ {"armv4t", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V4T, NX_LittleEndian, -+ "arm v4t"}, -+ {"armv5", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V5TEJ, NX_LittleEndian, -+ "arm v5"}, -+ {"xscale", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_XSCALE, NX_LittleEndian, -+ "arm xscale"}, -+ {"armv6", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V6, NX_LittleEndian, -+ "arm v6"}, -+ {"armv7", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7, NX_LittleEndian, -+ "arm v7"}, -+ {"armv7f", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7F, NX_LittleEndian, -+ "arm v7f"}, -+ {"armv7s", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7S, NX_LittleEndian, -+ "arm v7s"}, -+ {"armv7k", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7K, NX_LittleEndian, -+ "arm v7k"}, - {"little", CPU_TYPE_ANY, CPU_SUBTYPE_LITTLE_ENDIAN, NX_LittleEndian, - "Little Endian"}, - {"big", CPU_TYPE_ANY, CPU_SUBTYPE_BIG_ENDIAN, NX_BigEndian, -@@ -218,7 +236,8 @@ - for(ai = ArchInfoTable; ai->name != NULL; ai++) - if(ai->cputype == cputype && - (cpusubtype == CPU_SUBTYPE_MULTIPLE || -- (ai->cpusubtype == cpusubtype))) -+ ((ai->cpusubtype & ~CPU_SUBTYPE_MASK) == -+ (cpusubtype & ~CPU_SUBTYPE_MASK)))) - return(ai); - - if(cputype == CPU_TYPE_I386){ -@@ -234,8 +253,8 @@ - if(q->description == NULL) - return(NULL); - sprintf((char *)q->description, "Intel family %u model %u", -- CPU_SUBTYPE_INTEL_FAMILY(cpusubtype), -- CPU_SUBTYPE_INTEL_MODEL(cpusubtype)); -+ CPU_SUBTYPE_INTEL_FAMILY(cpusubtype & ~CPU_SUBTYPE_MASK), -+ CPU_SUBTYPE_INTEL_MODEL(cpusubtype & ~CPU_SUBTYPE_MASK)); - return((const NXArchInfo *)q); - } - else if(cputype == CPU_TYPE_POWERPC){ -@@ -274,15 +293,16 @@ - struct fat_arch *fat_archs, - uint32_t nfat_archs) - { -- unsigned long i; -- long lowest_family, lowest_model, lowest_index; -+ uint32_t i; -+ int32_t lowest_family, lowest_model, lowest_index; - - /* - * Look for the first exact match. - */ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype == cputype && -- fat_archs[i].cpusubtype == cpusubtype) -+ (fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ (cpusubtype & ~CPU_SUBTYPE_MASK)) - return(fat_archs + i); - } - -@@ -292,7 +312,7 @@ - */ - switch(cputype){ - case CPU_TYPE_I386: -- switch(cpusubtype){ -+ switch(cpusubtype & ~CPU_SUBTYPE_MASK){ - default: - /* - * Intel cpusubtypes after the pentium (same as 586) are handled -@@ -303,7 +323,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_PENT) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_PENT) - return(fat_archs + i); - } - case CPU_SUBTYPE_PENT: -@@ -315,7 +336,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_486) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_486) - return(fat_archs + i); - } - break; -@@ -327,7 +349,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_I386_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_I386_ALL) - return(fat_archs + i); - } - -@@ -337,19 +360,22 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_486) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_486) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_486SX) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_486SX) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_586) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_586) - return(fat_archs + i); - } - /* -@@ -359,25 +385,26 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(CPU_SUBTYPE_INTEL_FAMILY(fat_archs[i].cpusubtype) < -- lowest_family) -+ if(CPU_SUBTYPE_INTEL_FAMILY(fat_archs[i].cpusubtype & -+ ~CPU_SUBTYPE_MASK) < lowest_family) - lowest_family = CPU_SUBTYPE_INTEL_FAMILY( -- fat_archs[i].cpusubtype); -+ fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK); - } - /* if no intel cputypes found return NULL */ - if(lowest_family == CPU_SUBTYPE_INTEL_FAMILY_MAX + 1) - return(NULL); -- lowest_model = LONG_MAX; -+ lowest_model = INT_MAX; - lowest_index = -1; - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(CPU_SUBTYPE_INTEL_FAMILY(fat_archs[i].cpusubtype) == -- lowest_family){ -- if(CPU_SUBTYPE_INTEL_MODEL(fat_archs[i].cpusubtype) < -- lowest_model){ -+ if(CPU_SUBTYPE_INTEL_FAMILY(fat_archs[i].cpusubtype & -+ ~CPU_SUBTYPE_MASK) == lowest_family){ -+ if(CPU_SUBTYPE_INTEL_MODEL(fat_archs[i].cpusubtype & -+ ~CPU_SUBTYPE_MASK) < lowest_model){ - lowest_model = CPU_SUBTYPE_INTEL_MODEL( -- fat_archs[i].cpusubtype); -+ fat_archs[i].cpusubtype & -+ ~CPU_SUBTYPE_MASK); - lowest_index = i; - } - } -@@ -387,7 +414,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_X86_64_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_X86_64_ALL) - return(fat_archs + i); - } - break; -@@ -395,24 +423,27 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_MC680x0_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_MC680x0_ALL) - return(fat_archs + i); - } - /* - * Try to promote if starting from CPU_SUBTYPE_MC680x0_ALL and - * favor the CPU_SUBTYPE_MC68040 over the CPU_SUBTYPE_MC68030_ONLY. - */ -- if(cpusubtype == CPU_SUBTYPE_MC680x0_ALL){ -+ if((cpusubtype & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC680x0_ALL){ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_MC68040) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_MC68040) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_MC68030_ONLY) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_MC68030_ONLY) - return(fat_archs + i); - } - } -@@ -428,7 +459,7 @@ - * an exact match. For an unknown subtype pick only the ALL type if - * it exists. - */ -- switch(cpusubtype){ -+ switch(cpusubtype & ~CPU_SUBTYPE_MASK){ - case CPU_SUBTYPE_POWERPC_ALL: - /* - * The CPU_SUBTYPE_POWERPC_ALL is only used by the development -@@ -440,7 +471,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_970) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_970) - return(fat_archs + i); - } - case CPU_SUBTYPE_POWERPC_7450: -@@ -448,13 +480,15 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_7450) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_7450) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_7400) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_7400) - return(fat_archs + i); - } - case CPU_SUBTYPE_POWERPC_750: -@@ -466,44 +500,51 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_750) -+ if((fat_archs[i].cpusubtype & CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_750) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_604e) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_604e) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_604) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_604) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ -- if(fat_archs[i].cputype != cputype) -+ if((fat_archs[i].cputype & ~CPU_SUBTYPE_MASK) != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_603ev) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_603ev) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_603e) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_603e) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_603) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_603) - return(fat_archs + i); - } - default: - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_ALL) - return(fat_archs + i); - } - } -@@ -517,7 +558,7 @@ - * 970 (currently only the one 64-bit subtype) - * For an unknown subtype pick only the ALL type if it exists. - */ -- switch(cpusubtype){ -+ switch(cpusubtype & ~CPU_SUBTYPE_MASK){ - case CPU_SUBTYPE_POWERPC_ALL: - /* - * The CPU_SUBTYPE_POWERPC_ALL is only used by the development -@@ -529,14 +570,16 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_970) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_970) - return(fat_archs + i); - } - default: - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_ALL) - return(fat_archs + i); - } - } -@@ -545,7 +588,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_MC88000_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_MC88000_ALL) - return(fat_archs + i); - } - break; -@@ -553,7 +597,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_I860_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_I860_ALL) - return(fat_archs + i); - } - break; -@@ -561,7 +606,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_HPPA_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_HPPA_ALL) - return(fat_archs + i); - } - break; -@@ -569,10 +615,38 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_SPARC_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_SPARC_ALL) - return(fat_archs + i); - } - break; -+ case CPU_TYPE_ARM: -+ { -+ /* -+ * ARM is straightforward, since each architecture is backward -+ * compatible with previous architectures. So, we just take the -+ * highest that is less than our target. -+ */ -+ int fat_match_found = 0; -+ uint32_t best_fat_arch = 0; -+ for(i = 0; i < nfat_archs; i++){ -+ if(fat_archs[i].cputype != cputype) -+ continue; -+ if(fat_archs[i].cpusubtype > cpusubtype) -+ continue; -+ if(!fat_match_found){ -+ fat_match_found = 1; -+ best_fat_arch = i; -+ continue; -+ } -+ if(fat_archs[i].cpusubtype > -+ fat_archs[best_fat_arch].cpusubtype) -+ best_fat_arch = i; -+ } -+ if(fat_match_found) -+ return fat_archs + best_fat_arch; -+ } -+ break; - default: - return(NULL); - } -@@ -603,33 +677,34 @@ - if(cputype == CPU_TYPE_X86_64) - return(CPU_SUBTYPE_X86_64_ALL); - -- if(cpusubtype1 == cpusubtype2) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK)) - return(cpusubtype1); - - switch(cputype){ - case CPU_TYPE_MC680x0: -- if(cpusubtype1 != CPU_SUBTYPE_MC680x0_ALL && -- cpusubtype1 != CPU_SUBTYPE_MC68030_ONLY && -- cpusubtype1 != CPU_SUBTYPE_MC68040) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC680x0_ALL && -+ (cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68030_ONLY && -+ (cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68040) - return((cpu_subtype_t)-1); -- if(cpusubtype2 != CPU_SUBTYPE_MC680x0_ALL && -- cpusubtype2 != CPU_SUBTYPE_MC68030_ONLY && -- cpusubtype2 != CPU_SUBTYPE_MC68040) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC680x0_ALL && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68030_ONLY && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68040) - return((cpu_subtype_t)-1); - -- if(cpusubtype1 == CPU_SUBTYPE_MC68030_ONLY && -- cpusubtype2 == CPU_SUBTYPE_MC68040) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040) - return((cpu_subtype_t)-1); -- if(cpusubtype1 == CPU_SUBTYPE_MC68040 && -- cpusubtype2 == CPU_SUBTYPE_MC68030_ONLY) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040 && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY) - return((cpu_subtype_t)-1); - -- if(cpusubtype1 == CPU_SUBTYPE_MC68030_ONLY || -- cpusubtype2 == CPU_SUBTYPE_MC68030_ONLY) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY || -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY) - return(CPU_SUBTYPE_MC68030_ONLY); - -- if(cpusubtype1 == CPU_SUBTYPE_MC68040 || -- cpusubtype2 == CPU_SUBTYPE_MC68040) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040 || -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040) - return(CPU_SUBTYPE_MC68040); - break; /* logically can't get here */ - -@@ -639,66 +714,124 @@ - * anything with the 601 becomes 601. All other non exact matches - * combine to the higher value subtype. - */ -- if(cpusubtype1 == CPU_SUBTYPE_POWERPC_ALL) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_ALL) - return(cpusubtype2); -- if(cpusubtype2 == CPU_SUBTYPE_POWERPC_ALL) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_ALL) - return(cpusubtype1); - -- if(cpusubtype1 == CPU_SUBTYPE_POWERPC_601 || -- cpusubtype2 == CPU_SUBTYPE_POWERPC_601) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_601 || -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_601) - return(CPU_SUBTYPE_POWERPC_601); - -- if(cpusubtype1 > cpusubtype2) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) > -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK)) - return(cpusubtype1); - else - return(cpusubtype2); - break; /* logically can't get here */ - - case CPU_TYPE_MC88000: -- if(cpusubtype1 != CPU_SUBTYPE_MC88000_ALL && -- cpusubtype1 != CPU_SUBTYPE_MC88110) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88000_ALL && -+ (cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88110) - return((cpu_subtype_t)-1); -- if(cpusubtype2 != CPU_SUBTYPE_MC88000_ALL && -- cpusubtype2 != CPU_SUBTYPE_MC88110) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88000_ALL && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88110) - return((cpu_subtype_t)-1); - -- if(cpusubtype1 == CPU_SUBTYPE_MC88110 || -- cpusubtype2 == CPU_SUBTYPE_MC88110) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC88110 || -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC88110) - return(CPU_SUBTYPE_MC88110); - - break; /* logically can't get here */ - - case CPU_TYPE_I860: -- if(cpusubtype1 != CPU_SUBTYPE_I860_ALL && -- cpusubtype1 != CPU_SUBTYPE_I860_860) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_ALL && -+ (cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_860) - return((cpu_subtype_t)-1); -- if(cpusubtype2 != CPU_SUBTYPE_I860_ALL && -- cpusubtype2 != CPU_SUBTYPE_I860_860) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_ALL && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_860) - return((cpu_subtype_t)-1); - -- if(cpusubtype1 == CPU_SUBTYPE_I860_860 || -- cpusubtype2 == CPU_SUBTYPE_I860_860) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_I860_860 || -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_I860_860) - return(CPU_SUBTYPE_I860_860); - break; /* logically can't get here */ - - case CPU_TYPE_HPPA: -- if(cpusubtype1 != CPU_SUBTYPE_HPPA_ALL && -- cpusubtype1 != CPU_SUBTYPE_HPPA_7100LC) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_ALL && -+ (cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_7100LC) - return((cpu_subtype_t)-1); -- if(cpusubtype2 != CPU_SUBTYPE_HPPA_ALL && -- cpusubtype2 != CPU_SUBTYPE_HPPA_7100LC) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_ALL && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_7100LC) - return((cpu_subtype_t)-1); - - return(CPU_SUBTYPE_HPPA_7100LC); - break; /* logically can't get here */ - - case CPU_TYPE_SPARC: -- if(cpusubtype1 != CPU_SUBTYPE_SPARC_ALL) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_SPARC_ALL) - return((cpu_subtype_t)-1); -- if(cpusubtype2 != CPU_SUBTYPE_SPARC_ALL) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_SPARC_ALL) - return((cpu_subtype_t)-1); - break; /* logically can't get here */ - -+ case CPU_TYPE_ARM: -+ /* -+ * Combinability matrix for ARM: -+ * V4T V5 XSCALE V6 V7 ALL -+ * ~~~ ~~ ~~~~~~ ~~ ~~ ~~~ -+ * V4T V4T V5 XSCALE V6 V7 ALL -+ * V5 V5 V5 -- V6 V7 ALL -+ * XSCALE XSCALE -- XSCALE -- -- ALL -+ * V6 V6 V6 -- V6 V7 ALL -+ * V7 V7 V7 -- V7 V7 ALL -+ * ALL ALL ALL ALL ALL ALL ALL -+ */ -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_ARM_ALL) -+ return(cpusubtype2); -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_ARM_ALL) -+ return(cpusubtype1); -+ switch((cpusubtype1 & ~CPU_SUBTYPE_MASK)){ -+ case CPU_SUBTYPE_ARM_V7: -+ switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){ -+ case CPU_SUBTYPE_ARM_XSCALE: -+ return((cpu_subtype_t)-1); -+ default: -+ return(CPU_SUBTYPE_ARM_V7); -+ } -+ case CPU_SUBTYPE_ARM_V6: -+ switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){ -+ case CPU_SUBTYPE_ARM_XSCALE: -+ return((cpu_subtype_t)-1); -+ default: -+ return(CPU_SUBTYPE_ARM_V6); -+ } -+ case CPU_SUBTYPE_ARM_XSCALE: -+ switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){ -+ case CPU_SUBTYPE_ARM_V7: -+ case CPU_SUBTYPE_ARM_V6: -+ case CPU_SUBTYPE_ARM_V5TEJ: -+ return((cpu_subtype_t)-1); -+ default: -+ return(CPU_SUBTYPE_ARM_XSCALE); -+ } -+ case CPU_SUBTYPE_ARM_V5TEJ: -+ switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){ -+ case CPU_SUBTYPE_ARM_XSCALE: -+ return((cpu_subtype_t)-1); -+ case CPU_SUBTYPE_ARM_V7: -+ return(CPU_SUBTYPE_ARM_V7); -+ case CPU_SUBTYPE_ARM_V6: -+ return(CPU_SUBTYPE_ARM_V6); -+ default: -+ return(CPU_SUBTYPE_ARM_V5TEJ); -+ } -+ case CPU_SUBTYPE_ARM_V4T: -+ return((cpusubtype2 & ~CPU_SUBTYPE_MASK)); -+ default: -+ return((cpu_subtype_t)-1); -+ } -+ - default: - return((cpu_subtype_t)-1); - } -Index: odcctools-9.2-ld/libmacho/get_end.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/get_end.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/get_end.c 2013-09-03 14:12:37.137786960 +0000 -@@ -25,13 +25,7 @@ - #include <mach-o/ldsyms.h> - #include <mach-o/getsect.h> - #ifndef __OPENSTEP__ -- --#ifdef __LP64__ --extern struct mach_header_64 *_NSGetMachExecuteHeader(void); --#else /* !defined(__LP64__) */ - #include <crt_externs.h> --#endif /* !defined(__LP64__) */ -- - #else /* defined(__OPENSTEP__) */ - #ifdef __DYNAMIC__ - #include "mach-o/dyld.h" /* defines _dyld_lookup_and_bind() */ -@@ -49,7 +43,7 @@ - #define SETUP_VAR(var) \ - if ( var ## _pointer == 0) { \ - _dyld_lookup_and_bind( STRINGIFY(_ ## var), \ -- (unsigned long *) & var ## _pointer, 0); \ -+ (uint32_t *) & var ## _pointer, 0); \ - } - #define USE_VAR(var) (* var ## _pointer) - #endif -@@ -70,13 +64,13 @@ - { - #ifndef __LP64__ - -- static struct mach_header *mhp = NULL; - struct segment_command *sgp; -- unsigned long i, _end; -+ unsigned long _end; -+ uint32_t i; - #ifndef __OPENSTEP__ -- if(mhp == NULL) -- mhp = _NSGetMachExecuteHeader(); -+ struct mach_header *mhp = _NSGetMachExecuteHeader(); - #else /* defined(__OPENSTEP__) */ -+ static struct mach_header *mhp = NULL; - DECLARE_VAR(_mh_execute_header, struct mach_header); - SETUP_VAR(_mh_execute_header); - -@@ -95,12 +89,11 @@ - - #else /* defined(__LP64__) */ - -- static struct mach_header_64 *mhp = NULL; -+ struct mach_header_64 *mhp = _NSGetMachExecuteHeader(); - struct segment_command_64 *sgp; -- unsigned long i, _end; -+ unsigned long _end; -+ uint32_t i; - -- if(mhp == NULL) -- mhp = _NSGetMachExecuteHeader(); - _end = 0; - sgp = (struct segment_command_64 *) - ((char *)mhp + sizeof(struct mach_header_64)); -Index: odcctools-9.2-ld/libmacho/getsecbyname.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/getsecbyname.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/getsecbyname.c 2013-09-03 14:13:37.465785445 +0000 -@@ -28,13 +28,7 @@ - #include <mach-o/dyld.h> /* defines _dyld_lookup_and_bind() */ - #endif /* defined(__DYNAMIC__) */ - #ifndef __OPENSTEP__ -- --#ifdef __LP64__ --extern struct mach_header_64 *_NSGetMachExecuteHeader(void); --#else /* !defined(__LP64__) */ - #include <crt_externs.h> --#endif /* !defined(__LP64__) */ -- - #else /* defined(__OPENSTEP__) */ - - #if !defined(__DYNAMIC__) -@@ -49,7 +43,7 @@ - #define SETUP_VAR(var) \ - if ( var ## _pointer == NULL) { \ - _dyld_lookup_and_bind( STRINGIFY(_ ## var), \ -- (unsigned long *) & var ## _pointer, NULL); \ -+ (uint32_t *) & var ## _pointer, NULL); \ - } - #define USE_VAR(var) (* var ## _pointer) - #endif -@@ -68,7 +62,7 @@ - { - struct segment_command *sgp; - struct section *sp; -- unsigned long i, j; -+ uint32_t i, j; - - sgp = (struct segment_command *) - ((char *)mhp + sizeof(struct mach_header)); -@@ -106,7 +100,7 @@ - { - struct segment_command_64 *sgp; - struct section_64 *sp; -- unsigned long i, j; -+ uint32_t i, j; - - sgp = (struct segment_command_64 *) - ((char *)mhp + sizeof(struct mach_header_64)); -@@ -147,12 +141,12 @@ - { - struct segment_command *sgp; - struct section *sp; -- unsigned long i, j; -+ uint32_t i, j; - - sgp = (struct segment_command *) - ((char *)mhp + sizeof(struct mach_header)); - for(i = 0; i < mhp->ncmds; i++){ -- if(sgp->cmd == (fSwap ? NXSwapLong(LC_SEGMENT) : LC_SEGMENT)) { -+ if(sgp->cmd == (fSwap ? OSSwapInt32(LC_SEGMENT) : LC_SEGMENT)) { - - if (fSwap) { - #ifdef __LITTLE_ENDIAN__ -@@ -188,7 +182,7 @@ - sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); - } else { - sgp = (struct segment_command *)((char *)sgp + -- (fSwap ? NXSwapLong(sgp->cmdsize) : sgp->cmdsize)); -+ (fSwap ? OSSwapInt32(sgp->cmdsize) : sgp->cmdsize)); - } - } - return((struct section *)0); -@@ -206,11 +200,10 @@ - const char *segname, - const char *sectname) - { -- static struct mach_header *mhp = NULL; - #ifndef __OPENSTEP__ -- if(mhp == NULL) -- mhp = _NSGetMachExecuteHeader(); -+ struct mach_header *mhp = _NSGetMachExecuteHeader(); - #else /* defined(__OPENSTEP__) */ -+ static struct mach_header *mhp = NULL; - DECLARE_VAR(_mh_execute_header, struct mach_header); - SETUP_VAR(_mh_execute_header); - mhp = (struct mach_header *)(& USE_VAR(_mh_execute_header)); -@@ -225,10 +218,8 @@ - const char *segname, - const char *sectname) - { -- static struct mach_header_64 *mhp = NULL; -+ struct mach_header_64 *mhp = _NSGetMachExecuteHeader(); - -- if(mhp == NULL) -- mhp = _NSGetMachExecuteHeader(); - return(getsectbynamefromheader_64(mhp, segname, sectname)); - } - -@@ -262,6 +253,185 @@ - } - - /* -+ * This routine returns the a pointer to the section contents of the named -+ * section in the named segment if it exists in the image pointed to by the -+ * mach header. Otherwise it returns zero. -+ */ -+#ifndef __LP64__ -+ -+uint8_t * -+getsectiondata( -+const struct mach_header *mhp, -+const char *segname, -+const char *sectname, -+unsigned long *size) -+{ -+ struct segment_command *sgp, *zero; -+ struct section *sp, *find; -+ uint32_t i, j; -+ -+ zero = 0; -+ find = 0; -+ sp = 0; -+ sgp = (struct segment_command *) -+ ((char *)mhp + sizeof(struct mach_header)); -+ for(i = 0; i < mhp->ncmds; i++){ -+ if(sgp->cmd == LC_SEGMENT){ -+ if(zero == 0 && sgp->fileoff == 0 && sgp->nsects != 0){ -+ zero = sgp; -+ if(find != 0) -+ goto done; -+ } -+ if(find == 0 && -+ strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0){ -+ sp = (struct section *)((char *)sgp + -+ sizeof(struct segment_command)); -+ for(j = 0; j < sgp->nsects; j++){ -+ if(strncmp(sp->sectname, sectname, -+ sizeof(sp->sectname)) == 0 && -+ strncmp(sp->segname, segname, -+ sizeof(sp->segname)) == 0){ -+ find = sp; -+ if(zero != 0) -+ goto done; -+ } -+ sp = (struct section *)((char *)sp + -+ sizeof(struct section)); -+ } -+ } -+ } -+ sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); -+ } -+ return(0); -+done: -+ *size = sp->size; -+ return((uint8_t *)((uintptr_t)mhp - zero->vmaddr + sp->addr)); -+} -+ -+uint8_t * -+getsegmentdata( -+const struct mach_header *mhp, -+const char *segname, -+unsigned long *size) -+{ -+ struct segment_command *sgp, *zero, *find; -+ uint32_t i; -+ -+ zero = 0; -+ find = 0; -+ sgp = (struct segment_command *) -+ ((char *)mhp + sizeof(struct mach_header)); -+ for(i = 0; i < mhp->ncmds; i++){ -+ if(sgp->cmd == LC_SEGMENT){ -+ if(zero == 0 && sgp->fileoff == 0 && sgp->nsects != 0){ -+ zero = sgp; -+ if(find != 0) -+ goto done; -+ } -+ if(find == 0 && -+ strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0){ -+ find = sgp; -+ if(zero != 0) -+ goto done; -+ } -+ } -+ sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); -+ } -+ return(0); -+done: -+ *size = sgp->vmsize; -+ return((uint8_t *)((uintptr_t)mhp - zero->vmaddr + sgp->vmaddr)); -+} -+ -+#else /* defined(__LP64__) */ -+ -+uint8_t * -+getsectiondata( -+const struct mach_header_64 *mhp, -+const char *segname, -+const char *sectname, -+unsigned long *size) -+{ -+ struct segment_command_64 *sgp, *zero; -+ struct section_64 *sp, *find; -+ uint32_t i, j; -+ -+ zero = 0; -+ find = 0; -+ sp = 0; -+ sgp = (struct segment_command_64 *) -+ ((char *)mhp + sizeof(struct mach_header_64)); -+ for(i = 0; i < mhp->ncmds; i++){ -+ if(sgp->cmd == LC_SEGMENT_64){ -+ if(zero == 0 && sgp->fileoff == 0 && sgp->nsects != 0){ -+ zero = sgp; -+ if(find != 0) -+ goto done; -+ } -+ if(find == 0 && -+ strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0){ -+ sp = (struct section_64 *)((char *)sgp + -+ sizeof(struct segment_command_64)); -+ for(j = 0; j < sgp->nsects; j++){ -+ if(strncmp(sp->sectname, sectname, -+ sizeof(sp->sectname)) == 0 && -+ strncmp(sp->segname, segname, -+ sizeof(sp->segname)) == 0){ -+ find = sp; -+ if(zero != 0) -+ goto done; -+ } -+ sp = (struct section_64 *)((char *)sp + -+ sizeof(struct section_64)); -+ } -+ } -+ } -+ sgp = (struct segment_command_64 *)((char *)sgp + sgp->cmdsize); -+ } -+ return(0); -+done: -+ *size = sp->size; -+ return((uint8_t *)((uintptr_t)mhp - zero->vmaddr + sp->addr)); -+} -+ -+uint8_t * -+getsegmentdata( -+const struct mach_header_64 *mhp, -+const char *segname, -+unsigned long *size) -+{ -+ struct segment_command_64 *sgp, *zero, *find; -+ uint32_t i; -+ -+ zero = 0; -+ find = 0; -+ sgp = (struct segment_command_64 *) -+ ((char *)mhp + sizeof(struct mach_header_64)); -+ for(i = 0; i < mhp->ncmds; i++){ -+ if(sgp->cmd == LC_SEGMENT_64){ -+ if(zero == 0 && sgp->fileoff == 0 && sgp->nsects != 0){ -+ zero = sgp; -+ if(find != 0) -+ goto done; -+ } -+ if(find == 0 && -+ strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0){ -+ find = sgp; -+ if(zero != 0) -+ goto done; -+ } -+ } -+ sgp = (struct segment_command_64 *)((char *)sgp + sgp->cmdsize); -+ } -+ return(0); -+done: -+ *size = sgp->vmsize; -+ return((uint8_t *)((uintptr_t)mhp - zero->vmaddr + sgp->vmaddr)); -+} -+ -+#endif /* defined(__LP64__) */ -+ -+/* - * This routine returns the a pointer to the data for the named section in the - * named segment if it exist in the mach header passed to it. Also it returns - * the size of the section data indirectly through the pointer size. Otherwise -@@ -282,7 +452,7 @@ - return(NULL); - } - *size = sp->size; -- return((char *)((unsigned long)(sp->addr))); -+ return((char *)((uintptr_t)(sp->addr))); - } - - /* -@@ -306,7 +476,7 @@ - return(NULL); - } - *size = sp->size; -- return((char *)((unsigned long)(sp->addr))); -+ return((char *)((uintptr_t)(sp->addr))); - } - - #ifdef __DYNAMIC__ -@@ -324,7 +494,8 @@ - const char *sectname, - unsigned long *size) - { -- unsigned long i, n, vmaddr_slide; -+ uint32_t i, n; -+ uintptr_t vmaddr_slide; - #ifndef __LP64__ - struct mach_header *mh; - const struct section *s; -Index: odcctools-9.2-ld/libmacho/getsegbyname.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/getsegbyname.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/getsegbyname.c 2013-09-03 14:14:09.793784630 +0000 -@@ -25,11 +25,7 @@ - #ifndef __OPENSTEP__ - - #ifndef RLD --#ifdef __LP64__ --extern struct mach_header_64 *_NSGetMachExecuteHeader(void); --#else /* !defined(__LP64__) */ - #include <crt_externs.h> --#endif /* !defined(__LP64__) */ - #endif /* !defined(RLD) */ - - #else /* defined(__OPENSTEP__) */ -@@ -49,7 +45,7 @@ - #define SETUP_VAR(var) \ - if ( var ## _pointer == 0) { \ - _dyld_lookup_and_bind( STRINGIFY(_ ## var), \ -- (unsigned long *) & var ## _pointer, 0); \ -+ (uint32_t *) & var ## _pointer, 0); \ - } - #define USE_VAR(var) (* var ## _pointer) - #endif -@@ -68,14 +64,13 @@ - getsegbyname( - char *segname) - { -- static struct mach_header *mhp = NULL; - struct segment_command *sgp; -- unsigned long i; -+ uint32_t i; - #ifndef RLD - #ifndef __OPENSTEP__ -- if(mhp == NULL) -- mhp = _NSGetMachExecuteHeader(); -+ struct mach_header *mhp = _NSGetMachExecuteHeader(); - #else /* defined(__OPENSTEP__) */ -+ static struct mach_header *mhp = NULL; - DECLARE_VAR(_mh_execute_header, struct mach_header); - SETUP_VAR(_mh_execute_header); - mhp = (struct mach_header *)(& USE_VAR(_mh_execute_header)); -@@ -101,15 +96,14 @@ - getsegbyname( - char *segname) - { -- static struct mach_header_64 *mhp = NULL; -+ struct mach_header_64 *mhp = NULL; - struct segment_command_64 *sgp; -- unsigned long i; -+ uint32_t i; - -- if(mhp == NULL) - #ifndef RLD -- mhp = _NSGetMachExecuteHeader(); -+ mhp = _NSGetMachExecuteHeader(); - #else /* defined(RLD) */ -- mhp = (struct mach_header_64 *)(&_mh_execute_header); -+ mhp = (struct mach_header_64 *)(&_mh_execute_header); - #endif /* defined(RLD) */ - - sgp = (struct segment_command_64 *) -Index: odcctools-9.2-ld/libmacho/i386_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/i386_swap.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/i386_swap.c 2013-09-03 14:10:33.669788354 +0000 -@@ -132,6 +132,7 @@ - #define __dr7 dr7 - - #include <string.h> -+#include <libkern/OSByteOrder.h> - #include <mach-o/i386/swap.h> - - void -@@ -139,22 +140,22 @@ - i386_thread_state_t *cpu, - enum NXByteOrder target_byte_sex) - { -- cpu->eax = NXSwapLong(cpu->eax); -- cpu->ebx = NXSwapLong(cpu->ebx); -- cpu->ecx = NXSwapLong(cpu->ecx); -- cpu->edx = NXSwapLong(cpu->edx); -- cpu->edi = NXSwapLong(cpu->edi); -- cpu->esi = NXSwapLong(cpu->esi); -- cpu->ebp = NXSwapLong(cpu->ebp); -- cpu->esp = NXSwapLong(cpu->esp); -- cpu->ss = NXSwapLong(cpu->ss); -- cpu->eflags = NXSwapLong(cpu->eflags); -- cpu->eip = NXSwapLong(cpu->eip); -- cpu->cs = NXSwapLong(cpu->cs); -- cpu->ds = NXSwapLong(cpu->ds); -- cpu->es = NXSwapLong(cpu->es); -- cpu->fs = NXSwapLong(cpu->fs); -- cpu->gs = NXSwapLong(cpu->gs); -+ cpu->eax = OSSwapInt32(cpu->eax); -+ cpu->ebx = OSSwapInt32(cpu->ebx); -+ cpu->ecx = OSSwapInt32(cpu->ecx); -+ cpu->edx = OSSwapInt32(cpu->edx); -+ cpu->edi = OSSwapInt32(cpu->edi); -+ cpu->esi = OSSwapInt32(cpu->esi); -+ cpu->ebp = OSSwapInt32(cpu->ebp); -+ cpu->esp = OSSwapInt32(cpu->esp); -+ cpu->ss = OSSwapInt32(cpu->ss); -+ cpu->eflags = OSSwapInt32(cpu->eflags); -+ cpu->eip = OSSwapInt32(cpu->eip); -+ cpu->cs = OSSwapInt32(cpu->cs); -+ cpu->ds = OSSwapInt32(cpu->ds); -+ cpu->es = OSSwapInt32(cpu->es); -+ cpu->fs = OSSwapInt32(cpu->fs); -+ cpu->gs = OSSwapInt32(cpu->gs); - } - - #ifdef x86_THREAD_STATE64 -@@ -163,27 +164,27 @@ - x86_thread_state64_t *cpu, - enum NXByteOrder target_byte_sex) - { -- cpu->rax = NXSwapLongLong(cpu->rax); -- cpu->rbx = NXSwapLongLong(cpu->rbx); -- cpu->rcx = NXSwapLongLong(cpu->rcx); -- cpu->rdx = NXSwapLongLong(cpu->rdx); -- cpu->rdi = NXSwapLongLong(cpu->rdi); -- cpu->rsi = NXSwapLongLong(cpu->rsi); -- cpu->rbp = NXSwapLongLong(cpu->rbp); -- cpu->rsp = NXSwapLongLong(cpu->rsp); -- cpu->rflags = NXSwapLongLong(cpu->rflags); -- cpu->rip = NXSwapLongLong(cpu->rip); -- cpu->r8 = NXSwapLongLong(cpu->r8); -- cpu->r9 = NXSwapLongLong(cpu->r9); -- cpu->r10 = NXSwapLongLong(cpu->r10); -- cpu->r11 = NXSwapLongLong(cpu->r11); -- cpu->r12 = NXSwapLongLong(cpu->r12); -- cpu->r13 = NXSwapLongLong(cpu->r13); -- cpu->r14 = NXSwapLongLong(cpu->r14); -- cpu->r15 = NXSwapLongLong(cpu->r15); -- cpu->cs = NXSwapLongLong(cpu->cs); -- cpu->fs = NXSwapLongLong(cpu->fs); -- cpu->gs = NXSwapLongLong(cpu->gs); -+ cpu->rax = OSSwapInt64(cpu->rax); -+ cpu->rbx = OSSwapInt64(cpu->rbx); -+ cpu->rcx = OSSwapInt64(cpu->rcx); -+ cpu->rdx = OSSwapInt64(cpu->rdx); -+ cpu->rdi = OSSwapInt64(cpu->rdi); -+ cpu->rsi = OSSwapInt64(cpu->rsi); -+ cpu->rbp = OSSwapInt64(cpu->rbp); -+ cpu->rsp = OSSwapInt64(cpu->rsp); -+ cpu->rflags = OSSwapInt64(cpu->rflags); -+ cpu->rip = OSSwapInt64(cpu->rip); -+ cpu->r8 = OSSwapInt64(cpu->r8); -+ cpu->r9 = OSSwapInt64(cpu->r9); -+ cpu->r10 = OSSwapInt64(cpu->r10); -+ cpu->r11 = OSSwapInt64(cpu->r11); -+ cpu->r12 = OSSwapInt64(cpu->r12); -+ cpu->r13 = OSSwapInt64(cpu->r13); -+ cpu->r14 = OSSwapInt64(cpu->r14); -+ cpu->r15 = OSSwapInt64(cpu->r15); -+ cpu->cs = OSSwapInt64(cpu->cs); -+ cpu->fs = OSSwapInt64(cpu->fs); -+ cpu->gs = OSSwapInt64(cpu->gs); - } - - void -@@ -191,8 +192,8 @@ - x86_state_hdr_t *hdr, - enum NXByteOrder target_byte_sex) - { -- hdr->flavor = NXSwapLong(hdr->flavor); -- hdr->count = NXSwapLong(hdr->count); -+ hdr->flavor = OSSwapInt32(hdr->flavor); -+ hdr->count = OSSwapInt32(hdr->count); - } - - void -@@ -247,13 +248,13 @@ - - host_byte_sex = NXHostByteOrder(); - -- fpu->fpu_reserved[0] = NXSwapLong(fpu->fpu_reserved[0]); -- fpu->fpu_reserved[1] = NXSwapLong(fpu->fpu_reserved[1]); -+ fpu->fpu_reserved[0] = OSSwapInt32(fpu->fpu_reserved[0]); -+ fpu->fpu_reserved[1] = OSSwapInt32(fpu->fpu_reserved[1]); - - if(target_byte_sex == host_byte_sex){ - memcpy(&sfpc, &(fpu->fpu_fcw), - sizeof(struct swapped_fp_control)); -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - fpu->fpu_fcw.rc = sfpc.u.fields.rc; - fpu->fpu_fcw.pc = sfpc.u.fields.pc; - fpu->fpu_fcw.precis = sfpc.u.fields.precis; -@@ -265,7 +266,7 @@ - - memcpy(&sfps, &(fpu->fpu_fsw), - sizeof(struct swapped_fp_status)); -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - fpu->fpu_fsw.busy = sfps.u.fields.busy; - fpu->fpu_fsw.c3 = sfps.u.fields.c3; - fpu->fpu_fsw.tos = sfps.u.fields.tos; -@@ -290,7 +291,7 @@ - sfpc.u.fields.zdiv = fpu->fpu_fcw.zdiv; - sfpc.u.fields.denorm = fpu->fpu_fcw.denorm; - sfpc.u.fields.invalid = fpu->fpu_fcw.invalid; -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - memcpy(&(fpu->fpu_fcw), &sfpc, - sizeof(struct swapped_fp_control)); - -@@ -308,20 +309,20 @@ - sfps.u.fields.zdiv = fpu->fpu_fsw.zdiv; - sfps.u.fields.denorm = fpu->fpu_fsw.denorm; - sfps.u.fields.invalid = fpu->fpu_fsw.invalid; -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - memcpy(&(fpu->fpu_fsw), &sfps, - sizeof(struct swapped_fp_status)); - } -- fpu->fpu_fop = NXSwapShort(fpu->fpu_fop); -- fpu->fpu_ip = NXSwapLong(fpu->fpu_ip); -- fpu->fpu_cs = NXSwapShort(fpu->fpu_cs); -- fpu->fpu_rsrv2 = NXSwapShort(fpu->fpu_rsrv2); -- fpu->fpu_dp = NXSwapLong(fpu->fpu_dp); -- fpu->fpu_ds = NXSwapShort(fpu->fpu_ds); -- fpu->fpu_rsrv3 = NXSwapShort(fpu->fpu_rsrv3); -- fpu->fpu_mxcsr = NXSwapLong(fpu->fpu_mxcsr); -- fpu->fpu_mxcsrmask = NXSwapLong(fpu->fpu_mxcsrmask); -- fpu->fpu_reserved1 = NXSwapLong(fpu->fpu_reserved1); -+ fpu->fpu_fop = OSSwapInt16(fpu->fpu_fop); -+ fpu->fpu_ip = OSSwapInt32(fpu->fpu_ip); -+ fpu->fpu_cs = OSSwapInt16(fpu->fpu_cs); -+ fpu->fpu_rsrv2 = OSSwapInt16(fpu->fpu_rsrv2); -+ fpu->fpu_dp = OSSwapInt32(fpu->fpu_dp); -+ fpu->fpu_ds = OSSwapInt16(fpu->fpu_ds); -+ fpu->fpu_rsrv3 = OSSwapInt16(fpu->fpu_rsrv3); -+ fpu->fpu_mxcsr = OSSwapInt32(fpu->fpu_mxcsr); -+ fpu->fpu_mxcsrmask = OSSwapInt32(fpu->fpu_mxcsrmask); -+ fpu->fpu_reserved1 = OSSwapInt32(fpu->fpu_reserved1); - } - - void -@@ -329,9 +330,9 @@ - x86_exception_state64_t *exc, - enum NXByteOrder target_byte_sex) - { -- exc->trapno = NXSwapLong(exc->trapno); -- exc->err = NXSwapLong(exc->err); -- exc->faultvaddr = NXSwapLongLong(exc->faultvaddr); -+ exc->trapno = OSSwapInt32(exc->trapno); -+ exc->err = OSSwapInt32(exc->err); -+ exc->faultvaddr = OSSwapInt64(exc->faultvaddr); - } - - void -@@ -370,9 +371,13 @@ - - swap_x86_state_hdr(&fpu->fsh, target_byte_sex); - -+/* current i386 thread states */ -+#if i386_THREAD_STATE == 1 - if(hdr.flavor == x86_FLOAT_STATE32) - swap_i386_float_state(&fpu->ufs.fs32, target_byte_sex); -- else if(hdr.flavor == x86_FLOAT_STATE64) -+ else -+#endif -+ if(hdr.flavor == x86_FLOAT_STATE64) - swap_x86_float_state64(&fpu->ufs.fs64, target_byte_sex); - } - -@@ -391,9 +396,13 @@ - - swap_x86_state_hdr(&exc->esh, target_byte_sex); - -+/* current i386 thread states */ -+#if i386_THREAD_STATE == 1 - if(hdr.flavor == x86_EXCEPTION_STATE32) - swap_i386_exception_state(&exc->ues.es32, target_byte_sex); -- else if(hdr.flavor == x86_EXCEPTION_STATE64) -+ else -+#endif -+ if(hdr.flavor == x86_EXCEPTION_STATE64) - swap_x86_exception_state64(&exc->ues.es64, target_byte_sex); - } - -@@ -402,14 +411,14 @@ - x86_debug_state32_t *debug, - enum NXByteOrder target_byte_sex) - { -- debug->dr0 = NXSwapLong(debug->dr0); -- debug->dr1 = NXSwapLong(debug->dr1); -- debug->dr2 = NXSwapLong(debug->dr2); -- debug->dr3 = NXSwapLong(debug->dr3); -- debug->dr4 = NXSwapLong(debug->dr4); -- debug->dr5 = NXSwapLong(debug->dr5); -- debug->dr6 = NXSwapLong(debug->dr6); -- debug->dr7 = NXSwapLong(debug->dr7); -+ debug->dr0 = OSSwapInt32(debug->dr0); -+ debug->dr1 = OSSwapInt32(debug->dr1); -+ debug->dr2 = OSSwapInt32(debug->dr2); -+ debug->dr3 = OSSwapInt32(debug->dr3); -+ debug->dr4 = OSSwapInt32(debug->dr4); -+ debug->dr5 = OSSwapInt32(debug->dr5); -+ debug->dr6 = OSSwapInt32(debug->dr6); -+ debug->dr7 = OSSwapInt32(debug->dr7); - } - - void -@@ -417,14 +426,14 @@ - x86_debug_state64_t *debug, - enum NXByteOrder target_byte_sex) - { -- debug->dr0 = NXSwapLongLong(debug->dr0); -- debug->dr1 = NXSwapLongLong(debug->dr1); -- debug->dr2 = NXSwapLongLong(debug->dr2); -- debug->dr3 = NXSwapLongLong(debug->dr3); -- debug->dr4 = NXSwapLongLong(debug->dr4); -- debug->dr5 = NXSwapLongLong(debug->dr5); -- debug->dr6 = NXSwapLongLong(debug->dr6); -- debug->dr7 = NXSwapLongLong(debug->dr7); -+ debug->dr0 = OSSwapInt64(debug->dr0); -+ debug->dr1 = OSSwapInt64(debug->dr1); -+ debug->dr2 = OSSwapInt64(debug->dr2); -+ debug->dr3 = OSSwapInt64(debug->dr3); -+ debug->dr4 = OSSwapInt64(debug->dr4); -+ debug->dr5 = OSSwapInt64(debug->dr5); -+ debug->dr6 = OSSwapInt64(debug->dr6); -+ debug->dr7 = OSSwapInt64(debug->dr7); - } - - void -@@ -506,13 +515,13 @@ - - host_byte_sex = NXHostByteOrder(); - -- fpu->fpu_reserved[0] = NXSwapLong(fpu->fpu_reserved[0]); -- fpu->fpu_reserved[1] = NXSwapLong(fpu->fpu_reserved[1]); -+ fpu->fpu_reserved[0] = OSSwapInt32(fpu->fpu_reserved[0]); -+ fpu->fpu_reserved[1] = OSSwapInt32(fpu->fpu_reserved[1]); - - if(target_byte_sex == host_byte_sex){ - memcpy(&sfpc, &(fpu->fpu_fcw), - sizeof(struct swapped_fp_control)); -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - fpu->fpu_fcw.rc = sfpc.u.fields.rc; - fpu->fpu_fcw.pc = sfpc.u.fields.pc; - fpu->fpu_fcw.precis = sfpc.u.fields.precis; -@@ -524,7 +533,7 @@ - - memcpy(&sfps, &(fpu->fpu_fsw), - sizeof(struct swapped_fp_status)); -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - fpu->fpu_fsw.busy = sfps.u.fields.busy; - fpu->fpu_fsw.c3 = sfps.u.fields.c3; - fpu->fpu_fsw.tos = sfps.u.fields.tos; -@@ -549,7 +558,7 @@ - sfpc.u.fields.zdiv = fpu->fpu_fcw.zdiv; - sfpc.u.fields.denorm = fpu->fpu_fcw.denorm; - sfpc.u.fields.invalid = fpu->fpu_fcw.invalid; -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - memcpy(&(fpu->fpu_fcw), &sfpc, - sizeof(struct swapped_fp_control)); - -@@ -567,20 +576,20 @@ - sfps.u.fields.zdiv = fpu->fpu_fsw.zdiv; - sfps.u.fields.denorm = fpu->fpu_fsw.denorm; - sfps.u.fields.invalid = fpu->fpu_fsw.invalid; -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - memcpy(&(fpu->fpu_fsw), &sfps, - sizeof(struct swapped_fp_status)); - } -- fpu->fpu_fop = NXSwapShort(fpu->fpu_fop); -- fpu->fpu_ip = NXSwapLong(fpu->fpu_ip); -- fpu->fpu_cs = NXSwapShort(fpu->fpu_cs); -- fpu->fpu_rsrv2 = NXSwapShort(fpu->fpu_rsrv2); -- fpu->fpu_dp = NXSwapLong(fpu->fpu_dp); -- fpu->fpu_ds = NXSwapShort(fpu->fpu_ds); -- fpu->fpu_rsrv3 = NXSwapShort(fpu->fpu_rsrv3); -- fpu->fpu_mxcsr = NXSwapLong(fpu->fpu_mxcsr); -- fpu->fpu_mxcsrmask = NXSwapLong(fpu->fpu_mxcsrmask); -- fpu->fpu_reserved1 = NXSwapLong(fpu->fpu_reserved1); -+ fpu->fpu_fop = OSSwapInt16(fpu->fpu_fop); -+ fpu->fpu_ip = OSSwapInt32(fpu->fpu_ip); -+ fpu->fpu_cs = OSSwapInt16(fpu->fpu_cs); -+ fpu->fpu_rsrv2 = OSSwapInt16(fpu->fpu_rsrv2); -+ fpu->fpu_dp = OSSwapInt32(fpu->fpu_dp); -+ fpu->fpu_ds = OSSwapInt16(fpu->fpu_ds); -+ fpu->fpu_rsrv3 = OSSwapInt16(fpu->fpu_rsrv3); -+ fpu->fpu_mxcsr = OSSwapInt32(fpu->fpu_mxcsr); -+ fpu->fpu_mxcsrmask = OSSwapInt32(fpu->fpu_mxcsrmask); -+ fpu->fpu_reserved1 = OSSwapInt32(fpu->fpu_reserved1); - - #endif /* !defined(i386_EXCEPTION_STATE_COUNT) */ - } -@@ -590,9 +599,9 @@ - i386_exception_state_t *exc, - enum NXByteOrder target_byte_sex) - { -- exc->trapno = NXSwapLong(exc->trapno); -- exc->err = NXSwapLong(exc->err); -- exc->faultvaddr = NXSwapLong(exc->faultvaddr); -+ exc->trapno = OSSwapInt32(exc->trapno); -+ exc->err = OSSwapInt32(exc->err); -+ exc->faultvaddr = OSSwapInt32(exc->faultvaddr); - } - #endif /* i386_THREAD_STATE == 1 */ - -@@ -690,18 +699,18 @@ - } ss; - - enum NXByteOrder host_byte_sex; -- unsigned long i; -+ int i; - - host_byte_sex = NXHostByteOrder(); - -- fpu->environ.ip = NXSwapLong(fpu->environ.ip); -- fpu->environ.opcode = NXSwapShort(fpu->environ.opcode); -- fpu->environ.dp = NXSwapLong(fpu->environ.dp); -+ fpu->environ.ip = OSSwapInt32(fpu->environ.ip); -+ fpu->environ.opcode = OSSwapInt16(fpu->environ.opcode); -+ fpu->environ.dp = OSSwapInt32(fpu->environ.dp); - - if(target_byte_sex == host_byte_sex){ - memcpy(&sfpc, &(fpu->environ.control), - sizeof(struct swapped_fp_control)); -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - fpu->environ.control.rc = sfpc.u.fields.rc; - fpu->environ.control.pc = sfpc.u.fields.pc; - fpu->environ.control.precis = sfpc.u.fields.precis; -@@ -713,7 +722,7 @@ - - memcpy(&sfps, &(fpu->environ.status), - sizeof(struct swapped_fp_status)); -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - fpu->environ.status.busy = sfps.u.fields.busy; - fpu->environ.status.c3 = sfps.u.fields.c3; - fpu->environ.status.tos = sfps.u.fields.tos; -@@ -731,7 +740,7 @@ - - memcpy(&sfpt, &(fpu->environ.tag), - sizeof(struct swapped_fp_tag)); -- sfpt.u.half = NXSwapShort(sfpt.u.half); -+ sfpt.u.half = OSSwapInt16(sfpt.u.half); - fpu->environ.tag.tag7 = sfpt.u.fields.tag7; - fpu->environ.tag.tag6 = sfpt.u.fields.tag6; - fpu->environ.tag.tag5 = sfpt.u.fields.tag5; -@@ -743,14 +752,14 @@ - - memcpy(&ss, &(fpu->environ.cs), - sizeof(struct swapped_sel)); -- ss.u.half = NXSwapShort(ss.u.half); -+ ss.u.half = OSSwapInt16(ss.u.half); - fpu->environ.cs.index = ss.u.fields.index; - fpu->environ.cs.ti = ss.u.fields.ti; - fpu->environ.cs.rpl = ss.u.fields.rpl; - - memcpy(&ss, &(fpu->environ.ds), - sizeof(struct swapped_sel)); -- ss.u.half = NXSwapShort(ss.u.half); -+ ss.u.half = OSSwapInt16(ss.u.half); - fpu->environ.ds.index = ss.u.fields.index; - fpu->environ.ds.ti = ss.u.fields.ti; - fpu->environ.ds.rpl = ss.u.fields.rpl; -@@ -758,11 +767,11 @@ - for(i = 0; i < 8; i++){ - memcpy(&sfpd, &(fpu->stack.ST[i]), - sizeof(struct swapped_fp_data_reg)); -- fpu->stack.ST[i].mant = NXSwapShort(sfpd.mant); -- fpu->stack.ST[i].mant1 = NXSwapShort(sfpd.mant1); -- fpu->stack.ST[i].mant2 = NXSwapShort(sfpd.mant2); -- fpu->stack.ST[i].mant3 = NXSwapShort(sfpd.mant3); -- sfpd.u.half = NXSwapShort(sfpd.u.half); -+ fpu->stack.ST[i].mant = OSSwapInt16(sfpd.mant); -+ fpu->stack.ST[i].mant1 = OSSwapInt16(sfpd.mant1); -+ fpu->stack.ST[i].mant2 = OSSwapInt16(sfpd.mant2); -+ fpu->stack.ST[i].mant3 = OSSwapInt16(sfpd.mant3); -+ sfpd.u.half = OSSwapInt16(sfpd.u.half); - fpu->stack.ST[i].exp = sfpd.u.fields.exp; - fpu->stack.ST[i].sign = sfpd.u.fields.sign; - } -@@ -776,7 +785,7 @@ - sfpc.u.fields.zdiv = fpu->environ.control.zdiv; - sfpc.u.fields.denorm = fpu->environ.control.denorm; - sfpc.u.fields.invalid = fpu->environ.control.invalid; -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - memcpy(&(fpu->environ.control), &sfpc, - sizeof(struct swapped_fp_control)); - -@@ -794,7 +803,7 @@ - sfps.u.fields.zdiv = fpu->environ.status.zdiv; - sfps.u.fields.denorm = fpu->environ.status.denorm; - sfps.u.fields.invalid = fpu->environ.status.invalid; -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - memcpy(&(fpu->environ.status), &sfps, - sizeof(struct swapped_fp_status)); - -@@ -806,32 +815,32 @@ - sfpt.u.fields.tag2 = fpu->environ.tag.tag2; - sfpt.u.fields.tag1 = fpu->environ.tag.tag1; - sfpt.u.fields.tag0 = fpu->environ.tag.tag0; -- sfpt.u.half = NXSwapShort(sfpt.u.half); -+ sfpt.u.half = OSSwapInt16(sfpt.u.half); - memcpy(&(fpu->environ.tag), &sfpt, - sizeof(struct swapped_fp_tag)); - - ss.u.fields.index = fpu->environ.cs.index; - ss.u.fields.ti = fpu->environ.cs.ti; - ss.u.fields.rpl = fpu->environ.cs.rpl; -- ss.u.half = NXSwapShort(ss.u.half); -+ ss.u.half = OSSwapInt16(ss.u.half); - memcpy(&(fpu->environ.cs), &ss, - sizeof(struct swapped_sel)); - - ss.u.fields.index = fpu->environ.ds.index; - ss.u.fields.ti = fpu->environ.ds.ti; - ss.u.fields.rpl = fpu->environ.ds.rpl; -- ss.u.half = NXSwapShort(ss.u.half); -+ ss.u.half = OSSwapInt16(ss.u.half); - memcpy(&(fpu->environ.cs), &ss, - sizeof(struct swapped_sel)); - - for(i = 0; i < 8; i++){ -- sfpd.mant = NXSwapShort(fpu->stack.ST[i].mant); -- sfpd.mant1 = NXSwapShort(fpu->stack.ST[i].mant1); -- sfpd.mant2 = NXSwapShort(fpu->stack.ST[i].mant2); -- sfpd.mant3 = NXSwapShort(fpu->stack.ST[i].mant3); -+ sfpd.mant = OSSwapInt16(fpu->stack.ST[i].mant); -+ sfpd.mant1 = OSSwapInt16(fpu->stack.ST[i].mant1); -+ sfpd.mant2 = OSSwapInt16(fpu->stack.ST[i].mant2); -+ sfpd.mant3 = OSSwapInt16(fpu->stack.ST[i].mant3); - sfpd.u.fields.exp = fpu->stack.ST[i].exp; - sfpd.u.fields.sign = fpu->stack.ST[i].sign; -- sfpd.u.half = NXSwapShort(sfpd.u.half); -+ sfpd.u.half = OSSwapInt16(sfpd.u.half); - memcpy(&(fpu->stack.ST[i]), &sfpd, - sizeof(struct swapped_fp_data_reg)); - } -@@ -857,19 +866,19 @@ - wrtflt :1, - prot :1; - } pgfault; -- unsigned long word; -+ uint32_t word; - } u; - } sec; -- unsigned long word; -+ uint32_t word; - enum NXByteOrder host_byte_sex; - - host_byte_sex = NXHostByteOrder(); - -- exc->trapno = NXSwapLong(exc->trapno); -+ exc->trapno = OSSwapInt32(exc->trapno); - if(exc->trapno == 14){ - if(target_byte_sex == host_byte_sex){ - memcpy(&sec, &(exc->err), sizeof(struct swapped_err_code)); -- sec.u.word = NXSwapLong(sec.u.word); -+ sec.u.word = OSSwapInt32(sec.u.word); - exc->err.pgfault.user = sec.u.pgfault.user; - exc->err.pgfault.wrtflt = sec.u.pgfault.wrtflt; - exc->err.pgfault.prot = sec.u.pgfault.prot; -@@ -878,16 +887,16 @@ - sec.u.pgfault.prot = exc->err.pgfault.prot; - sec.u.pgfault.wrtflt = exc->err.pgfault.wrtflt; - sec.u.pgfault.user = exc->err.pgfault.user; -- sec.u.word = NXSwapLong(sec.u.word); -+ sec.u.word = OSSwapInt32(sec.u.word); - memcpy(&(exc->err), &sec, sizeof(struct swapped_err_code)); - } - } - else{ - if(target_byte_sex == host_byte_sex){ - memcpy(&sec, &(exc->err), sizeof(struct swapped_err_code)); -- sec.u.word = NXSwapLong(sec.u.word); -+ sec.u.word = OSSwapInt32(sec.u.word); - word = sec.u.normal.index; -- exc->err.normal.index = NXSwapLong(word); -+ exc->err.normal.index = OSSwapInt32(word); - exc->err.normal.tbl = sec.u.normal.tbl; - exc->err.normal.ext = sec.u.normal.ext; - } -@@ -895,8 +904,8 @@ - sec.u.normal.ext = exc->err.normal.ext; - sec.u.normal.tbl = exc->err.normal.tbl; - word = exc->err.normal.index; -- sec.u.normal.index = NXSwapLong(word); -- sec.u.word = NXSwapLong(sec.u.word); -+ sec.u.normal.index = OSSwapInt32(word); -+ sec.u.word = OSSwapInt32(sec.u.word); - memcpy(&(exc->err), &sec, sizeof(struct swapped_err_code)); - } - } -@@ -907,7 +916,7 @@ - i386_thread_cthreadstate_t *user, - enum NXByteOrder target_byte_sex) - { -- user->self = NXSwapLong(user->self); -+ user->self = OSSwapInt32(user->self); - } - #endif /* i386_THREAD_STATE == -1 */ - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/libmacho/i860_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/i860_swap.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/i860_swap.c 2013-09-03 14:14:29.729781596 +0000 -@@ -28,34 +28,34 @@ - struct i860_thread_state_regs *cpu, - enum NXByteOrder target_byte_sex) - { -- unsigned long i; -+ int i; - - for(i = 0; i < 31; i++) -- cpu->ireg[i] = NXSwapLong(cpu->ireg[i]); -+ cpu->ireg[i] = OSSwapInt32(cpu->ireg[i]); - for(i = 0; i < 30; i++) -- cpu->freg[i] = NXSwapLong(cpu->freg[i]); -- cpu->psr = NXSwapLong(cpu->psr); -- cpu->epsr = NXSwapLong(cpu->epsr); -- cpu->db = NXSwapLong(cpu->db); -- cpu->pc = NXSwapLong(cpu->pc); -- cpu->_padding_ = NXSwapLong(cpu->_padding_); -- cpu->Mres3 = NXSwapDouble(cpu->Mres3); -- cpu->Ares3 = NXSwapDouble(cpu->Ares3); -- cpu->Mres2 = NXSwapDouble(cpu->Mres2); -- cpu->Ares2 = NXSwapDouble(cpu->Ares2); -- cpu->Mres1 = NXSwapDouble(cpu->Mres1); -- cpu->Ares1 = NXSwapDouble(cpu->Ares1); -- cpu->Ires1 = NXSwapDouble(cpu->Ires1); -- cpu->Lres3m = NXSwapDouble(cpu->Lres3m); -- cpu->Lres2m = NXSwapDouble(cpu->Lres2m); -- cpu->Lres1m = NXSwapDouble(cpu->Lres1m); -- cpu->KR = NXSwapDouble(cpu->KR); -- cpu->KI = NXSwapDouble(cpu->KI); -- cpu->T = NXSwapDouble(cpu->T); -- cpu->Fsr3 = NXSwapLong(cpu->Fsr3); -- cpu->Fsr2 = NXSwapLong(cpu->Fsr2); -- cpu->Fsr1 = NXSwapLong(cpu->Fsr1); -- cpu->Mergelo32 = NXSwapLong(cpu->Mergelo32); -- cpu->Mergehi32 = NXSwapLong(cpu->Mergehi32); -+ cpu->freg[i] = OSSwapInt32(cpu->freg[i]); -+ cpu->psr = OSSwapInt32(cpu->psr); -+ cpu->epsr = OSSwapInt32(cpu->epsr); -+ cpu->db = OSSwapInt32(cpu->db); -+ cpu->pc = OSSwapInt32(cpu->pc); -+ cpu->_padding_ = OSSwapInt32(cpu->_padding_); -+ cpu->Mres3 = OSSwapInt64(cpu->Mres3); -+ cpu->Ares3 = OSSwapInt64(cpu->Ares3); -+ cpu->Mres2 = OSSwapInt64(cpu->Mres2); -+ cpu->Ares2 = OSSwapInt64(cpu->Ares2); -+ cpu->Mres1 = OSSwapInt64(cpu->Mres1); -+ cpu->Ares1 = OSSwapInt64(cpu->Ares1); -+ cpu->Ires1 = OSSwapInt64(cpu->Ires1); -+ cpu->Lres3m = OSSwapInt64(cpu->Lres3m); -+ cpu->Lres2m = OSSwapInt64(cpu->Lres2m); -+ cpu->Lres1m = OSSwapInt64(cpu->Lres1m); -+ cpu->KR = OSSwapInt64(cpu->KR); -+ cpu->KI = OSSwapInt64(cpu->KI); -+ cpu->T = OSSwapInt64(cpu->T); -+ cpu->Fsr3 = OSSwapInt32(cpu->Fsr3); -+ cpu->Fsr2 = OSSwapInt32(cpu->Fsr2); -+ cpu->Fsr1 = OSSwapInt32(cpu->Fsr1); -+ cpu->Mergelo32 = OSSwapInt32(cpu->Mergelo32); -+ cpu->Mergehi32 = OSSwapInt32(cpu->Mergehi32); - } - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/libmacho/m68k_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/m68k_swap.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/m68k_swap.c 2013-09-03 14:14:46.537783795 +0000 -@@ -28,15 +28,15 @@ - struct m68k_thread_state_regs *cpu, - enum NXByteOrder target_byte_sex) - { -- unsigned long i; -+ uint32_t i; - - for(i = 0; i < 8; i++) -- cpu->dreg[i] = NXSwapLong(cpu->dreg[i]); -+ cpu->dreg[i] = OSSwapInt32(cpu->dreg[i]); - for(i = 0; i < 8; i++) -- cpu->areg[i] = NXSwapLong(cpu->areg[i]); -- cpu->pad0 = NXSwapShort(cpu->pad0); -- cpu->sr = NXSwapShort(cpu->sr); -- cpu->pc = NXSwapLong(cpu->pc); -+ cpu->areg[i] = OSSwapInt32(cpu->areg[i]); -+ cpu->pad0 = OSSwapInt16(cpu->pad0); -+ cpu->sr = OSSwapInt16(cpu->sr); -+ cpu->pc = OSSwapInt32(cpu->pc); - } - - void -@@ -44,18 +44,18 @@ - struct m68k_thread_state_68882 *fpu, - enum NXByteOrder target_byte_sex) - { -- unsigned long i, tmp; -+ uint32_t i, tmp; - - for(i = 0; i < 8; i++){ -- tmp = NXSwapLong(fpu->regs[i].fp[0]); -- fpu->regs[i].fp[1] = NXSwapLong(fpu->regs[i].fp[1]); -- fpu->regs[i].fp[0] = NXSwapLong(fpu->regs[i].fp[2]); -+ tmp = OSSwapInt32(fpu->regs[i].fp[0]); -+ fpu->regs[i].fp[1] = OSSwapInt32(fpu->regs[i].fp[1]); -+ fpu->regs[i].fp[0] = OSSwapInt32(fpu->regs[i].fp[2]); - fpu->regs[i].fp[2] = tmp; - } -- fpu->cr = NXSwapLong(fpu->cr); -- fpu->sr = NXSwapLong(fpu->sr); -- fpu->iar = NXSwapLong(fpu->iar); -- fpu->state = NXSwapLong(fpu->state); -+ fpu->cr = OSSwapInt32(fpu->cr); -+ fpu->sr = OSSwapInt32(fpu->sr); -+ fpu->iar = OSSwapInt32(fpu->iar); -+ fpu->state = OSSwapInt32(fpu->state); - } - - void -@@ -63,6 +63,6 @@ - struct m68k_thread_state_user_reg *user_reg, - enum NXByteOrder target_byte_sex) - { -- user_reg->user_reg = NXSwapLong(user_reg->user_reg); -+ user_reg->user_reg = OSSwapInt32(user_reg->user_reg); - } - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/libmacho/m88k_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/m88k_swap.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/m88k_swap.c 2013-09-03 14:15:30.353782975 +0000 -@@ -30,40 +30,40 @@ - m88k_thread_state_grf_t *cpu, - enum NXByteOrder target_byte_sex) - { -- cpu->r1 = NXSwapLong(cpu->r1); -- cpu->r2 = NXSwapLong(cpu->r2); -- cpu->r3 = NXSwapLong(cpu->r3); -- cpu->r4 = NXSwapLong(cpu->r4); -- cpu->r5 = NXSwapLong(cpu->r5); -- cpu->r6 = NXSwapLong(cpu->r6); -- cpu->r7 = NXSwapLong(cpu->r7); -- cpu->r8 = NXSwapLong(cpu->r8); -- cpu->r9 = NXSwapLong(cpu->r9); -- cpu->r10 = NXSwapLong(cpu->r10); -- cpu->r11 = NXSwapLong(cpu->r11); -- cpu->r12 = NXSwapLong(cpu->r12); -- cpu->r13 = NXSwapLong(cpu->r13); -- cpu->r14 = NXSwapLong(cpu->r14); -- cpu->r15 = NXSwapLong(cpu->r15); -- cpu->r16 = NXSwapLong(cpu->r16); -- cpu->r17 = NXSwapLong(cpu->r17); -- cpu->r18 = NXSwapLong(cpu->r18); -- cpu->r19 = NXSwapLong(cpu->r19); -- cpu->r20 = NXSwapLong(cpu->r20); -- cpu->r21 = NXSwapLong(cpu->r21); -- cpu->r22 = NXSwapLong(cpu->r22); -- cpu->r23 = NXSwapLong(cpu->r23); -- cpu->r24 = NXSwapLong(cpu->r24); -- cpu->r25 = NXSwapLong(cpu->r25); -- cpu->r26 = NXSwapLong(cpu->r26); -- cpu->r27 = NXSwapLong(cpu->r27); -- cpu->r28 = NXSwapLong(cpu->r28); -- cpu->r29 = NXSwapLong(cpu->r29); -- cpu->r30 = NXSwapLong(cpu->r30); -- cpu->r31 = NXSwapLong(cpu->r31); -- cpu->xip = NXSwapLong(cpu->xip); -- cpu->xip_in_bd = NXSwapLong(cpu->xip_in_bd); -- cpu->nip = NXSwapLong(cpu->nip); -+ cpu->r1 = OSSwapInt32(cpu->r1); -+ cpu->r2 = OSSwapInt32(cpu->r2); -+ cpu->r3 = OSSwapInt32(cpu->r3); -+ cpu->r4 = OSSwapInt32(cpu->r4); -+ cpu->r5 = OSSwapInt32(cpu->r5); -+ cpu->r6 = OSSwapInt32(cpu->r6); -+ cpu->r7 = OSSwapInt32(cpu->r7); -+ cpu->r8 = OSSwapInt32(cpu->r8); -+ cpu->r9 = OSSwapInt32(cpu->r9); -+ cpu->r10 = OSSwapInt32(cpu->r10); -+ cpu->r11 = OSSwapInt32(cpu->r11); -+ cpu->r12 = OSSwapInt32(cpu->r12); -+ cpu->r13 = OSSwapInt32(cpu->r13); -+ cpu->r14 = OSSwapInt32(cpu->r14); -+ cpu->r15 = OSSwapInt32(cpu->r15); -+ cpu->r16 = OSSwapInt32(cpu->r16); -+ cpu->r17 = OSSwapInt32(cpu->r17); -+ cpu->r18 = OSSwapInt32(cpu->r18); -+ cpu->r19 = OSSwapInt32(cpu->r19); -+ cpu->r20 = OSSwapInt32(cpu->r20); -+ cpu->r21 = OSSwapInt32(cpu->r21); -+ cpu->r22 = OSSwapInt32(cpu->r22); -+ cpu->r23 = OSSwapInt32(cpu->r23); -+ cpu->r24 = OSSwapInt32(cpu->r24); -+ cpu->r25 = OSSwapInt32(cpu->r25); -+ cpu->r26 = OSSwapInt32(cpu->r26); -+ cpu->r27 = OSSwapInt32(cpu->r27); -+ cpu->r28 = OSSwapInt32(cpu->r28); -+ cpu->r29 = OSSwapInt32(cpu->r29); -+ cpu->r30 = OSSwapInt32(cpu->r30); -+ cpu->r31 = OSSwapInt32(cpu->r31); -+ cpu->xip = OSSwapInt32(cpu->xip); -+ cpu->xip_in_bd = OSSwapInt32(cpu->xip_in_bd); -+ cpu->nip = OSSwapInt32(cpu->nip); - } - - void -@@ -85,7 +85,7 @@ - unsigned xmod:BIT_WIDTH(16); - unsigned :BITS_WIDTH(31,17); - } fields; -- unsigned long word; -+ uint32_t word; - } u; - } ssr; - struct swapped_m88k_fpcr { -@@ -100,140 +100,140 @@ - m88k_fpcr_rm_t rm:BITS_WIDTH(15,14); - unsigned :BITS_WIDTH(31,16); - } fields; -- unsigned long word; -+ uint32_t word; - } u; - } scr; - - host_byte_sex = NXHostByteOrder(); - -- fpu->x1.x[0] = NXSwapLong(fpu->x1.x[0]); -- fpu->x1.x[1] = NXSwapLong(fpu->x1.x[1]); -- fpu->x1.x[2] = NXSwapLong(fpu->x1.x[2]); -- fpu->x1.x[3] = NXSwapLong(fpu->x1.x[3]); -- fpu->x2.x[0] = NXSwapLong(fpu->x2.x[0]); -- fpu->x2.x[1] = NXSwapLong(fpu->x2.x[1]); -- fpu->x2.x[2] = NXSwapLong(fpu->x2.x[2]); -- fpu->x2.x[3] = NXSwapLong(fpu->x2.x[3]); -- fpu->x3.x[0] = NXSwapLong(fpu->x3.x[0]); -- fpu->x3.x[1] = NXSwapLong(fpu->x3.x[1]); -- fpu->x3.x[2] = NXSwapLong(fpu->x3.x[2]); -- fpu->x3.x[3] = NXSwapLong(fpu->x3.x[3]); -- fpu->x4.x[0] = NXSwapLong(fpu->x4.x[0]); -- fpu->x4.x[1] = NXSwapLong(fpu->x4.x[1]); -- fpu->x4.x[2] = NXSwapLong(fpu->x4.x[2]); -- fpu->x4.x[3] = NXSwapLong(fpu->x4.x[3]); -- fpu->x5.x[0] = NXSwapLong(fpu->x5.x[0]); -- fpu->x5.x[1] = NXSwapLong(fpu->x5.x[1]); -- fpu->x5.x[2] = NXSwapLong(fpu->x5.x[2]); -- fpu->x5.x[3] = NXSwapLong(fpu->x5.x[3]); -- fpu->x6.x[0] = NXSwapLong(fpu->x6.x[0]); -- fpu->x6.x[1] = NXSwapLong(fpu->x6.x[1]); -- fpu->x6.x[2] = NXSwapLong(fpu->x6.x[2]); -- fpu->x6.x[3] = NXSwapLong(fpu->x6.x[3]); -- fpu->x7.x[0] = NXSwapLong(fpu->x7.x[0]); -- fpu->x7.x[1] = NXSwapLong(fpu->x7.x[1]); -- fpu->x7.x[2] = NXSwapLong(fpu->x7.x[2]); -- fpu->x7.x[3] = NXSwapLong(fpu->x7.x[3]); -- fpu->x8.x[0] = NXSwapLong(fpu->x8.x[0]); -- fpu->x8.x[1] = NXSwapLong(fpu->x8.x[1]); -- fpu->x8.x[2] = NXSwapLong(fpu->x8.x[2]); -- fpu->x8.x[3] = NXSwapLong(fpu->x8.x[3]); -- fpu->x9.x[0] = NXSwapLong(fpu->x9.x[0]); -- fpu->x9.x[1] = NXSwapLong(fpu->x9.x[1]); -- fpu->x9.x[2] = NXSwapLong(fpu->x9.x[2]); -- fpu->x9.x[3] = NXSwapLong(fpu->x9.x[3]); -- fpu->x10.x[0] = NXSwapLong(fpu->x10.x[0]); -- fpu->x10.x[1] = NXSwapLong(fpu->x10.x[1]); -- fpu->x10.x[2] = NXSwapLong(fpu->x10.x[2]); -- fpu->x10.x[3] = NXSwapLong(fpu->x10.x[3]); -- fpu->x11.x[0] = NXSwapLong(fpu->x11.x[0]); -- fpu->x11.x[1] = NXSwapLong(fpu->x11.x[1]); -- fpu->x11.x[2] = NXSwapLong(fpu->x11.x[2]); -- fpu->x11.x[3] = NXSwapLong(fpu->x11.x[3]); -- fpu->x12.x[0] = NXSwapLong(fpu->x12.x[0]); -- fpu->x12.x[1] = NXSwapLong(fpu->x12.x[1]); -- fpu->x12.x[2] = NXSwapLong(fpu->x12.x[2]); -- fpu->x12.x[3] = NXSwapLong(fpu->x12.x[3]); -- fpu->x13.x[0] = NXSwapLong(fpu->x13.x[0]); -- fpu->x13.x[1] = NXSwapLong(fpu->x13.x[1]); -- fpu->x13.x[2] = NXSwapLong(fpu->x13.x[2]); -- fpu->x13.x[3] = NXSwapLong(fpu->x13.x[3]); -- fpu->x14.x[0] = NXSwapLong(fpu->x14.x[0]); -- fpu->x14.x[1] = NXSwapLong(fpu->x14.x[1]); -- fpu->x14.x[2] = NXSwapLong(fpu->x14.x[2]); -- fpu->x14.x[3] = NXSwapLong(fpu->x14.x[3]); -- fpu->x15.x[0] = NXSwapLong(fpu->x15.x[0]); -- fpu->x15.x[1] = NXSwapLong(fpu->x15.x[1]); -- fpu->x15.x[2] = NXSwapLong(fpu->x15.x[2]); -- fpu->x15.x[3] = NXSwapLong(fpu->x15.x[3]); -- fpu->x16.x[0] = NXSwapLong(fpu->x16.x[0]); -- fpu->x16.x[1] = NXSwapLong(fpu->x16.x[1]); -- fpu->x16.x[2] = NXSwapLong(fpu->x16.x[2]); -- fpu->x16.x[3] = NXSwapLong(fpu->x16.x[3]); -- fpu->x17.x[0] = NXSwapLong(fpu->x17.x[0]); -- fpu->x17.x[1] = NXSwapLong(fpu->x17.x[1]); -- fpu->x17.x[2] = NXSwapLong(fpu->x17.x[2]); -- fpu->x17.x[3] = NXSwapLong(fpu->x17.x[3]); -- fpu->x18.x[0] = NXSwapLong(fpu->x18.x[0]); -- fpu->x18.x[1] = NXSwapLong(fpu->x18.x[1]); -- fpu->x18.x[2] = NXSwapLong(fpu->x18.x[2]); -- fpu->x18.x[3] = NXSwapLong(fpu->x18.x[3]); -- fpu->x19.x[0] = NXSwapLong(fpu->x19.x[0]); -- fpu->x19.x[1] = NXSwapLong(fpu->x19.x[1]); -- fpu->x19.x[2] = NXSwapLong(fpu->x19.x[2]); -- fpu->x19.x[3] = NXSwapLong(fpu->x19.x[3]); -- fpu->x20.x[0] = NXSwapLong(fpu->x20.x[0]); -- fpu->x20.x[1] = NXSwapLong(fpu->x20.x[1]); -- fpu->x20.x[2] = NXSwapLong(fpu->x20.x[2]); -- fpu->x20.x[3] = NXSwapLong(fpu->x20.x[3]); -- fpu->x21.x[0] = NXSwapLong(fpu->x21.x[0]); -- fpu->x21.x[1] = NXSwapLong(fpu->x21.x[1]); -- fpu->x21.x[2] = NXSwapLong(fpu->x21.x[2]); -- fpu->x21.x[3] = NXSwapLong(fpu->x21.x[3]); -- fpu->x22.x[0] = NXSwapLong(fpu->x22.x[0]); -- fpu->x22.x[1] = NXSwapLong(fpu->x22.x[1]); -- fpu->x22.x[2] = NXSwapLong(fpu->x22.x[2]); -- fpu->x22.x[3] = NXSwapLong(fpu->x22.x[3]); -- fpu->x23.x[0] = NXSwapLong(fpu->x23.x[0]); -- fpu->x23.x[1] = NXSwapLong(fpu->x23.x[1]); -- fpu->x23.x[2] = NXSwapLong(fpu->x23.x[2]); -- fpu->x23.x[3] = NXSwapLong(fpu->x23.x[3]); -- fpu->x24.x[0] = NXSwapLong(fpu->x24.x[0]); -- fpu->x24.x[1] = NXSwapLong(fpu->x24.x[1]); -- fpu->x24.x[2] = NXSwapLong(fpu->x24.x[2]); -- fpu->x24.x[3] = NXSwapLong(fpu->x24.x[3]); -- fpu->x25.x[0] = NXSwapLong(fpu->x25.x[0]); -- fpu->x25.x[1] = NXSwapLong(fpu->x25.x[1]); -- fpu->x25.x[2] = NXSwapLong(fpu->x25.x[2]); -- fpu->x25.x[3] = NXSwapLong(fpu->x25.x[3]); -- fpu->x26.x[0] = NXSwapLong(fpu->x26.x[0]); -- fpu->x26.x[1] = NXSwapLong(fpu->x26.x[1]); -- fpu->x26.x[2] = NXSwapLong(fpu->x26.x[2]); -- fpu->x26.x[3] = NXSwapLong(fpu->x26.x[3]); -- fpu->x27.x[0] = NXSwapLong(fpu->x27.x[0]); -- fpu->x27.x[1] = NXSwapLong(fpu->x27.x[1]); -- fpu->x27.x[2] = NXSwapLong(fpu->x27.x[2]); -- fpu->x27.x[3] = NXSwapLong(fpu->x27.x[3]); -- fpu->x28.x[0] = NXSwapLong(fpu->x28.x[0]); -- fpu->x28.x[1] = NXSwapLong(fpu->x28.x[1]); -- fpu->x28.x[2] = NXSwapLong(fpu->x28.x[2]); -- fpu->x28.x[3] = NXSwapLong(fpu->x28.x[3]); -- fpu->x29.x[0] = NXSwapLong(fpu->x29.x[0]); -- fpu->x29.x[1] = NXSwapLong(fpu->x29.x[1]); -- fpu->x29.x[2] = NXSwapLong(fpu->x29.x[2]); -- fpu->x29.x[3] = NXSwapLong(fpu->x29.x[3]); -- fpu->x30.x[0] = NXSwapLong(fpu->x30.x[0]); -- fpu->x30.x[1] = NXSwapLong(fpu->x30.x[1]); -- fpu->x30.x[2] = NXSwapLong(fpu->x30.x[2]); -- fpu->x30.x[3] = NXSwapLong(fpu->x30.x[3]); -- fpu->x31.x[0] = NXSwapLong(fpu->x31.x[0]); -- fpu->x31.x[1] = NXSwapLong(fpu->x31.x[1]); -- fpu->x31.x[2] = NXSwapLong(fpu->x31.x[2]); -- fpu->x31.x[3] = NXSwapLong(fpu->x31.x[3]); -+ fpu->x1.x[0] = OSSwapInt32(fpu->x1.x[0]); -+ fpu->x1.x[1] = OSSwapInt32(fpu->x1.x[1]); -+ fpu->x1.x[2] = OSSwapInt32(fpu->x1.x[2]); -+ fpu->x1.x[3] = OSSwapInt32(fpu->x1.x[3]); -+ fpu->x2.x[0] = OSSwapInt32(fpu->x2.x[0]); -+ fpu->x2.x[1] = OSSwapInt32(fpu->x2.x[1]); -+ fpu->x2.x[2] = OSSwapInt32(fpu->x2.x[2]); -+ fpu->x2.x[3] = OSSwapInt32(fpu->x2.x[3]); -+ fpu->x3.x[0] = OSSwapInt32(fpu->x3.x[0]); -+ fpu->x3.x[1] = OSSwapInt32(fpu->x3.x[1]); -+ fpu->x3.x[2] = OSSwapInt32(fpu->x3.x[2]); -+ fpu->x3.x[3] = OSSwapInt32(fpu->x3.x[3]); -+ fpu->x4.x[0] = OSSwapInt32(fpu->x4.x[0]); -+ fpu->x4.x[1] = OSSwapInt32(fpu->x4.x[1]); -+ fpu->x4.x[2] = OSSwapInt32(fpu->x4.x[2]); -+ fpu->x4.x[3] = OSSwapInt32(fpu->x4.x[3]); -+ fpu->x5.x[0] = OSSwapInt32(fpu->x5.x[0]); -+ fpu->x5.x[1] = OSSwapInt32(fpu->x5.x[1]); -+ fpu->x5.x[2] = OSSwapInt32(fpu->x5.x[2]); -+ fpu->x5.x[3] = OSSwapInt32(fpu->x5.x[3]); -+ fpu->x6.x[0] = OSSwapInt32(fpu->x6.x[0]); -+ fpu->x6.x[1] = OSSwapInt32(fpu->x6.x[1]); -+ fpu->x6.x[2] = OSSwapInt32(fpu->x6.x[2]); -+ fpu->x6.x[3] = OSSwapInt32(fpu->x6.x[3]); -+ fpu->x7.x[0] = OSSwapInt32(fpu->x7.x[0]); -+ fpu->x7.x[1] = OSSwapInt32(fpu->x7.x[1]); -+ fpu->x7.x[2] = OSSwapInt32(fpu->x7.x[2]); -+ fpu->x7.x[3] = OSSwapInt32(fpu->x7.x[3]); -+ fpu->x8.x[0] = OSSwapInt32(fpu->x8.x[0]); -+ fpu->x8.x[1] = OSSwapInt32(fpu->x8.x[1]); -+ fpu->x8.x[2] = OSSwapInt32(fpu->x8.x[2]); -+ fpu->x8.x[3] = OSSwapInt32(fpu->x8.x[3]); -+ fpu->x9.x[0] = OSSwapInt32(fpu->x9.x[0]); -+ fpu->x9.x[1] = OSSwapInt32(fpu->x9.x[1]); -+ fpu->x9.x[2] = OSSwapInt32(fpu->x9.x[2]); -+ fpu->x9.x[3] = OSSwapInt32(fpu->x9.x[3]); -+ fpu->x10.x[0] = OSSwapInt32(fpu->x10.x[0]); -+ fpu->x10.x[1] = OSSwapInt32(fpu->x10.x[1]); -+ fpu->x10.x[2] = OSSwapInt32(fpu->x10.x[2]); -+ fpu->x10.x[3] = OSSwapInt32(fpu->x10.x[3]); -+ fpu->x11.x[0] = OSSwapInt32(fpu->x11.x[0]); -+ fpu->x11.x[1] = OSSwapInt32(fpu->x11.x[1]); -+ fpu->x11.x[2] = OSSwapInt32(fpu->x11.x[2]); -+ fpu->x11.x[3] = OSSwapInt32(fpu->x11.x[3]); -+ fpu->x12.x[0] = OSSwapInt32(fpu->x12.x[0]); -+ fpu->x12.x[1] = OSSwapInt32(fpu->x12.x[1]); -+ fpu->x12.x[2] = OSSwapInt32(fpu->x12.x[2]); -+ fpu->x12.x[3] = OSSwapInt32(fpu->x12.x[3]); -+ fpu->x13.x[0] = OSSwapInt32(fpu->x13.x[0]); -+ fpu->x13.x[1] = OSSwapInt32(fpu->x13.x[1]); -+ fpu->x13.x[2] = OSSwapInt32(fpu->x13.x[2]); -+ fpu->x13.x[3] = OSSwapInt32(fpu->x13.x[3]); -+ fpu->x14.x[0] = OSSwapInt32(fpu->x14.x[0]); -+ fpu->x14.x[1] = OSSwapInt32(fpu->x14.x[1]); -+ fpu->x14.x[2] = OSSwapInt32(fpu->x14.x[2]); -+ fpu->x14.x[3] = OSSwapInt32(fpu->x14.x[3]); -+ fpu->x15.x[0] = OSSwapInt32(fpu->x15.x[0]); -+ fpu->x15.x[1] = OSSwapInt32(fpu->x15.x[1]); -+ fpu->x15.x[2] = OSSwapInt32(fpu->x15.x[2]); -+ fpu->x15.x[3] = OSSwapInt32(fpu->x15.x[3]); -+ fpu->x16.x[0] = OSSwapInt32(fpu->x16.x[0]); -+ fpu->x16.x[1] = OSSwapInt32(fpu->x16.x[1]); -+ fpu->x16.x[2] = OSSwapInt32(fpu->x16.x[2]); -+ fpu->x16.x[3] = OSSwapInt32(fpu->x16.x[3]); -+ fpu->x17.x[0] = OSSwapInt32(fpu->x17.x[0]); -+ fpu->x17.x[1] = OSSwapInt32(fpu->x17.x[1]); -+ fpu->x17.x[2] = OSSwapInt32(fpu->x17.x[2]); -+ fpu->x17.x[3] = OSSwapInt32(fpu->x17.x[3]); -+ fpu->x18.x[0] = OSSwapInt32(fpu->x18.x[0]); -+ fpu->x18.x[1] = OSSwapInt32(fpu->x18.x[1]); -+ fpu->x18.x[2] = OSSwapInt32(fpu->x18.x[2]); -+ fpu->x18.x[3] = OSSwapInt32(fpu->x18.x[3]); -+ fpu->x19.x[0] = OSSwapInt32(fpu->x19.x[0]); -+ fpu->x19.x[1] = OSSwapInt32(fpu->x19.x[1]); -+ fpu->x19.x[2] = OSSwapInt32(fpu->x19.x[2]); -+ fpu->x19.x[3] = OSSwapInt32(fpu->x19.x[3]); -+ fpu->x20.x[0] = OSSwapInt32(fpu->x20.x[0]); -+ fpu->x20.x[1] = OSSwapInt32(fpu->x20.x[1]); -+ fpu->x20.x[2] = OSSwapInt32(fpu->x20.x[2]); -+ fpu->x20.x[3] = OSSwapInt32(fpu->x20.x[3]); -+ fpu->x21.x[0] = OSSwapInt32(fpu->x21.x[0]); -+ fpu->x21.x[1] = OSSwapInt32(fpu->x21.x[1]); -+ fpu->x21.x[2] = OSSwapInt32(fpu->x21.x[2]); -+ fpu->x21.x[3] = OSSwapInt32(fpu->x21.x[3]); -+ fpu->x22.x[0] = OSSwapInt32(fpu->x22.x[0]); -+ fpu->x22.x[1] = OSSwapInt32(fpu->x22.x[1]); -+ fpu->x22.x[2] = OSSwapInt32(fpu->x22.x[2]); -+ fpu->x22.x[3] = OSSwapInt32(fpu->x22.x[3]); -+ fpu->x23.x[0] = OSSwapInt32(fpu->x23.x[0]); -+ fpu->x23.x[1] = OSSwapInt32(fpu->x23.x[1]); -+ fpu->x23.x[2] = OSSwapInt32(fpu->x23.x[2]); -+ fpu->x23.x[3] = OSSwapInt32(fpu->x23.x[3]); -+ fpu->x24.x[0] = OSSwapInt32(fpu->x24.x[0]); -+ fpu->x24.x[1] = OSSwapInt32(fpu->x24.x[1]); -+ fpu->x24.x[2] = OSSwapInt32(fpu->x24.x[2]); -+ fpu->x24.x[3] = OSSwapInt32(fpu->x24.x[3]); -+ fpu->x25.x[0] = OSSwapInt32(fpu->x25.x[0]); -+ fpu->x25.x[1] = OSSwapInt32(fpu->x25.x[1]); -+ fpu->x25.x[2] = OSSwapInt32(fpu->x25.x[2]); -+ fpu->x25.x[3] = OSSwapInt32(fpu->x25.x[3]); -+ fpu->x26.x[0] = OSSwapInt32(fpu->x26.x[0]); -+ fpu->x26.x[1] = OSSwapInt32(fpu->x26.x[1]); -+ fpu->x26.x[2] = OSSwapInt32(fpu->x26.x[2]); -+ fpu->x26.x[3] = OSSwapInt32(fpu->x26.x[3]); -+ fpu->x27.x[0] = OSSwapInt32(fpu->x27.x[0]); -+ fpu->x27.x[1] = OSSwapInt32(fpu->x27.x[1]); -+ fpu->x27.x[2] = OSSwapInt32(fpu->x27.x[2]); -+ fpu->x27.x[3] = OSSwapInt32(fpu->x27.x[3]); -+ fpu->x28.x[0] = OSSwapInt32(fpu->x28.x[0]); -+ fpu->x28.x[1] = OSSwapInt32(fpu->x28.x[1]); -+ fpu->x28.x[2] = OSSwapInt32(fpu->x28.x[2]); -+ fpu->x28.x[3] = OSSwapInt32(fpu->x28.x[3]); -+ fpu->x29.x[0] = OSSwapInt32(fpu->x29.x[0]); -+ fpu->x29.x[1] = OSSwapInt32(fpu->x29.x[1]); -+ fpu->x29.x[2] = OSSwapInt32(fpu->x29.x[2]); -+ fpu->x29.x[3] = OSSwapInt32(fpu->x29.x[3]); -+ fpu->x30.x[0] = OSSwapInt32(fpu->x30.x[0]); -+ fpu->x30.x[1] = OSSwapInt32(fpu->x30.x[1]); -+ fpu->x30.x[2] = OSSwapInt32(fpu->x30.x[2]); -+ fpu->x30.x[3] = OSSwapInt32(fpu->x30.x[3]); -+ fpu->x31.x[0] = OSSwapInt32(fpu->x31.x[0]); -+ fpu->x31.x[1] = OSSwapInt32(fpu->x31.x[1]); -+ fpu->x31.x[2] = OSSwapInt32(fpu->x31.x[2]); -+ fpu->x31.x[3] = OSSwapInt32(fpu->x31.x[3]); - - if(target_byte_sex == host_byte_sex){ - memcpy(&ssr, &(fpu->fpsr), sizeof(struct swapped_m88k_fpsr)); -- ssr.u.word = NXSwapLong(ssr.u.word); -+ ssr.u.word = OSSwapInt32(ssr.u.word); - fpu->fpsr.afinx = ssr.u.fields.afinx; - fpu->fpsr.afovf = ssr.u.fields.afovf; - fpu->fpsr.afunf = ssr.u.fields.afunf; -@@ -242,7 +242,7 @@ - fpu->fpsr.xmod = ssr.u.fields.xmod; - - memcpy(&scr, &(fpu->fpcr), sizeof(struct swapped_m88k_fpcr)); -- scr.u.word = NXSwapLong(scr.u.word); -+ scr.u.word = OSSwapInt32(scr.u.word); - fpu->fpcr.efinx = scr.u.fields.efinx; - fpu->fpcr.efovf = scr.u.fields.efovf; - fpu->fpcr.efunf = scr.u.fields.efunf; -@@ -257,7 +257,7 @@ - ssr.u.fields.afdvz = fpu->fpsr.afdvz; - ssr.u.fields.afinv = fpu->fpsr.afinv; - ssr.u.fields.xmod = fpu->fpsr.xmod; -- ssr.u.word = NXSwapLong(ssr.u.word); -+ ssr.u.word = OSSwapInt32(ssr.u.word); - memcpy(&(fpu->fpsr), &ssr, sizeof(struct swapped_m88k_fpsr)); - - scr.u.fields.efinx = fpu->fpcr.efinx; -@@ -266,7 +266,7 @@ - scr.u.fields.efdvz = fpu->fpcr.efdvz; - scr.u.fields.efinv = fpu->fpcr.efinv; - scr.u.fields.rm = fpu->fpcr.rm; -- scr.u.word = NXSwapLong(scr.u.word); -+ scr.u.word = OSSwapInt32(scr.u.word); - memcpy(&(fpu->fpcr), &scr, sizeof(struct swapped_m88k_fpcr)); - } - } -@@ -276,7 +276,7 @@ - m88k_thread_state_user_t *user, - enum NXByteOrder target_byte_sex) - { -- user->user = NXSwapLong(user->user); -+ user->user = OSSwapInt32(user->user); - } - - void -@@ -284,7 +284,7 @@ - m88110_thread_state_impl_t *spu, - enum NXByteOrder target_byte_sex) - { -- unsigned long i; -+ uint32_t i; - enum NXByteOrder host_byte_sex; - - struct swapped_m88110_bp_ctrl { -@@ -297,7 +297,7 @@ - unsigned rw:BIT_WIDTH(28); - unsigned :BITS_WIDTH(31,29); - } fields; -- unsigned long word; -+ uint32_t word; - } u; - } sbpc; - -@@ -318,7 +318,7 @@ - unsigned le:BIT_WIDTH(30); - unsigned supr:BIT_WIDTH(31); - } fields; -- unsigned long word; -+ uint32_t word; - } u; - } spsr; - -@@ -338,7 +338,7 @@ - m88110_iresult_size_t iresult_size:BITS_WIDTH(15,14); - unsigned :BITS_WIDTH(31,16); - } fields; -- unsigned long word; -+ uint32_t word; - } u; - } sfps; - -@@ -346,10 +346,10 @@ - - if(target_byte_sex == host_byte_sex){ - for(i = 0; i < M88110_N_DATA_BP; i++){ -- spu->data_bp[i].addr = NXSwapLong(spu->data_bp[i].addr); -+ spu->data_bp[i].addr = OSSwapInt32(spu->data_bp[i].addr); - memcpy(&sbpc, &(spu->data_bp[i].ctrl), - sizeof(struct swapped_m88110_bp_ctrl)); -- sbpc.u.word = NXSwapLong(sbpc.u.word); -+ sbpc.u.word = OSSwapInt32(sbpc.u.word); - spu->data_bp[i].ctrl.v = sbpc.u.fields.v; - spu->data_bp[i].ctrl.addr_match = sbpc.u.fields.addr_match; - spu->data_bp[i].ctrl.rwm = sbpc.u.fields.rwm; -@@ -357,7 +357,7 @@ - } - - memcpy(&spsr, &(spu->psr), sizeof(struct swap_m88110_psr)); -- spsr.u.word = NXSwapLong(spsr.u.word); -+ spsr.u.word = OSSwapInt32(spsr.u.word); - spu->psr.mxm_dis = spsr.u.fields.mxm_dis; - spu->psr.sfu1dis = spsr.u.fields.sfu1dis; - spu->psr.trace = spsr.u.fields.trace; -@@ -370,7 +370,7 @@ - - memcpy(&sfps, &(spu->fp_trap_status), - sizeof(struct swapped_m88110_fp_trap_status)); -- sfps.u.word = NXSwapLong(sfps.u.word); -+ sfps.u.word = OSSwapInt32(sfps.u.word); - spu->fp_trap_status.efinx = sfps.u.fields.efinx; - spu->fp_trap_status.efovf = sfps.u.fields.efovf; - spu->fp_trap_status.efunf = sfps.u.fields.efunf; -@@ -383,12 +383,12 @@ - } - else{ - for(i = 0; i < M88110_N_DATA_BP; i++){ -- spu->data_bp[i].addr = NXSwapLong(spu->data_bp[i].addr); -+ spu->data_bp[i].addr = OSSwapInt32(spu->data_bp[i].addr); - sbpc.u.fields.v = spu->data_bp[i].ctrl.v; - sbpc.u.fields.addr_match = spu->data_bp[i].ctrl.addr_match; - sbpc.u.fields.rwm = spu->data_bp[i].ctrl.rwm; - sbpc.u.fields.rw = spu->data_bp[i].ctrl.rw; -- sbpc.u.word = NXSwapLong(sbpc.u.word); -+ sbpc.u.word = OSSwapInt32(sbpc.u.word); - memcpy(&(spu->data_bp[i].ctrl), &sbpc, - sizeof(struct swapped_m88110_bp_ctrl)); - } -@@ -402,7 +402,7 @@ - spsr.u.fields.se = spu->psr.se; - spsr.u.fields.le = spu->psr.le; - spsr.u.fields.supr = spu->psr.supr; -- spsr.u.word = NXSwapLong(spsr.u.word); -+ spsr.u.word = OSSwapInt32(spsr.u.word); - memcpy(&(spu->psr), &spsr, sizeof(struct swap_m88110_psr)); - - sfps.u.fields.efinx = spu->fp_trap_status.efinx; -@@ -414,17 +414,17 @@ - sfps.u.fields.unimp = spu->fp_trap_status.unimp; - sfps.u.fields.sfu1_disabled = spu->fp_trap_status.sfu1_disabled; - sfps.u.fields.iresult_size = spu->fp_trap_status.iresult_size; -- sfps.u.word = NXSwapLong(sfps.u.word); -+ sfps.u.word = OSSwapInt32(sfps.u.word); - memcpy(&(spu->fp_trap_status), &sfps, - sizeof(struct swapped_m88110_fp_trap_status)); - } - spu->intermediate_result.x[0] = -- NXSwapLong(spu->intermediate_result.x[0]); -+ OSSwapInt32(spu->intermediate_result.x[0]); - spu->intermediate_result.x[1] = -- NXSwapLong(spu->intermediate_result.x[1]); -+ OSSwapInt32(spu->intermediate_result.x[1]); - spu->intermediate_result.x[2] = -- NXSwapLong(spu->intermediate_result.x[2]); -+ OSSwapInt32(spu->intermediate_result.x[2]); - spu->intermediate_result.x[3] = -- NXSwapLong(spu->intermediate_result.x[3]); -+ OSSwapInt32(spu->intermediate_result.x[3]); - } - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/libmacho/ppc_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/ppc_swap.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/ppc_swap.c 2013-09-03 14:11:11.073788786 +0000 -@@ -79,46 +79,46 @@ - ppc_thread_state_t *cpu, - enum NXByteOrder target_byte_sex) - { -- cpu->srr0 = NXSwapLong(cpu->srr0); -- cpu->srr1 = NXSwapLong(cpu->srr1); -- cpu->r0 = NXSwapLong(cpu->r0); -- cpu->r1 = NXSwapLong(cpu->r1); -- cpu->r2 = NXSwapLong(cpu->r2); -- cpu->r3 = NXSwapLong(cpu->r3); -- cpu->r4 = NXSwapLong(cpu->r4); -- cpu->r5 = NXSwapLong(cpu->r5); -- cpu->r6 = NXSwapLong(cpu->r6); -- cpu->r7 = NXSwapLong(cpu->r7); -- cpu->r8 = NXSwapLong(cpu->r8); -- cpu->r9 = NXSwapLong(cpu->r9); -- cpu->r10 = NXSwapLong(cpu->r10); -- cpu->r11 = NXSwapLong(cpu->r11); -- cpu->r12 = NXSwapLong(cpu->r12); -- cpu->r13 = NXSwapLong(cpu->r13); -- cpu->r14 = NXSwapLong(cpu->r14); -- cpu->r15 = NXSwapLong(cpu->r15); -- cpu->r16 = NXSwapLong(cpu->r16); -- cpu->r17 = NXSwapLong(cpu->r17); -- cpu->r18 = NXSwapLong(cpu->r18); -- cpu->r19 = NXSwapLong(cpu->r19); -- cpu->r20 = NXSwapLong(cpu->r20); -- cpu->r21 = NXSwapLong(cpu->r21); -- cpu->r22 = NXSwapLong(cpu->r22); -- cpu->r23 = NXSwapLong(cpu->r23); -- cpu->r24 = NXSwapLong(cpu->r24); -- cpu->r25 = NXSwapLong(cpu->r25); -- cpu->r26 = NXSwapLong(cpu->r26); -- cpu->r27 = NXSwapLong(cpu->r27); -- cpu->r28 = NXSwapLong(cpu->r28); -- cpu->r29 = NXSwapLong(cpu->r29); -- cpu->r30 = NXSwapLong(cpu->r30); -- cpu->r31 = NXSwapLong(cpu->r31); -- cpu->lr = NXSwapLong(cpu->lr); -- cpu->cr = NXSwapLong(cpu->cr); -- cpu->xer = NXSwapLong(cpu->xer); -- cpu->ctr = NXSwapLong(cpu->ctr); -- cpu->mq = NXSwapLong(cpu->mq); -- cpu->vrsave = NXSwapLong(cpu->vrsave); -+ cpu->srr0 = OSSwapInt32(cpu->srr0); -+ cpu->srr1 = OSSwapInt32(cpu->srr1); -+ cpu->r0 = OSSwapInt32(cpu->r0); -+ cpu->r1 = OSSwapInt32(cpu->r1); -+ cpu->r2 = OSSwapInt32(cpu->r2); -+ cpu->r3 = OSSwapInt32(cpu->r3); -+ cpu->r4 = OSSwapInt32(cpu->r4); -+ cpu->r5 = OSSwapInt32(cpu->r5); -+ cpu->r6 = OSSwapInt32(cpu->r6); -+ cpu->r7 = OSSwapInt32(cpu->r7); -+ cpu->r8 = OSSwapInt32(cpu->r8); -+ cpu->r9 = OSSwapInt32(cpu->r9); -+ cpu->r10 = OSSwapInt32(cpu->r10); -+ cpu->r11 = OSSwapInt32(cpu->r11); -+ cpu->r12 = OSSwapInt32(cpu->r12); -+ cpu->r13 = OSSwapInt32(cpu->r13); -+ cpu->r14 = OSSwapInt32(cpu->r14); -+ cpu->r15 = OSSwapInt32(cpu->r15); -+ cpu->r16 = OSSwapInt32(cpu->r16); -+ cpu->r17 = OSSwapInt32(cpu->r17); -+ cpu->r18 = OSSwapInt32(cpu->r18); -+ cpu->r19 = OSSwapInt32(cpu->r19); -+ cpu->r20 = OSSwapInt32(cpu->r20); -+ cpu->r21 = OSSwapInt32(cpu->r21); -+ cpu->r22 = OSSwapInt32(cpu->r22); -+ cpu->r23 = OSSwapInt32(cpu->r23); -+ cpu->r24 = OSSwapInt32(cpu->r24); -+ cpu->r25 = OSSwapInt32(cpu->r25); -+ cpu->r26 = OSSwapInt32(cpu->r26); -+ cpu->r27 = OSSwapInt32(cpu->r27); -+ cpu->r28 = OSSwapInt32(cpu->r28); -+ cpu->r29 = OSSwapInt32(cpu->r29); -+ cpu->r30 = OSSwapInt32(cpu->r30); -+ cpu->r31 = OSSwapInt32(cpu->r31); -+ cpu->lr = OSSwapInt32(cpu->lr); -+ cpu->cr = OSSwapInt32(cpu->cr); -+ cpu->xer = OSSwapInt32(cpu->xer); -+ cpu->ctr = OSSwapInt32(cpu->ctr); -+ cpu->mq = OSSwapInt32(cpu->mq); -+ cpu->vrsave = OSSwapInt32(cpu->vrsave); - - } - -@@ -127,13 +127,13 @@ - ppc_float_state_t *fpu, - enum NXByteOrder target_byte_sex) - { -- unsigned long i; -+ uint32_t i; - - for(i = 0; i < 32; i++) -- fpu->fpregs[i] = NXSwapDouble(fpu->fpregs[i]); -+ fpu->fpregs[i] = OSSwapInt64(fpu->fpregs[i]); - -- fpu->fpscr_pad = NXSwapLong(fpu->fpscr_pad); -- fpu->fpscr = NXSwapLong(fpu->fpscr); -+ fpu->fpscr_pad = OSSwapInt32(fpu->fpscr_pad); -+ fpu->fpscr = OSSwapInt32(fpu->fpscr); - } - - void -@@ -141,14 +141,14 @@ - ppc_exception_state_t *state, - enum NXByteOrder target_byte_sex) - { -- unsigned long i; -+ uint32_t i; - -- state->dar = NXSwapLong(state->dar); -- state->dsisr = NXSwapLong(state->dsisr); -- state->exception = NXSwapLong(state->exception); -- state->pad0 = NXSwapLong(state->pad0); -+ state->dar = OSSwapInt32(state->dar); -+ state->dsisr = OSSwapInt32(state->dsisr); -+ state->exception = OSSwapInt32(state->exception); -+ state->pad0 = OSSwapInt32(state->pad0); - - for(i = 0; i < 4; i++) -- state->pad1[i] = NXSwapLong(state->pad1[i]); -+ state->pad1[i] = OSSwapInt32(state->pad1[i]); - } - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/libmacho/sparc_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/sparc_swap.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/sparc_swap.c 2013-09-03 13:44:20.233826093 +0000 -@@ -54,29 +54,29 @@ - - host_byte_sex = NXHostByteOrder(); - -- cpu->regs.r_pc = NXSwapLong(cpu->regs.r_pc); -- cpu->regs.r_npc = NXSwapLong(cpu->regs.r_npc); -- cpu->regs.r_y = NXSwapLong(cpu->regs.r_y); -- cpu->regs.r_g1 = NXSwapLong(cpu->regs.r_g1); -- cpu->regs.r_g2 = NXSwapLong(cpu->regs.r_g2); -- cpu->regs.r_g3 = NXSwapLong(cpu->regs.r_g3); -- cpu->regs.r_g4 = NXSwapLong(cpu->regs.r_g4); -- cpu->regs.r_g5 = NXSwapLong(cpu->regs.r_g5); -- cpu->regs.r_g6 = NXSwapLong(cpu->regs.r_g6); -- cpu->regs.r_g7 = NXSwapLong(cpu->regs.r_g7); -- cpu->regs.r_o0 = NXSwapLong(cpu->regs.r_o0); -- cpu->regs.r_o1 = NXSwapLong(cpu->regs.r_o1); -- cpu->regs.r_o2 = NXSwapLong(cpu->regs.r_o2); -- cpu->regs.r_o3 = NXSwapLong(cpu->regs.r_o3); -- cpu->regs.r_o4 = NXSwapLong(cpu->regs.r_o4); -- cpu->regs.r_o5 = NXSwapLong(cpu->regs.r_o5); -- cpu->regs.r_o6 = NXSwapLong(cpu->regs.r_o6); -- cpu->regs.r_o7 = NXSwapLong(cpu->regs.r_o7); -+ cpu->regs.r_pc = OSSwapInt32(cpu->regs.r_pc); -+ cpu->regs.r_npc = OSSwapInt32(cpu->regs.r_npc); -+ cpu->regs.r_y = OSSwapInt32(cpu->regs.r_y); -+ cpu->regs.r_g1 = OSSwapInt32(cpu->regs.r_g1); -+ cpu->regs.r_g2 = OSSwapInt32(cpu->regs.r_g2); -+ cpu->regs.r_g3 = OSSwapInt32(cpu->regs.r_g3); -+ cpu->regs.r_g4 = OSSwapInt32(cpu->regs.r_g4); -+ cpu->regs.r_g5 = OSSwapInt32(cpu->regs.r_g5); -+ cpu->regs.r_g6 = OSSwapInt32(cpu->regs.r_g6); -+ cpu->regs.r_g7 = OSSwapInt32(cpu->regs.r_g7); -+ cpu->regs.r_o0 = OSSwapInt32(cpu->regs.r_o0); -+ cpu->regs.r_o1 = OSSwapInt32(cpu->regs.r_o1); -+ cpu->regs.r_o2 = OSSwapInt32(cpu->regs.r_o2); -+ cpu->regs.r_o3 = OSSwapInt32(cpu->regs.r_o3); -+ cpu->regs.r_o4 = OSSwapInt32(cpu->regs.r_o4); -+ cpu->regs.r_o5 = OSSwapInt32(cpu->regs.r_o5); -+ cpu->regs.r_o6 = OSSwapInt32(cpu->regs.r_o6); -+ cpu->regs.r_o7 = OSSwapInt32(cpu->regs.r_o7); - - pr_status = (struct p_status *) &(cpu->regs.r_psr); - if(target_byte_sex == host_byte_sex){ - memcpy(&spsr, &(cpu->regs.r_psr), sizeof(struct swapped_psr)); -- spsr.u.word = NXSwapLong(spsr.u.word); -+ spsr.u.word = OSSwapInt32(spsr.u.word); - pr_status->PSRREG.psr_bits.cwp = spsr.u.fields.cwp; - pr_status->PSRREG.psr_bits.ps = spsr.u.fields.ps; - pr_status->PSRREG.psr_bits.s = spsr.u.fields.s; -@@ -99,7 +99,7 @@ - spsr.u.fields.icc = pr_status->PSRREG.psr_bits.icc; - spsr.u.fields.ver = pr_status->PSRREG.psr_bits.et; - spsr.u.fields.impl = pr_status->PSRREG.psr_bits.impl; -- spsr.u.word = NXSwapLong(spsr.u.word); -+ spsr.u.word = OSSwapInt32(spsr.u.word); - memcpy(&(cpu->regs.r_psr), &spsr, sizeof(struct swapped_psr)); - } - } -@@ -127,7 +127,7 @@ - unsigned int word; - } u; - } sfsr; -- unsigned long i; -+ uint32_t i; - struct f_status *fpu_status; - enum NXByteOrder host_byte_sex; - -@@ -137,18 +137,18 @@ - /* floating point registers */ - for(i = 0; i < 16; i++) /* 16 doubles */ - fpu->fpu.fpu_fr.Fpu_dregs[i] = -- NXSwapDouble(fpu->fpu.fpu_fr.Fpu_dregs[i]); -+ OSSwapInt64(fpu->fpu.fpu_fr.Fpu_dregs[i]); - -- fpu->fpu.Fpu_q[0].FQu.whole = NXSwapDouble(fpu->fpu.Fpu_q[0].FQu.whole); -- fpu->fpu.Fpu_q[1].FQu.whole = NXSwapDouble(fpu->fpu.Fpu_q[1].FQu.whole); -- fpu->fpu.Fpu_flags = NXSwapLong(fpu->fpu.Fpu_flags); -- fpu->fpu.Fpu_extra = NXSwapLong(fpu->fpu.Fpu_extra); -- fpu->fpu.Fpu_qcnt = NXSwapLong(fpu->fpu.Fpu_qcnt); -+ fpu->fpu.Fpu_q[0].FQu.whole = OSSwapInt64(fpu->fpu.Fpu_q[0].FQu.whole); -+ fpu->fpu.Fpu_q[1].FQu.whole = OSSwapInt64(fpu->fpu.Fpu_q[1].FQu.whole); -+ fpu->fpu.Fpu_flags = OSSwapInt32(fpu->fpu.Fpu_flags); -+ fpu->fpu.Fpu_extra = OSSwapInt32(fpu->fpu.Fpu_extra); -+ fpu->fpu.Fpu_qcnt = OSSwapInt32(fpu->fpu.Fpu_qcnt); - - fpu_status = (struct f_status *) &(fpu->fpu.Fpu_fsr); - if(target_byte_sex == host_byte_sex){ - memcpy(&sfsr, &(fpu->fpu.Fpu_fsr), sizeof(unsigned int)); -- sfsr.u.word = NXSwapLong(sfsr.u.word); -+ sfsr.u.word = OSSwapInt32(sfsr.u.word); - fpu_status->FPUREG.Fpu_fsr_bits.rd = sfsr.u.fields.rd; - fpu_status->FPUREG.Fpu_fsr_bits.rp = sfsr.u.fields.rp; - fpu_status->FPUREG.Fpu_fsr_bits.tem = sfsr.u.fields.tem; -@@ -171,7 +171,7 @@ - sfsr.u.fields.fcc = fpu_status->FPUREG.Fpu_fsr_bits.fcc; - sfsr.u.fields.aexc = fpu_status->FPUREG.Fpu_fsr_bits.aexc; - sfsr.u.fields.cexc = fpu_status->FPUREG.Fpu_fsr_bits.cexc; -- sfsr.u.word = NXSwapLong(sfsr.u.word); -+ sfsr.u.word = OSSwapInt32(sfsr.u.word); - memcpy(&(fpu->fpu.Fpu_fsr), &sfsr, sizeof(struct swapped_fsr)); - } - } -Index: odcctools-9.2-ld/libmacho/swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/swap.c 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/libmacho/swap.c 2013-09-03 13:43:55.657826656 +0000 -@@ -22,6 +22,7 @@ - */ - #ifndef RLD - #include <stdint.h> -+#include <libkern/OSByteOrder.h> - #include <mach-o/swap.h> - #include <string.h> - -@@ -30,8 +31,8 @@ - struct fat_header *fat_header, - enum NXByteOrder target_byte_sex) - { -- fat_header->magic = NXSwapLong(fat_header->magic); -- fat_header->nfat_arch = NXSwapLong(fat_header->nfat_arch); -+ fat_header->magic = OSSwapInt32(fat_header->magic); -+ fat_header->nfat_arch = OSSwapInt32(fat_header->nfat_arch); - } - - void -@@ -43,11 +44,11 @@ - uint32_t i; - - for(i = 0; i < nfat_arch; i++){ -- fat_archs[i].cputype = NXSwapLong(fat_archs[i].cputype); -- fat_archs[i].cpusubtype = NXSwapLong(fat_archs[i].cpusubtype); -- fat_archs[i].offset = NXSwapLong(fat_archs[i].offset); -- fat_archs[i].size = NXSwapLong(fat_archs[i].size); -- fat_archs[i].align = NXSwapLong(fat_archs[i].align); -+ fat_archs[i].cputype = OSSwapInt32(fat_archs[i].cputype); -+ fat_archs[i].cpusubtype = OSSwapInt32(fat_archs[i].cpusubtype); -+ fat_archs[i].offset = OSSwapInt32(fat_archs[i].offset); -+ fat_archs[i].size = OSSwapInt32(fat_archs[i].size); -+ fat_archs[i].align = OSSwapInt32(fat_archs[i].align); - } - } - -@@ -56,13 +57,13 @@ - struct mach_header *mh, - enum NXByteOrder target_byte_sex) - { -- mh->magic = NXSwapLong(mh->magic); -- mh->cputype = NXSwapLong(mh->cputype); -- mh->cpusubtype = NXSwapLong(mh->cpusubtype); -- mh->filetype = NXSwapLong(mh->filetype); -- mh->ncmds = NXSwapLong(mh->ncmds); -- mh->sizeofcmds = NXSwapLong(mh->sizeofcmds); -- mh->flags = NXSwapLong(mh->flags); -+ mh->magic = OSSwapInt32(mh->magic); -+ mh->cputype = OSSwapInt32(mh->cputype); -+ mh->cpusubtype = OSSwapInt32(mh->cpusubtype); -+ mh->filetype = OSSwapInt32(mh->filetype); -+ mh->ncmds = OSSwapInt32(mh->ncmds); -+ mh->sizeofcmds = OSSwapInt32(mh->sizeofcmds); -+ mh->flags = OSSwapInt32(mh->flags); - } - - void -@@ -70,14 +71,14 @@ - struct mach_header_64 *mh, - enum NXByteOrder target_byte_sex) - { -- mh->magic = NXSwapLong(mh->magic); -- mh->cputype = NXSwapLong(mh->cputype); -- mh->cpusubtype = NXSwapLong(mh->cpusubtype); -- mh->filetype = NXSwapLong(mh->filetype); -- mh->ncmds = NXSwapLong(mh->ncmds); -- mh->sizeofcmds = NXSwapLong(mh->sizeofcmds); -- mh->flags = NXSwapLong(mh->flags); -- mh->reserved = NXSwapLong(mh->reserved); -+ mh->magic = OSSwapInt32(mh->magic); -+ mh->cputype = OSSwapInt32(mh->cputype); -+ mh->cpusubtype = OSSwapInt32(mh->cpusubtype); -+ mh->filetype = OSSwapInt32(mh->filetype); -+ mh->ncmds = OSSwapInt32(mh->ncmds); -+ mh->sizeofcmds = OSSwapInt32(mh->sizeofcmds); -+ mh->flags = OSSwapInt32(mh->flags); -+ mh->reserved = OSSwapInt32(mh->reserved); - } - - void -@@ -85,8 +86,8 @@ - struct load_command *lc, - enum NXByteOrder target_byte_sex) - { -- lc->cmd = NXSwapLong(lc->cmd); -- lc->cmdsize = NXSwapLong(lc->cmdsize); -+ lc->cmd = OSSwapInt32(lc->cmd); -+ lc->cmdsize = OSSwapInt32(lc->cmdsize); - } - - void -@@ -95,16 +96,16 @@ - enum NXByteOrder target_byte_sex) - { - /* segname[16] */ -- sg->cmd = NXSwapLong(sg->cmd); -- sg->cmdsize = NXSwapLong(sg->cmdsize); -- sg->vmaddr = NXSwapLong(sg->vmaddr); -- sg->vmsize = NXSwapLong(sg->vmsize); -- sg->fileoff = NXSwapLong(sg->fileoff); -- sg->filesize = NXSwapLong(sg->filesize); -- sg->maxprot = NXSwapLong(sg->maxprot); -- sg->initprot = NXSwapLong(sg->initprot); -- sg->nsects = NXSwapLong(sg->nsects); -- sg->flags = NXSwapLong(sg->flags); -+ sg->cmd = OSSwapInt32(sg->cmd); -+ sg->cmdsize = OSSwapInt32(sg->cmdsize); -+ sg->vmaddr = OSSwapInt32(sg->vmaddr); -+ sg->vmsize = OSSwapInt32(sg->vmsize); -+ sg->fileoff = OSSwapInt32(sg->fileoff); -+ sg->filesize = OSSwapInt32(sg->filesize); -+ sg->maxprot = OSSwapInt32(sg->maxprot); -+ sg->initprot = OSSwapInt32(sg->initprot); -+ sg->nsects = OSSwapInt32(sg->nsects); -+ sg->flags = OSSwapInt32(sg->flags); - } - - void -@@ -113,16 +114,16 @@ - enum NXByteOrder target_byte_sex) - { - /* char segname[16] */ -- sg->cmd = NXSwapLong(sg->cmd); -- sg->cmdsize = NXSwapLong(sg->cmdsize); -- sg->vmaddr = NXSwapLongLong(sg->vmaddr); -- sg->vmsize = NXSwapLongLong(sg->vmsize); -- sg->fileoff = NXSwapLongLong(sg->fileoff); -- sg->filesize = NXSwapLongLong(sg->filesize); -- sg->maxprot = NXSwapLong(sg->maxprot); -- sg->initprot = NXSwapLong(sg->initprot); -- sg->nsects = NXSwapLong(sg->nsects); -- sg->flags = NXSwapLong(sg->flags); -+ sg->cmd = OSSwapInt32(sg->cmd); -+ sg->cmdsize = OSSwapInt32(sg->cmdsize); -+ sg->vmaddr = OSSwapInt64(sg->vmaddr); -+ sg->vmsize = OSSwapInt64(sg->vmsize); -+ sg->fileoff = OSSwapInt64(sg->fileoff); -+ sg->filesize = OSSwapInt64(sg->filesize); -+ sg->maxprot = OSSwapInt32(sg->maxprot); -+ sg->initprot = OSSwapInt32(sg->initprot); -+ sg->nsects = OSSwapInt32(sg->nsects); -+ sg->flags = OSSwapInt32(sg->flags); - } - - void -@@ -136,15 +137,15 @@ - for(i = 0; i < nsects; i++){ - /* sectname[16] */ - /* segname[16] */ -- s[i].addr = NXSwapLong(s[i].addr); -- s[i].size = NXSwapLong(s[i].size); -- s[i].offset = NXSwapLong(s[i].offset); -- s[i].align = NXSwapLong(s[i].align); -- s[i].reloff = NXSwapLong(s[i].reloff); -- s[i].nreloc = NXSwapLong(s[i].nreloc); -- s[i].flags = NXSwapLong(s[i].flags); -- s[i].reserved1 = NXSwapLong(s[i].reserved1); -- s[i].reserved2 = NXSwapLong(s[i].reserved2); -+ s[i].addr = OSSwapInt32(s[i].addr); -+ s[i].size = OSSwapInt32(s[i].size); -+ s[i].offset = OSSwapInt32(s[i].offset); -+ s[i].align = OSSwapInt32(s[i].align); -+ s[i].reloff = OSSwapInt32(s[i].reloff); -+ s[i].nreloc = OSSwapInt32(s[i].nreloc); -+ s[i].flags = OSSwapInt32(s[i].flags); -+ s[i].reserved1 = OSSwapInt32(s[i].reserved1); -+ s[i].reserved2 = OSSwapInt32(s[i].reserved2); - } - } - -@@ -159,16 +160,16 @@ - for(i = 0; i < nsects; i++){ - /* sectname[16] */ - /* segname[16] */ -- s[i].addr = NXSwapLongLong(s[i].addr); -- s[i].size = NXSwapLongLong(s[i].size); -- s[i].offset = NXSwapLong(s[i].offset); -- s[i].align = NXSwapLong(s[i].align); -- s[i].reloff = NXSwapLong(s[i].reloff); -- s[i].nreloc = NXSwapLong(s[i].nreloc); -- s[i].flags = NXSwapLong(s[i].flags); -- s[i].reserved1 = NXSwapLong(s[i].reserved1); -- s[i].reserved2 = NXSwapLong(s[i].reserved2); -- s[i].reserved3 = NXSwapLong(s[i].reserved3); -+ s[i].addr = OSSwapInt64(s[i].addr); -+ s[i].size = OSSwapInt64(s[i].size); -+ s[i].offset = OSSwapInt32(s[i].offset); -+ s[i].align = OSSwapInt32(s[i].align); -+ s[i].reloff = OSSwapInt32(s[i].reloff); -+ s[i].nreloc = OSSwapInt32(s[i].nreloc); -+ s[i].flags = OSSwapInt32(s[i].flags); -+ s[i].reserved1 = OSSwapInt32(s[i].reserved1); -+ s[i].reserved2 = OSSwapInt32(s[i].reserved2); -+ s[i].reserved3 = OSSwapInt32(s[i].reserved3); - } - } - -@@ -177,12 +178,12 @@ - struct symtab_command *st, - enum NXByteOrder target_byte_sex) - { -- st->cmd = NXSwapLong(st->cmd); -- st->cmdsize = NXSwapLong(st->cmdsize); -- st->symoff = NXSwapLong(st->symoff); -- st->nsyms = NXSwapLong(st->nsyms); -- st->stroff = NXSwapLong(st->stroff); -- st->strsize = NXSwapLong(st->strsize); -+ st->cmd = OSSwapInt32(st->cmd); -+ st->cmdsize = OSSwapInt32(st->cmdsize); -+ st->symoff = OSSwapInt32(st->symoff); -+ st->nsyms = OSSwapInt32(st->nsyms); -+ st->stroff = OSSwapInt32(st->stroff); -+ st->strsize = OSSwapInt32(st->strsize); - } - - void -@@ -190,26 +191,26 @@ - struct dysymtab_command *dyst, - enum NXByteOrder target_byte_sex) - { -- dyst->cmd = NXSwapLong(dyst->cmd); -- dyst->cmdsize = NXSwapLong(dyst->cmdsize); -- dyst->ilocalsym = NXSwapLong(dyst->ilocalsym); -- dyst->nlocalsym = NXSwapLong(dyst->nlocalsym); -- dyst->iextdefsym = NXSwapLong(dyst->iextdefsym); -- dyst->nextdefsym = NXSwapLong(dyst->nextdefsym); -- dyst->iundefsym = NXSwapLong(dyst->iundefsym); -- dyst->nundefsym = NXSwapLong(dyst->nundefsym); -- dyst->tocoff = NXSwapLong(dyst->tocoff); -- dyst->ntoc = NXSwapLong(dyst->ntoc); -- dyst->modtaboff = NXSwapLong(dyst->modtaboff); -- dyst->nmodtab = NXSwapLong(dyst->nmodtab); -- dyst->extrefsymoff = NXSwapLong(dyst->extrefsymoff); -- dyst->nextrefsyms = NXSwapLong(dyst->nextrefsyms); -- dyst->indirectsymoff = NXSwapLong(dyst->indirectsymoff); -- dyst->nindirectsyms = NXSwapLong(dyst->nindirectsyms); -- dyst->extreloff = NXSwapLong(dyst->extreloff); -- dyst->nextrel = NXSwapLong(dyst->nextrel); -- dyst->locreloff = NXSwapLong(dyst->locreloff); -- dyst->nlocrel = NXSwapLong(dyst->nlocrel); -+ dyst->cmd = OSSwapInt32(dyst->cmd); -+ dyst->cmdsize = OSSwapInt32(dyst->cmdsize); -+ dyst->ilocalsym = OSSwapInt32(dyst->ilocalsym); -+ dyst->nlocalsym = OSSwapInt32(dyst->nlocalsym); -+ dyst->iextdefsym = OSSwapInt32(dyst->iextdefsym); -+ dyst->nextdefsym = OSSwapInt32(dyst->nextdefsym); -+ dyst->iundefsym = OSSwapInt32(dyst->iundefsym); -+ dyst->nundefsym = OSSwapInt32(dyst->nundefsym); -+ dyst->tocoff = OSSwapInt32(dyst->tocoff); -+ dyst->ntoc = OSSwapInt32(dyst->ntoc); -+ dyst->modtaboff = OSSwapInt32(dyst->modtaboff); -+ dyst->nmodtab = OSSwapInt32(dyst->nmodtab); -+ dyst->extrefsymoff = OSSwapInt32(dyst->extrefsymoff); -+ dyst->nextrefsyms = OSSwapInt32(dyst->nextrefsyms); -+ dyst->indirectsymoff = OSSwapInt32(dyst->indirectsymoff); -+ dyst->nindirectsyms = OSSwapInt32(dyst->nindirectsyms); -+ dyst->extreloff = OSSwapInt32(dyst->extreloff); -+ dyst->nextrel = OSSwapInt32(dyst->nextrel); -+ dyst->locreloff = OSSwapInt32(dyst->locreloff); -+ dyst->nlocrel = OSSwapInt32(dyst->nlocrel); - } - - void -@@ -217,10 +218,10 @@ - struct symseg_command *ss, - enum NXByteOrder target_byte_sex) - { -- ss->cmd = NXSwapLong(ss->cmd); -- ss->cmdsize = NXSwapLong(ss->cmdsize); -- ss->offset = NXSwapLong(ss->offset); -- ss->size = NXSwapLong(ss->size); -+ ss->cmd = OSSwapInt32(ss->cmd); -+ ss->cmdsize = OSSwapInt32(ss->cmdsize); -+ ss->offset = OSSwapInt32(ss->offset); -+ ss->size = OSSwapInt32(ss->size); - } - - void -@@ -228,11 +229,11 @@ - struct fvmlib_command *fl, - enum NXByteOrder target_byte_sex) - { -- fl->cmd = NXSwapLong(fl->cmd); -- fl->cmdsize = NXSwapLong(fl->cmdsize); -- fl->fvmlib.name.offset = NXSwapLong(fl->fvmlib.name.offset); -- fl->fvmlib.minor_version = NXSwapLong(fl->fvmlib.minor_version); -- fl->fvmlib.header_addr = NXSwapLong(fl->fvmlib.header_addr); -+ fl->cmd = OSSwapInt32(fl->cmd); -+ fl->cmdsize = OSSwapInt32(fl->cmdsize); -+ fl->fvmlib.name.offset = OSSwapInt32(fl->fvmlib.name.offset); -+ fl->fvmlib.minor_version = OSSwapInt32(fl->fvmlib.minor_version); -+ fl->fvmlib.header_addr = OSSwapInt32(fl->fvmlib.header_addr); - } - - void -@@ -240,13 +241,13 @@ - struct dylib_command *dl, - enum NXByteOrder target_byte_sex) - { -- dl->cmd = NXSwapLong(dl->cmd); -- dl->cmdsize = NXSwapLong(dl->cmdsize); -- dl->dylib.name.offset = NXSwapLong(dl->dylib.name.offset); -- dl->dylib.timestamp = NXSwapLong(dl->dylib.timestamp); -- dl->dylib.current_version = NXSwapLong(dl->dylib.current_version); -+ dl->cmd = OSSwapInt32(dl->cmd); -+ dl->cmdsize = OSSwapInt32(dl->cmdsize); -+ dl->dylib.name.offset = OSSwapInt32(dl->dylib.name.offset); -+ dl->dylib.timestamp = OSSwapInt32(dl->dylib.timestamp); -+ dl->dylib.current_version = OSSwapInt32(dl->dylib.current_version); - dl->dylib.compatibility_version = -- NXSwapLong(dl->dylib.compatibility_version); -+ OSSwapInt32(dl->dylib.compatibility_version); - } - - void -@@ -254,9 +255,9 @@ - struct sub_framework_command *sub, - enum NXByteOrder target_byte_sex) - { -- sub->cmd = NXSwapLong(sub->cmd); -- sub->cmdsize = NXSwapLong(sub->cmdsize); -- sub->umbrella.offset = NXSwapLong(sub->umbrella.offset); -+ sub->cmd = OSSwapInt32(sub->cmd); -+ sub->cmdsize = OSSwapInt32(sub->cmdsize); -+ sub->umbrella.offset = OSSwapInt32(sub->umbrella.offset); - } - - void -@@ -264,9 +265,9 @@ - struct sub_umbrella_command *usub, - enum NXByteOrder target_byte_sex) - { -- usub->cmd = NXSwapLong(usub->cmd); -- usub->cmdsize = NXSwapLong(usub->cmdsize); -- usub->sub_umbrella.offset = NXSwapLong(usub->sub_umbrella.offset); -+ usub->cmd = OSSwapInt32(usub->cmd); -+ usub->cmdsize = OSSwapInt32(usub->cmdsize); -+ usub->sub_umbrella.offset = OSSwapInt32(usub->sub_umbrella.offset); - } - - void -@@ -274,9 +275,9 @@ - struct sub_library_command *lsub, - enum NXByteOrder target_byte_sex) - { -- lsub->cmd = NXSwapLong(lsub->cmd); -- lsub->cmdsize = NXSwapLong(lsub->cmdsize); -- lsub->sub_library.offset = NXSwapLong(lsub->sub_library.offset); -+ lsub->cmd = OSSwapInt32(lsub->cmd); -+ lsub->cmdsize = OSSwapInt32(lsub->cmdsize); -+ lsub->sub_library.offset = OSSwapInt32(lsub->sub_library.offset); - } - - void -@@ -284,9 +285,9 @@ - struct sub_client_command *csub, - enum NXByteOrder target_byte_sex) - { -- csub->cmd = NXSwapLong(csub->cmd); -- csub->cmdsize = NXSwapLong(csub->cmdsize); -- csub->client.offset = NXSwapLong(csub->client.offset); -+ csub->cmd = OSSwapInt32(csub->cmd); -+ csub->cmdsize = OSSwapInt32(csub->cmdsize); -+ csub->client.offset = OSSwapInt32(csub->client.offset); - } - - -@@ -295,12 +296,12 @@ - struct prebound_dylib_command *pbdylib, - enum NXByteOrder target_byte_sex) - { -- pbdylib->cmd = NXSwapLong(pbdylib->cmd); -- pbdylib->cmdsize = NXSwapLong(pbdylib->cmdsize); -- pbdylib->name.offset = NXSwapLong(pbdylib->name.offset); -- pbdylib->nmodules = NXSwapLong(pbdylib->nmodules); -+ pbdylib->cmd = OSSwapInt32(pbdylib->cmd); -+ pbdylib->cmdsize = OSSwapInt32(pbdylib->cmdsize); -+ pbdylib->name.offset = OSSwapInt32(pbdylib->name.offset); -+ pbdylib->nmodules = OSSwapInt32(pbdylib->nmodules); - pbdylib->linked_modules.offset = -- NXSwapLong(pbdylib->linked_modules.offset); -+ OSSwapInt32(pbdylib->linked_modules.offset); - } - - void -@@ -308,9 +309,9 @@ - struct dylinker_command *dyld, - enum NXByteOrder target_byte_sex) - { -- dyld->cmd = NXSwapLong(dyld->cmd); -- dyld->cmdsize = NXSwapLong(dyld->cmdsize); -- dyld->name.offset = NXSwapLong(dyld->name.offset); -+ dyld->cmd = OSSwapInt32(dyld->cmd); -+ dyld->cmdsize = OSSwapInt32(dyld->cmdsize); -+ dyld->name.offset = OSSwapInt32(dyld->name.offset); - } - - void -@@ -318,10 +319,10 @@ - struct fvmfile_command *ff, - enum NXByteOrder target_byte_sex) - { -- ff->cmd = NXSwapLong(ff->cmd); -- ff->cmdsize = NXSwapLong(ff->cmdsize); -- ff->name.offset = NXSwapLong(ff->name.offset); -- ff->header_addr = NXSwapLong(ff->header_addr); -+ ff->cmd = OSSwapInt32(ff->cmd); -+ ff->cmdsize = OSSwapInt32(ff->cmdsize); -+ ff->name.offset = OSSwapInt32(ff->name.offset); -+ ff->header_addr = OSSwapInt32(ff->header_addr); - } - - -@@ -330,8 +331,8 @@ - struct thread_command *ut, - enum NXByteOrder target_byte_sex) - { -- ut->cmd = NXSwapLong(ut->cmd); -- ut->cmdsize = NXSwapLong(ut->cmdsize); -+ ut->cmd = OSSwapInt32(ut->cmd); -+ ut->cmdsize = OSSwapInt32(ut->cmdsize); - } - - void -@@ -339,8 +340,8 @@ - struct ident_command *id_cmd, - enum NXByteOrder target_byte_sex) - { -- id_cmd->cmd = NXSwapLong(id_cmd->cmd); -- id_cmd->cmdsize = NXSwapLong(id_cmd->cmdsize); -+ id_cmd->cmd = OSSwapInt32(id_cmd->cmd); -+ id_cmd->cmdsize = OSSwapInt32(id_cmd->cmdsize); - } - - void -@@ -348,16 +349,16 @@ - struct routines_command *r_cmd, - enum NXByteOrder target_byte_sex) - { -- r_cmd->cmd = NXSwapLong(r_cmd->cmd); -- r_cmd->cmdsize = NXSwapLong(r_cmd->cmdsize); -- r_cmd->init_address = NXSwapLong(r_cmd->init_address); -- r_cmd->init_module = NXSwapLong(r_cmd->init_module); -- r_cmd->reserved1 = NXSwapLong(r_cmd->reserved1); -- r_cmd->reserved2 = NXSwapLong(r_cmd->reserved2); -- r_cmd->reserved3 = NXSwapLong(r_cmd->reserved3); -- r_cmd->reserved4 = NXSwapLong(r_cmd->reserved4); -- r_cmd->reserved5 = NXSwapLong(r_cmd->reserved5); -- r_cmd->reserved6 = NXSwapLong(r_cmd->reserved6); -+ r_cmd->cmd = OSSwapInt32(r_cmd->cmd); -+ r_cmd->cmdsize = OSSwapInt32(r_cmd->cmdsize); -+ r_cmd->init_address = OSSwapInt32(r_cmd->init_address); -+ r_cmd->init_module = OSSwapInt32(r_cmd->init_module); -+ r_cmd->reserved1 = OSSwapInt32(r_cmd->reserved1); -+ r_cmd->reserved2 = OSSwapInt32(r_cmd->reserved2); -+ r_cmd->reserved3 = OSSwapInt32(r_cmd->reserved3); -+ r_cmd->reserved4 = OSSwapInt32(r_cmd->reserved4); -+ r_cmd->reserved5 = OSSwapInt32(r_cmd->reserved5); -+ r_cmd->reserved6 = OSSwapInt32(r_cmd->reserved6); - } - - void -@@ -365,16 +366,16 @@ - struct routines_command_64 *r_cmd, - enum NXByteOrder target_byte_sex) - { -- r_cmd->cmd = NXSwapLong(r_cmd->cmd); -- r_cmd->cmdsize = NXSwapLong(r_cmd->cmdsize); -- r_cmd->init_address = NXSwapLongLong(r_cmd->init_address); -- r_cmd->init_module = NXSwapLongLong(r_cmd->init_module); -- r_cmd->reserved1 = NXSwapLongLong(r_cmd->reserved1); -- r_cmd->reserved2 = NXSwapLongLong(r_cmd->reserved2); -- r_cmd->reserved3 = NXSwapLongLong(r_cmd->reserved3); -- r_cmd->reserved4 = NXSwapLongLong(r_cmd->reserved4); -- r_cmd->reserved5 = NXSwapLongLong(r_cmd->reserved5); -- r_cmd->reserved6 = NXSwapLongLong(r_cmd->reserved6); -+ r_cmd->cmd = OSSwapInt32(r_cmd->cmd); -+ r_cmd->cmdsize = OSSwapInt32(r_cmd->cmdsize); -+ r_cmd->init_address = OSSwapInt64(r_cmd->init_address); -+ r_cmd->init_module = OSSwapInt64(r_cmd->init_module); -+ r_cmd->reserved1 = OSSwapInt64(r_cmd->reserved1); -+ r_cmd->reserved2 = OSSwapInt64(r_cmd->reserved2); -+ r_cmd->reserved3 = OSSwapInt64(r_cmd->reserved3); -+ r_cmd->reserved4 = OSSwapInt64(r_cmd->reserved4); -+ r_cmd->reserved5 = OSSwapInt64(r_cmd->reserved5); -+ r_cmd->reserved6 = OSSwapInt64(r_cmd->reserved6); - } - - void -@@ -382,9 +383,9 @@ - struct prebind_cksum_command *cksum_cmd, - enum NXByteOrder target_byte_sex) - { -- cksum_cmd->cmd = NXSwapLong(cksum_cmd->cmd); -- cksum_cmd->cmdsize = NXSwapLong(cksum_cmd->cmdsize); -- cksum_cmd->cksum = NXSwapLong(cksum_cmd->cksum); -+ cksum_cmd->cmd = OSSwapInt32(cksum_cmd->cmd); -+ cksum_cmd->cmdsize = OSSwapInt32(cksum_cmd->cmdsize); -+ cksum_cmd->cksum = OSSwapInt32(cksum_cmd->cksum); - } - - void -@@ -392,8 +393,8 @@ - struct uuid_command *uuid_cmd, - enum NXByteOrder target_byte_sex) - { -- uuid_cmd->cmd = NXSwapLong(uuid_cmd->cmd); -- uuid_cmd->cmdsize = NXSwapLong(uuid_cmd->cmdsize); -+ uuid_cmd->cmd = OSSwapInt32(uuid_cmd->cmd); -+ uuid_cmd->cmdsize = OSSwapInt32(uuid_cmd->cmdsize); - } - - void -@@ -405,11 +406,11 @@ - uint32_t i; - - for(i = 0; i < nsymbols; i++){ -- symbols[i].n_un.n_strx = NXSwapLong(symbols[i].n_un.n_strx); -+ symbols[i].n_un.n_strx = OSSwapInt32(symbols[i].n_un.n_strx); - /* n_type */ - /* n_sect */ -- symbols[i].n_desc = NXSwapShort(symbols[i].n_desc); -- symbols[i].n_value = NXSwapLong(symbols[i].n_value); -+ symbols[i].n_desc = OSSwapInt16(symbols[i].n_desc); -+ symbols[i].n_value = OSSwapInt32(symbols[i].n_value); - } - } - -@@ -422,11 +423,11 @@ - uint32_t i; - - for(i = 0; i < nsymbols; i++){ -- symbols[i].n_un.n_strx = NXSwapLong(symbols[i].n_un.n_strx); -+ symbols[i].n_un.n_strx = OSSwapInt32(symbols[i].n_un.n_strx); - /* n_type */ - /* n_sect */ -- symbols[i].n_desc = NXSwapShort(symbols[i].n_desc); -- symbols[i].n_value = NXSwapLongLong(symbols[i].n_value); -+ symbols[i].n_desc = OSSwapInt16(symbols[i].n_desc); -+ symbols[i].n_value = OSSwapInt64(symbols[i].n_value); - } - } - -@@ -439,8 +440,8 @@ - uint32_t i; - - for(i = 0; i < nranlibs; i++){ -- ranlibs[i].ran_un.ran_strx = NXSwapLong(ranlibs[i].ran_un.ran_strx); -- ranlibs[i].ran_off = NXSwapLong(ranlibs[i].ran_off); -+ ranlibs[i].ran_un.ran_strx = OSSwapInt32(ranlibs[i].ran_un.ran_strx); -+ ranlibs[i].ran_off = OSSwapInt32(ranlibs[i].ran_off); - } - } - -@@ -455,7 +456,7 @@ - uint32_t to_host_byte_sex, scattered; - - struct swapped_relocation_info { -- long r_address; -+ uint32_t r_address; - union { - struct { - unsigned int -@@ -471,7 +472,7 @@ - - struct swapped_scattered_relocation_info { - uint32_t word; -- long r_value; -+ uint32_t r_value; - } *ssr; - - host_byte_sex = NXHostByteOrder(); -@@ -479,14 +480,14 @@ - - for(i = 0; i < nrelocs; i++){ - if(to_host_byte_sex) -- scattered = (NXSwapLong(relocs[i].r_address) & R_SCATTERED) != 0; -+ scattered = (OSSwapInt32(relocs[i].r_address) & R_SCATTERED) != 0; - else - scattered = ((relocs[i].r_address) & R_SCATTERED) != 0; - if(scattered == FALSE){ - if(to_host_byte_sex){ - memcpy(&sr, relocs + i, sizeof(struct relocation_info)); -- sr.r_address = NXSwapLong(sr.r_address); -- sr.u.word = NXSwapLong(sr.u.word); -+ sr.r_address = OSSwapInt32(sr.r_address); -+ sr.u.word = OSSwapInt32(sr.u.word); - relocs[i].r_address = sr.r_address; - relocs[i].r_symbolnum = sr.u.fields.r_symbolnum; - relocs[i].r_pcrel = sr.u.fields.r_pcrel; -@@ -501,15 +502,15 @@ - sr.u.fields.r_pcrel = relocs[i].r_pcrel; - sr.u.fields.r_extern = relocs[i].r_extern; - sr.u.fields.r_type = relocs[i].r_type; -- sr.r_address = NXSwapLong(sr.r_address); -- sr.u.word = NXSwapLong(sr.u.word); -+ sr.r_address = OSSwapInt32(sr.r_address); -+ sr.u.word = OSSwapInt32(sr.u.word); - memcpy(relocs + i, &sr, sizeof(struct relocation_info)); - } - } - else{ - ssr = (struct swapped_scattered_relocation_info *)(relocs + i); -- ssr->word = NXSwapLong(ssr->word); -- ssr->r_value = NXSwapLong(ssr->r_value); -+ ssr->word = OSSwapInt32(ssr->word); -+ ssr->r_value = OSSwapInt32(ssr->r_value); - } - } - } -@@ -523,7 +524,7 @@ - uint32_t i; - - for(i = 0; i < nindirect_symbols; i++) -- indirect_symbols[i] = NXSwapLong(indirect_symbols[i]); -+ indirect_symbols[i] = OSSwapInt32(indirect_symbols[i]); - } - - void -@@ -551,14 +552,14 @@ - for(i = 0; i < nrefs; i++){ - if(target_byte_sex == host_byte_sex){ - memcpy(&sref, refs + i, sizeof(struct swapped_dylib_reference)); -- sref.u.word = NXSwapLong(sref.u.word); -+ sref.u.word = OSSwapInt32(sref.u.word); - refs[i].flags = sref.u.fields.flags; - refs[i].isym = sref.u.fields.isym; - } - else{ - sref.u.fields.isym = refs[i].isym; - sref.u.fields.flags = refs[i].flags; -- sref.u.word = NXSwapLong(sref.u.word); -+ sref.u.word = OSSwapInt32(sref.u.word); - memcpy(refs + i, &sref, sizeof(struct swapped_dylib_reference)); - } - } -@@ -574,19 +575,19 @@ - uint32_t i; - - for(i = 0; i < nmods; i++){ -- mods[i].module_name = NXSwapLong(mods[i].module_name); -- mods[i].iextdefsym = NXSwapLong(mods[i].iextdefsym); -- mods[i].nextdefsym = NXSwapLong(mods[i].nextdefsym); -- mods[i].irefsym = NXSwapLong(mods[i].irefsym); -- mods[i].nrefsym = NXSwapLong(mods[i].nrefsym); -- mods[i].ilocalsym = NXSwapLong(mods[i].ilocalsym); -- mods[i].nlocalsym = NXSwapLong(mods[i].nlocalsym); -- mods[i].iextrel = NXSwapLong(mods[i].iextrel); -- mods[i].nextrel = NXSwapLong(mods[i].nextrel); -- mods[i].iinit_iterm = NXSwapLong(mods[i].iinit_iterm); -- mods[i].ninit_nterm = NXSwapLong(mods[i].ninit_nterm); -- mods[i].objc_module_info_size = NXSwapLong(mods[i].objc_module_info_size); -- mods[i].objc_module_info_addr = NXSwapLong(mods[i].objc_module_info_addr); -+ mods[i].module_name = OSSwapInt32(mods[i].module_name); -+ mods[i].iextdefsym = OSSwapInt32(mods[i].iextdefsym); -+ mods[i].nextdefsym = OSSwapInt32(mods[i].nextdefsym); -+ mods[i].irefsym = OSSwapInt32(mods[i].irefsym); -+ mods[i].nrefsym = OSSwapInt32(mods[i].nrefsym); -+ mods[i].ilocalsym = OSSwapInt32(mods[i].ilocalsym); -+ mods[i].nlocalsym = OSSwapInt32(mods[i].nlocalsym); -+ mods[i].iextrel = OSSwapInt32(mods[i].iextrel); -+ mods[i].nextrel = OSSwapInt32(mods[i].nextrel); -+ mods[i].iinit_iterm = OSSwapInt32(mods[i].iinit_iterm); -+ mods[i].ninit_nterm = OSSwapInt32(mods[i].ninit_nterm); -+ mods[i].objc_module_info_size = OSSwapInt32(mods[i].objc_module_info_size); -+ mods[i].objc_module_info_addr = OSSwapInt32(mods[i].objc_module_info_addr); - } - } - -@@ -599,19 +600,19 @@ - uint32_t i; - - for(i = 0; i < nmods; i++){ -- mods[i].module_name = NXSwapLong(mods[i].module_name); -- mods[i].iextdefsym = NXSwapLong(mods[i].iextdefsym); -- mods[i].nextdefsym = NXSwapLong(mods[i].nextdefsym); -- mods[i].irefsym = NXSwapLong(mods[i].irefsym); -- mods[i].nrefsym = NXSwapLong(mods[i].nrefsym); -- mods[i].ilocalsym = NXSwapLong(mods[i].ilocalsym); -- mods[i].nlocalsym = NXSwapLong(mods[i].nlocalsym); -- mods[i].iextrel = NXSwapLong(mods[i].iextrel); -- mods[i].nextrel = NXSwapLong(mods[i].nextrel); -- mods[i].iinit_iterm = NXSwapLong(mods[i].iinit_iterm); -- mods[i].ninit_nterm = NXSwapLong(mods[i].ninit_nterm); -- mods[i].objc_module_info_size = NXSwapLong(mods[i].objc_module_info_size); -- mods[i].objc_module_info_addr = NXSwapLongLong(mods[i].objc_module_info_addr); -+ mods[i].module_name = OSSwapInt32(mods[i].module_name); -+ mods[i].iextdefsym = OSSwapInt32(mods[i].iextdefsym); -+ mods[i].nextdefsym = OSSwapInt32(mods[i].nextdefsym); -+ mods[i].irefsym = OSSwapInt32(mods[i].irefsym); -+ mods[i].nrefsym = OSSwapInt32(mods[i].nrefsym); -+ mods[i].ilocalsym = OSSwapInt32(mods[i].ilocalsym); -+ mods[i].nlocalsym = OSSwapInt32(mods[i].nlocalsym); -+ mods[i].iextrel = OSSwapInt32(mods[i].iextrel); -+ mods[i].nextrel = OSSwapInt32(mods[i].nextrel); -+ mods[i].iinit_iterm = OSSwapInt32(mods[i].iinit_iterm); -+ mods[i].ninit_nterm = OSSwapInt32(mods[i].ninit_nterm); -+ mods[i].objc_module_info_size = OSSwapInt32(mods[i].objc_module_info_size); -+ mods[i].objc_module_info_addr = OSSwapInt64(mods[i].objc_module_info_addr); - } - } - -@@ -624,8 +625,8 @@ - uint32_t i; - - for(i = 0; i < ntocs; i++){ -- tocs[i].symbol_index = NXSwapLong(tocs[i].symbol_index); -- tocs[i].module_index = NXSwapLong(tocs[i].module_index); -+ tocs[i].symbol_index = OSSwapInt32(tocs[i].symbol_index); -+ tocs[i].module_index = OSSwapInt32(tocs[i].module_index); - } - } - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/include/mach/machine.h -=================================================================== ---- odcctools-9.2-ld.orig/include/mach/machine.h 2013-09-03 11:38:18.638001227 +0000 -+++ odcctools-9.2-ld/include/mach/machine.h 2013-09-03 15:11:40.625705183 +0000 -@@ -302,7 +302,14 @@ - #define CPU_SUBTYPE_ARM_A500 ((cpu_subtype_t) 2) - #define CPU_SUBTYPE_ARM_A440 ((cpu_subtype_t) 3) - #define CPU_SUBTYPE_ARM_M4 ((cpu_subtype_t) 4) --#define CPU_SUBTYPE_ARM_A680 ((cpu_subtype_t) 5) -+#define CPU_SUBTYPE_ARM_V4T ((cpu_subtype_t) 5) -+#define CPU_SUBTYPE_ARM_V6 ((cpu_subtype_t) 6) -+#define CPU_SUBTYPE_ARM_V5TEJ ((cpu_subtype_t) 7) -+#define CPU_SUBTYPE_ARM_XSCALE ((cpu_subtype_t) 8) -+#define CPU_SUBTYPE_ARM_V7 ((cpu_subtype_t) 9) -+#define CPU_SUBTYPE_ARM_V7F ((cpu_subtype_t) 10) /* Cortex A9 */ -+#define CPU_SUBTYPE_ARM_V7S ((cpu_subtype_t) 11) /* Swift */ -+#define CPU_SUBTYPE_ARM_V7K ((cpu_subtype_t) 12) /* Kirkwood40 */ - - /* - * MC88000 subtypes -@@ -380,11 +387,4 @@ - #define CPU_SUBTYPE_VEO_4 ((cpu_subtype_t) 4) - #define CPU_SUBTYPE_VEO_ALL CPU_SUBTYPE_VEO_2 - --#define CPU_SUBTYPE_ARM_V4T ((cpu_subtype_t) 5) --#define CPU_SUBTYPE_ARM_V6 ((cpu_subtype_t) 6) --#define CPU_SUBTYPE_ARM_V5TEJ ((cpu_subtype_t) 7) --#define CPU_SUBTYPE_ARM_XSCALE ((cpu_subtype_t) 8) --#define CPU_SUBTYPE_ARM_ALL ((cpu_subtype_t) 0) -- -- - #endif /* _MACH_MACHINE_H_ */ diff --git a/recipes-devtools/odcctools/files/cctools-287.patch b/recipes-devtools/odcctools/files/cctools-287.patch deleted file mode 100644 index 6e6dd60..0000000 --- a/recipes-devtools/odcctools/files/cctools-287.patch +++ /dev/null @@ -1,13095 +0,0 @@ -Index: odcctools-9.2-ld/libmacho/arch.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/arch.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/arch.c 2013-09-03 21:08:01.865209516 +0000 -@@ -73,6 +73,8 @@ - "PowerPC 64-bit"}, - {"sparc", CPU_TYPE_SPARC, CPU_SUBTYPE_SPARC_ALL, NX_BigEndian, - "SPARC"}, -+ {"arm", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_ALL, NX_LittleEndian, -+ "ARM"}, - {"any", CPU_TYPE_ANY, CPU_SUBTYPE_MULTIPLE, NX_UnknownByteOrder, - "Architecture Independent"}, - {"veo", CPU_TYPE_VEO, CPU_SUBTYPE_VEO_ALL, NX_BigEndian, -@@ -124,6 +126,22 @@ - "PowerPC 970" }, - {"ppc970-64", CPU_TYPE_POWERPC64, CPU_SUBTYPE_POWERPC_970, NX_BigEndian, - "PowerPC 970 64-bit"}, -+ {"armv4t", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V4T, NX_LittleEndian, -+ "arm v4t"}, -+ {"armv5", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V5TEJ, NX_LittleEndian, -+ "arm v5"}, -+ {"xscale", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_XSCALE, NX_LittleEndian, -+ "arm xscale"}, -+ {"armv6", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V6, NX_LittleEndian, -+ "arm v6"}, -+ {"armv7", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7, NX_LittleEndian, -+ "arm v7"}, -+ {"armv7f", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7F, NX_LittleEndian, -+ "arm v7f"}, -+ {"armv7s", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7S, NX_LittleEndian, -+ "arm v7s"}, -+ {"armv7k", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7K, NX_LittleEndian, -+ "arm v7k"}, - {"little", CPU_TYPE_ANY, CPU_SUBTYPE_LITTLE_ENDIAN, NX_LittleEndian, - "Little Endian"}, - {"big", CPU_TYPE_ANY, CPU_SUBTYPE_BIG_ENDIAN, NX_BigEndian, -@@ -218,7 +236,8 @@ - for(ai = ArchInfoTable; ai->name != NULL; ai++) - if(ai->cputype == cputype && - (cpusubtype == CPU_SUBTYPE_MULTIPLE || -- (ai->cpusubtype == cpusubtype))) -+ ((ai->cpusubtype & ~CPU_SUBTYPE_MASK) == -+ (cpusubtype & ~CPU_SUBTYPE_MASK)))) - return(ai); - - if(cputype == CPU_TYPE_I386){ -@@ -234,8 +253,8 @@ - if(q->description == NULL) - return(NULL); - sprintf((char *)q->description, "Intel family %u model %u", -- CPU_SUBTYPE_INTEL_FAMILY(cpusubtype), -- CPU_SUBTYPE_INTEL_MODEL(cpusubtype)); -+ CPU_SUBTYPE_INTEL_FAMILY(cpusubtype & ~CPU_SUBTYPE_MASK), -+ CPU_SUBTYPE_INTEL_MODEL(cpusubtype & ~CPU_SUBTYPE_MASK)); - return((const NXArchInfo *)q); - } - else if(cputype == CPU_TYPE_POWERPC){ -@@ -274,15 +293,16 @@ - struct fat_arch *fat_archs, - uint32_t nfat_archs) - { -- unsigned long i; -- long lowest_family, lowest_model, lowest_index; -+ uint32_t i; -+ int32_t lowest_family, lowest_model, lowest_index; - - /* - * Look for the first exact match. - */ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype == cputype && -- fat_archs[i].cpusubtype == cpusubtype) -+ (fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ (cpusubtype & ~CPU_SUBTYPE_MASK)) - return(fat_archs + i); - } - -@@ -292,7 +312,7 @@ - */ - switch(cputype){ - case CPU_TYPE_I386: -- switch(cpusubtype){ -+ switch(cpusubtype & ~CPU_SUBTYPE_MASK){ - default: - /* - * Intel cpusubtypes after the pentium (same as 586) are handled -@@ -303,7 +323,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_PENT) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_PENT) - return(fat_archs + i); - } - case CPU_SUBTYPE_PENT: -@@ -315,7 +336,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_486) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_486) - return(fat_archs + i); - } - break; -@@ -327,7 +349,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_I386_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_I386_ALL) - return(fat_archs + i); - } - -@@ -337,19 +360,22 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_486) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_486) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_486SX) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_486SX) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_586) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_586) - return(fat_archs + i); - } - /* -@@ -359,25 +385,26 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(CPU_SUBTYPE_INTEL_FAMILY(fat_archs[i].cpusubtype) < -- lowest_family) -+ if(CPU_SUBTYPE_INTEL_FAMILY(fat_archs[i].cpusubtype & -+ ~CPU_SUBTYPE_MASK) < lowest_family) - lowest_family = CPU_SUBTYPE_INTEL_FAMILY( -- fat_archs[i].cpusubtype); -+ fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK); - } - /* if no intel cputypes found return NULL */ - if(lowest_family == CPU_SUBTYPE_INTEL_FAMILY_MAX + 1) - return(NULL); -- lowest_model = LONG_MAX; -+ lowest_model = INT_MAX; - lowest_index = -1; - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(CPU_SUBTYPE_INTEL_FAMILY(fat_archs[i].cpusubtype) == -- lowest_family){ -- if(CPU_SUBTYPE_INTEL_MODEL(fat_archs[i].cpusubtype) < -- lowest_model){ -+ if(CPU_SUBTYPE_INTEL_FAMILY(fat_archs[i].cpusubtype & -+ ~CPU_SUBTYPE_MASK) == lowest_family){ -+ if(CPU_SUBTYPE_INTEL_MODEL(fat_archs[i].cpusubtype & -+ ~CPU_SUBTYPE_MASK) < lowest_model){ - lowest_model = CPU_SUBTYPE_INTEL_MODEL( -- fat_archs[i].cpusubtype); -+ fat_archs[i].cpusubtype & -+ ~CPU_SUBTYPE_MASK); - lowest_index = i; - } - } -@@ -387,7 +414,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_X86_64_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_X86_64_ALL) - return(fat_archs + i); - } - break; -@@ -395,24 +423,27 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_MC680x0_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_MC680x0_ALL) - return(fat_archs + i); - } - /* - * Try to promote if starting from CPU_SUBTYPE_MC680x0_ALL and - * favor the CPU_SUBTYPE_MC68040 over the CPU_SUBTYPE_MC68030_ONLY. - */ -- if(cpusubtype == CPU_SUBTYPE_MC680x0_ALL){ -+ if((cpusubtype & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC680x0_ALL){ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_MC68040) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_MC68040) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_MC68030_ONLY) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_MC68030_ONLY) - return(fat_archs + i); - } - } -@@ -428,7 +459,7 @@ - * an exact match. For an unknown subtype pick only the ALL type if - * it exists. - */ -- switch(cpusubtype){ -+ switch(cpusubtype & ~CPU_SUBTYPE_MASK){ - case CPU_SUBTYPE_POWERPC_ALL: - /* - * The CPU_SUBTYPE_POWERPC_ALL is only used by the development -@@ -440,7 +471,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_970) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_970) - return(fat_archs + i); - } - case CPU_SUBTYPE_POWERPC_7450: -@@ -448,13 +480,15 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_7450) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_7450) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_7400) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_7400) - return(fat_archs + i); - } - case CPU_SUBTYPE_POWERPC_750: -@@ -466,44 +500,51 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_750) -+ if((fat_archs[i].cpusubtype & CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_750) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_604e) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_604e) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_604) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_604) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ -- if(fat_archs[i].cputype != cputype) -+ if((fat_archs[i].cputype & ~CPU_SUBTYPE_MASK) != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_603ev) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_603ev) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_603e) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_603e) - return(fat_archs + i); - } - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_603) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_603) - return(fat_archs + i); - } - default: - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_ALL) - return(fat_archs + i); - } - } -@@ -517,7 +558,7 @@ - * 970 (currently only the one 64-bit subtype) - * For an unknown subtype pick only the ALL type if it exists. - */ -- switch(cpusubtype){ -+ switch(cpusubtype & ~CPU_SUBTYPE_MASK){ - case CPU_SUBTYPE_POWERPC_ALL: - /* - * The CPU_SUBTYPE_POWERPC_ALL is only used by the development -@@ -529,14 +570,16 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_970) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_970) - return(fat_archs + i); - } - default: - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_POWERPC_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_POWERPC_ALL) - return(fat_archs + i); - } - } -@@ -545,7 +588,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_MC88000_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_MC88000_ALL) - return(fat_archs + i); - } - break; -@@ -553,7 +597,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_I860_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_I860_ALL) - return(fat_archs + i); - } - break; -@@ -561,7 +606,8 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_HPPA_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_HPPA_ALL) - return(fat_archs + i); - } - break; -@@ -569,10 +615,38 @@ - for(i = 0; i < nfat_archs; i++){ - if(fat_archs[i].cputype != cputype) - continue; -- if(fat_archs[i].cpusubtype == CPU_SUBTYPE_SPARC_ALL) -+ if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) == -+ CPU_SUBTYPE_SPARC_ALL) - return(fat_archs + i); - } - break; -+ case CPU_TYPE_ARM: -+ { -+ /* -+ * ARM is straightforward, since each architecture is backward -+ * compatible with previous architectures. So, we just take the -+ * highest that is less than our target. -+ */ -+ int fat_match_found = 0; -+ uint32_t best_fat_arch = 0; -+ for(i = 0; i < nfat_archs; i++){ -+ if(fat_archs[i].cputype != cputype) -+ continue; -+ if(fat_archs[i].cpusubtype > cpusubtype) -+ continue; -+ if(!fat_match_found){ -+ fat_match_found = 1; -+ best_fat_arch = i; -+ continue; -+ } -+ if(fat_archs[i].cpusubtype > -+ fat_archs[best_fat_arch].cpusubtype) -+ best_fat_arch = i; -+ } -+ if(fat_match_found) -+ return fat_archs + best_fat_arch; -+ } -+ break; - default: - return(NULL); - } -@@ -603,33 +677,34 @@ - if(cputype == CPU_TYPE_X86_64) - return(CPU_SUBTYPE_X86_64_ALL); - -- if(cpusubtype1 == cpusubtype2) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK)) - return(cpusubtype1); - - switch(cputype){ - case CPU_TYPE_MC680x0: -- if(cpusubtype1 != CPU_SUBTYPE_MC680x0_ALL && -- cpusubtype1 != CPU_SUBTYPE_MC68030_ONLY && -- cpusubtype1 != CPU_SUBTYPE_MC68040) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC680x0_ALL && -+ (cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68030_ONLY && -+ (cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68040) - return((cpu_subtype_t)-1); -- if(cpusubtype2 != CPU_SUBTYPE_MC680x0_ALL && -- cpusubtype2 != CPU_SUBTYPE_MC68030_ONLY && -- cpusubtype2 != CPU_SUBTYPE_MC68040) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC680x0_ALL && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68030_ONLY && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68040) - return((cpu_subtype_t)-1); - -- if(cpusubtype1 == CPU_SUBTYPE_MC68030_ONLY && -- cpusubtype2 == CPU_SUBTYPE_MC68040) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040) - return((cpu_subtype_t)-1); -- if(cpusubtype1 == CPU_SUBTYPE_MC68040 && -- cpusubtype2 == CPU_SUBTYPE_MC68030_ONLY) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040 && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY) - return((cpu_subtype_t)-1); - -- if(cpusubtype1 == CPU_SUBTYPE_MC68030_ONLY || -- cpusubtype2 == CPU_SUBTYPE_MC68030_ONLY) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY || -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY) - return(CPU_SUBTYPE_MC68030_ONLY); - -- if(cpusubtype1 == CPU_SUBTYPE_MC68040 || -- cpusubtype2 == CPU_SUBTYPE_MC68040) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040 || -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040) - return(CPU_SUBTYPE_MC68040); - break; /* logically can't get here */ - -@@ -639,66 +714,124 @@ - * anything with the 601 becomes 601. All other non exact matches - * combine to the higher value subtype. - */ -- if(cpusubtype1 == CPU_SUBTYPE_POWERPC_ALL) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_ALL) - return(cpusubtype2); -- if(cpusubtype2 == CPU_SUBTYPE_POWERPC_ALL) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_ALL) - return(cpusubtype1); - -- if(cpusubtype1 == CPU_SUBTYPE_POWERPC_601 || -- cpusubtype2 == CPU_SUBTYPE_POWERPC_601) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_601 || -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_601) - return(CPU_SUBTYPE_POWERPC_601); - -- if(cpusubtype1 > cpusubtype2) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) > -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK)) - return(cpusubtype1); - else - return(cpusubtype2); - break; /* logically can't get here */ - - case CPU_TYPE_MC88000: -- if(cpusubtype1 != CPU_SUBTYPE_MC88000_ALL && -- cpusubtype1 != CPU_SUBTYPE_MC88110) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88000_ALL && -+ (cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88110) - return((cpu_subtype_t)-1); -- if(cpusubtype2 != CPU_SUBTYPE_MC88000_ALL && -- cpusubtype2 != CPU_SUBTYPE_MC88110) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88000_ALL && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88110) - return((cpu_subtype_t)-1); - -- if(cpusubtype1 == CPU_SUBTYPE_MC88110 || -- cpusubtype2 == CPU_SUBTYPE_MC88110) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC88110 || -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC88110) - return(CPU_SUBTYPE_MC88110); - - break; /* logically can't get here */ - - case CPU_TYPE_I860: -- if(cpusubtype1 != CPU_SUBTYPE_I860_ALL && -- cpusubtype1 != CPU_SUBTYPE_I860_860) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_ALL && -+ (cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_860) - return((cpu_subtype_t)-1); -- if(cpusubtype2 != CPU_SUBTYPE_I860_ALL && -- cpusubtype2 != CPU_SUBTYPE_I860_860) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_ALL && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_860) - return((cpu_subtype_t)-1); - -- if(cpusubtype1 == CPU_SUBTYPE_I860_860 || -- cpusubtype2 == CPU_SUBTYPE_I860_860) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_I860_860 || -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_I860_860) - return(CPU_SUBTYPE_I860_860); - break; /* logically can't get here */ - - case CPU_TYPE_HPPA: -- if(cpusubtype1 != CPU_SUBTYPE_HPPA_ALL && -- cpusubtype1 != CPU_SUBTYPE_HPPA_7100LC) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_ALL && -+ (cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_7100LC) - return((cpu_subtype_t)-1); -- if(cpusubtype2 != CPU_SUBTYPE_HPPA_ALL && -- cpusubtype2 != CPU_SUBTYPE_HPPA_7100LC) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_ALL && -+ (cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_7100LC) - return((cpu_subtype_t)-1); - - return(CPU_SUBTYPE_HPPA_7100LC); - break; /* logically can't get here */ - - case CPU_TYPE_SPARC: -- if(cpusubtype1 != CPU_SUBTYPE_SPARC_ALL) -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_SPARC_ALL) - return((cpu_subtype_t)-1); -- if(cpusubtype2 != CPU_SUBTYPE_SPARC_ALL) -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_SPARC_ALL) - return((cpu_subtype_t)-1); - break; /* logically can't get here */ - -+ case CPU_TYPE_ARM: -+ /* -+ * Combinability matrix for ARM: -+ * V4T V5 XSCALE V6 V7 ALL -+ * ~~~ ~~ ~~~~~~ ~~ ~~ ~~~ -+ * V4T V4T V5 XSCALE V6 V7 ALL -+ * V5 V5 V5 -- V6 V7 ALL -+ * XSCALE XSCALE -- XSCALE -- -- ALL -+ * V6 V6 V6 -- V6 V7 ALL -+ * V7 V7 V7 -- V7 V7 ALL -+ * ALL ALL ALL ALL ALL ALL ALL -+ */ -+ if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_ARM_ALL) -+ return(cpusubtype2); -+ if((cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_ARM_ALL) -+ return(cpusubtype1); -+ switch((cpusubtype1 & ~CPU_SUBTYPE_MASK)){ -+ case CPU_SUBTYPE_ARM_V7: -+ switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){ -+ case CPU_SUBTYPE_ARM_XSCALE: -+ return((cpu_subtype_t)-1); -+ default: -+ return(CPU_SUBTYPE_ARM_V7); -+ } -+ case CPU_SUBTYPE_ARM_V6: -+ switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){ -+ case CPU_SUBTYPE_ARM_XSCALE: -+ return((cpu_subtype_t)-1); -+ default: -+ return(CPU_SUBTYPE_ARM_V6); -+ } -+ case CPU_SUBTYPE_ARM_XSCALE: -+ switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){ -+ case CPU_SUBTYPE_ARM_V7: -+ case CPU_SUBTYPE_ARM_V6: -+ case CPU_SUBTYPE_ARM_V5TEJ: -+ return((cpu_subtype_t)-1); -+ default: -+ return(CPU_SUBTYPE_ARM_XSCALE); -+ } -+ case CPU_SUBTYPE_ARM_V5TEJ: -+ switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){ -+ case CPU_SUBTYPE_ARM_XSCALE: -+ return((cpu_subtype_t)-1); -+ case CPU_SUBTYPE_ARM_V7: -+ return(CPU_SUBTYPE_ARM_V7); -+ case CPU_SUBTYPE_ARM_V6: -+ return(CPU_SUBTYPE_ARM_V6); -+ default: -+ return(CPU_SUBTYPE_ARM_V5TEJ); -+ } -+ case CPU_SUBTYPE_ARM_V4T: -+ return((cpusubtype2 & ~CPU_SUBTYPE_MASK)); -+ default: -+ return((cpu_subtype_t)-1); -+ } -+ - default: - return((cpu_subtype_t)-1); - } -Index: odcctools-9.2-ld/libmacho/get_end.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/get_end.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/get_end.c 2013-09-03 21:08:01.865209516 +0000 -@@ -25,13 +25,7 @@ - #include <mach-o/ldsyms.h> - #include <mach-o/getsect.h> - #ifndef __OPENSTEP__ -- --#ifdef __LP64__ --extern struct mach_header_64 *_NSGetMachExecuteHeader(void); --#else /* !defined(__LP64__) */ - #include <crt_externs.h> --#endif /* !defined(__LP64__) */ -- - #else /* defined(__OPENSTEP__) */ - #ifdef __DYNAMIC__ - #include "mach-o/dyld.h" /* defines _dyld_lookup_and_bind() */ -@@ -49,7 +43,7 @@ - #define SETUP_VAR(var) \ - if ( var ## _pointer == 0) { \ - _dyld_lookup_and_bind( STRINGIFY(_ ## var), \ -- (unsigned long *) & var ## _pointer, 0); \ -+ (uint32_t *) & var ## _pointer, 0); \ - } - #define USE_VAR(var) (* var ## _pointer) - #endif -@@ -70,13 +64,13 @@ - { - #ifndef __LP64__ - -- static struct mach_header *mhp = NULL; - struct segment_command *sgp; -- unsigned long i, _end; -+ unsigned long _end; -+ uint32_t i; - #ifndef __OPENSTEP__ -- if(mhp == NULL) -- mhp = _NSGetMachExecuteHeader(); -+ struct mach_header *mhp = _NSGetMachExecuteHeader(); - #else /* defined(__OPENSTEP__) */ -+ static struct mach_header *mhp = NULL; - DECLARE_VAR(_mh_execute_header, struct mach_header); - SETUP_VAR(_mh_execute_header); - -@@ -95,12 +89,11 @@ - - #else /* defined(__LP64__) */ - -- static struct mach_header_64 *mhp = NULL; -+ struct mach_header_64 *mhp = _NSGetMachExecuteHeader(); - struct segment_command_64 *sgp; -- unsigned long i, _end; -+ unsigned long _end; -+ uint32_t i; - -- if(mhp == NULL) -- mhp = _NSGetMachExecuteHeader(); - _end = 0; - sgp = (struct segment_command_64 *) - ((char *)mhp + sizeof(struct mach_header_64)); -Index: odcctools-9.2-ld/libmacho/getsecbyname.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/getsecbyname.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/getsecbyname.c 2013-09-03 21:08:01.865209516 +0000 -@@ -28,13 +28,7 @@ - #include <mach-o/dyld.h> /* defines _dyld_lookup_and_bind() */ - #endif /* defined(__DYNAMIC__) */ - #ifndef __OPENSTEP__ -- --#ifdef __LP64__ --extern struct mach_header_64 *_NSGetMachExecuteHeader(void); --#else /* !defined(__LP64__) */ - #include <crt_externs.h> --#endif /* !defined(__LP64__) */ -- - #else /* defined(__OPENSTEP__) */ - - #if !defined(__DYNAMIC__) -@@ -49,7 +43,7 @@ - #define SETUP_VAR(var) \ - if ( var ## _pointer == NULL) { \ - _dyld_lookup_and_bind( STRINGIFY(_ ## var), \ -- (unsigned long *) & var ## _pointer, NULL); \ -+ (uint32_t *) & var ## _pointer, NULL); \ - } - #define USE_VAR(var) (* var ## _pointer) - #endif -@@ -68,7 +62,7 @@ - { - struct segment_command *sgp; - struct section *sp; -- unsigned long i, j; -+ uint32_t i, j; - - sgp = (struct segment_command *) - ((char *)mhp + sizeof(struct mach_header)); -@@ -106,7 +100,7 @@ - { - struct segment_command_64 *sgp; - struct section_64 *sp; -- unsigned long i, j; -+ uint32_t i, j; - - sgp = (struct segment_command_64 *) - ((char *)mhp + sizeof(struct mach_header_64)); -@@ -147,12 +141,12 @@ - { - struct segment_command *sgp; - struct section *sp; -- unsigned long i, j; -+ uint32_t i, j; - - sgp = (struct segment_command *) - ((char *)mhp + sizeof(struct mach_header)); - for(i = 0; i < mhp->ncmds; i++){ -- if(sgp->cmd == (fSwap ? NXSwapLong(LC_SEGMENT) : LC_SEGMENT)) { -+ if(sgp->cmd == (fSwap ? OSSwapInt32(LC_SEGMENT) : LC_SEGMENT)) { - - if (fSwap) { - #ifdef __LITTLE_ENDIAN__ -@@ -188,7 +182,7 @@ - sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); - } else { - sgp = (struct segment_command *)((char *)sgp + -- (fSwap ? NXSwapLong(sgp->cmdsize) : sgp->cmdsize)); -+ (fSwap ? OSSwapInt32(sgp->cmdsize) : sgp->cmdsize)); - } - } - return((struct section *)0); -@@ -206,11 +200,10 @@ - const char *segname, - const char *sectname) - { -- static struct mach_header *mhp = NULL; - #ifndef __OPENSTEP__ -- if(mhp == NULL) -- mhp = _NSGetMachExecuteHeader(); -+ struct mach_header *mhp = _NSGetMachExecuteHeader(); - #else /* defined(__OPENSTEP__) */ -+ static struct mach_header *mhp = NULL; - DECLARE_VAR(_mh_execute_header, struct mach_header); - SETUP_VAR(_mh_execute_header); - mhp = (struct mach_header *)(& USE_VAR(_mh_execute_header)); -@@ -225,10 +218,8 @@ - const char *segname, - const char *sectname) - { -- static struct mach_header_64 *mhp = NULL; -+ struct mach_header_64 *mhp = _NSGetMachExecuteHeader(); - -- if(mhp == NULL) -- mhp = _NSGetMachExecuteHeader(); - return(getsectbynamefromheader_64(mhp, segname, sectname)); - } - -@@ -262,6 +253,185 @@ - } - - /* -+ * This routine returns the a pointer to the section contents of the named -+ * section in the named segment if it exists in the image pointed to by the -+ * mach header. Otherwise it returns zero. -+ */ -+#ifndef __LP64__ -+ -+uint8_t * -+getsectiondata( -+const struct mach_header *mhp, -+const char *segname, -+const char *sectname, -+unsigned long *size) -+{ -+ struct segment_command *sgp, *zero; -+ struct section *sp, *find; -+ uint32_t i, j; -+ -+ zero = 0; -+ find = 0; -+ sp = 0; -+ sgp = (struct segment_command *) -+ ((char *)mhp + sizeof(struct mach_header)); -+ for(i = 0; i < mhp->ncmds; i++){ -+ if(sgp->cmd == LC_SEGMENT){ -+ if(zero == 0 && sgp->fileoff == 0 && sgp->nsects != 0){ -+ zero = sgp; -+ if(find != 0) -+ goto done; -+ } -+ if(find == 0 && -+ strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0){ -+ sp = (struct section *)((char *)sgp + -+ sizeof(struct segment_command)); -+ for(j = 0; j < sgp->nsects; j++){ -+ if(strncmp(sp->sectname, sectname, -+ sizeof(sp->sectname)) == 0 && -+ strncmp(sp->segname, segname, -+ sizeof(sp->segname)) == 0){ -+ find = sp; -+ if(zero != 0) -+ goto done; -+ } -+ sp = (struct section *)((char *)sp + -+ sizeof(struct section)); -+ } -+ } -+ } -+ sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); -+ } -+ return(0); -+done: -+ *size = sp->size; -+ return((uint8_t *)((uintptr_t)mhp - zero->vmaddr + sp->addr)); -+} -+ -+uint8_t * -+getsegmentdata( -+const struct mach_header *mhp, -+const char *segname, -+unsigned long *size) -+{ -+ struct segment_command *sgp, *zero, *find; -+ uint32_t i; -+ -+ zero = 0; -+ find = 0; -+ sgp = (struct segment_command *) -+ ((char *)mhp + sizeof(struct mach_header)); -+ for(i = 0; i < mhp->ncmds; i++){ -+ if(sgp->cmd == LC_SEGMENT){ -+ if(zero == 0 && sgp->fileoff == 0 && sgp->nsects != 0){ -+ zero = sgp; -+ if(find != 0) -+ goto done; -+ } -+ if(find == 0 && -+ strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0){ -+ find = sgp; -+ if(zero != 0) -+ goto done; -+ } -+ } -+ sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); -+ } -+ return(0); -+done: -+ *size = sgp->vmsize; -+ return((uint8_t *)((uintptr_t)mhp - zero->vmaddr + sgp->vmaddr)); -+} -+ -+#else /* defined(__LP64__) */ -+ -+uint8_t * -+getsectiondata( -+const struct mach_header_64 *mhp, -+const char *segname, -+const char *sectname, -+unsigned long *size) -+{ -+ struct segment_command_64 *sgp, *zero; -+ struct section_64 *sp, *find; -+ uint32_t i, j; -+ -+ zero = 0; -+ find = 0; -+ sp = 0; -+ sgp = (struct segment_command_64 *) -+ ((char *)mhp + sizeof(struct mach_header_64)); -+ for(i = 0; i < mhp->ncmds; i++){ -+ if(sgp->cmd == LC_SEGMENT_64){ -+ if(zero == 0 && sgp->fileoff == 0 && sgp->nsects != 0){ -+ zero = sgp; -+ if(find != 0) -+ goto done; -+ } -+ if(find == 0 && -+ strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0){ -+ sp = (struct section_64 *)((char *)sgp + -+ sizeof(struct segment_command_64)); -+ for(j = 0; j < sgp->nsects; j++){ -+ if(strncmp(sp->sectname, sectname, -+ sizeof(sp->sectname)) == 0 && -+ strncmp(sp->segname, segname, -+ sizeof(sp->segname)) == 0){ -+ find = sp; -+ if(zero != 0) -+ goto done; -+ } -+ sp = (struct section_64 *)((char *)sp + -+ sizeof(struct section_64)); -+ } -+ } -+ } -+ sgp = (struct segment_command_64 *)((char *)sgp + sgp->cmdsize); -+ } -+ return(0); -+done: -+ *size = sp->size; -+ return((uint8_t *)((uintptr_t)mhp - zero->vmaddr + sp->addr)); -+} -+ -+uint8_t * -+getsegmentdata( -+const struct mach_header_64 *mhp, -+const char *segname, -+unsigned long *size) -+{ -+ struct segment_command_64 *sgp, *zero, *find; -+ uint32_t i; -+ -+ zero = 0; -+ find = 0; -+ sgp = (struct segment_command_64 *) -+ ((char *)mhp + sizeof(struct mach_header_64)); -+ for(i = 0; i < mhp->ncmds; i++){ -+ if(sgp->cmd == LC_SEGMENT_64){ -+ if(zero == 0 && sgp->fileoff == 0 && sgp->nsects != 0){ -+ zero = sgp; -+ if(find != 0) -+ goto done; -+ } -+ if(find == 0 && -+ strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0){ -+ find = sgp; -+ if(zero != 0) -+ goto done; -+ } -+ } -+ sgp = (struct segment_command_64 *)((char *)sgp + sgp->cmdsize); -+ } -+ return(0); -+done: -+ *size = sgp->vmsize; -+ return((uint8_t *)((uintptr_t)mhp - zero->vmaddr + sgp->vmaddr)); -+} -+ -+#endif /* defined(__LP64__) */ -+ -+/* - * This routine returns the a pointer to the data for the named section in the - * named segment if it exist in the mach header passed to it. Also it returns - * the size of the section data indirectly through the pointer size. Otherwise -@@ -282,7 +452,7 @@ - return(NULL); - } - *size = sp->size; -- return((char *)((unsigned long)(sp->addr))); -+ return((char *)((uintptr_t)(sp->addr))); - } - - /* -@@ -306,7 +476,7 @@ - return(NULL); - } - *size = sp->size; -- return((char *)((unsigned long)(sp->addr))); -+ return((char *)((uintptr_t)(sp->addr))); - } - - #ifdef __DYNAMIC__ -@@ -324,7 +494,8 @@ - const char *sectname, - unsigned long *size) - { -- unsigned long i, n, vmaddr_slide; -+ uint32_t i, n; -+ uintptr_t vmaddr_slide; - #ifndef __LP64__ - struct mach_header *mh; - const struct section *s; -Index: odcctools-9.2-ld/libmacho/getsegbyname.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/getsegbyname.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/getsegbyname.c 2013-09-03 21:08:01.869209516 +0000 -@@ -25,11 +25,7 @@ - #ifndef __OPENSTEP__ - - #ifndef RLD --#ifdef __LP64__ --extern struct mach_header_64 *_NSGetMachExecuteHeader(void); --#else /* !defined(__LP64__) */ - #include <crt_externs.h> --#endif /* !defined(__LP64__) */ - #endif /* !defined(RLD) */ - - #else /* defined(__OPENSTEP__) */ -@@ -49,7 +45,7 @@ - #define SETUP_VAR(var) \ - if ( var ## _pointer == 0) { \ - _dyld_lookup_and_bind( STRINGIFY(_ ## var), \ -- (unsigned long *) & var ## _pointer, 0); \ -+ (uint32_t *) & var ## _pointer, 0); \ - } - #define USE_VAR(var) (* var ## _pointer) - #endif -@@ -68,14 +64,13 @@ - getsegbyname( - char *segname) - { -- static struct mach_header *mhp = NULL; - struct segment_command *sgp; -- unsigned long i; -+ uint32_t i; - #ifndef RLD - #ifndef __OPENSTEP__ -- if(mhp == NULL) -- mhp = _NSGetMachExecuteHeader(); -+ struct mach_header *mhp = _NSGetMachExecuteHeader(); - #else /* defined(__OPENSTEP__) */ -+ static struct mach_header *mhp = NULL; - DECLARE_VAR(_mh_execute_header, struct mach_header); - SETUP_VAR(_mh_execute_header); - mhp = (struct mach_header *)(& USE_VAR(_mh_execute_header)); -@@ -101,15 +96,14 @@ - getsegbyname( - char *segname) - { -- static struct mach_header_64 *mhp = NULL; -+ struct mach_header_64 *mhp = NULL; - struct segment_command_64 *sgp; -- unsigned long i; -+ uint32_t i; - -- if(mhp == NULL) - #ifndef RLD -- mhp = _NSGetMachExecuteHeader(); -+ mhp = _NSGetMachExecuteHeader(); - #else /* defined(RLD) */ -- mhp = (struct mach_header_64 *)(&_mh_execute_header); -+ mhp = (struct mach_header_64 *)(&_mh_execute_header); - #endif /* defined(RLD) */ - - sgp = (struct segment_command_64 *) -Index: odcctools-9.2-ld/libmacho/i386_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/i386_swap.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/i386_swap.c 2013-09-03 21:08:01.869209516 +0000 -@@ -132,6 +132,7 @@ - #define __dr7 dr7 - - #include <string.h> -+#include <libkern/OSByteOrder.h> - #include <mach-o/i386/swap.h> - - void -@@ -139,22 +140,22 @@ - i386_thread_state_t *cpu, - enum NXByteOrder target_byte_sex) - { -- cpu->eax = NXSwapLong(cpu->eax); -- cpu->ebx = NXSwapLong(cpu->ebx); -- cpu->ecx = NXSwapLong(cpu->ecx); -- cpu->edx = NXSwapLong(cpu->edx); -- cpu->edi = NXSwapLong(cpu->edi); -- cpu->esi = NXSwapLong(cpu->esi); -- cpu->ebp = NXSwapLong(cpu->ebp); -- cpu->esp = NXSwapLong(cpu->esp); -- cpu->ss = NXSwapLong(cpu->ss); -- cpu->eflags = NXSwapLong(cpu->eflags); -- cpu->eip = NXSwapLong(cpu->eip); -- cpu->cs = NXSwapLong(cpu->cs); -- cpu->ds = NXSwapLong(cpu->ds); -- cpu->es = NXSwapLong(cpu->es); -- cpu->fs = NXSwapLong(cpu->fs); -- cpu->gs = NXSwapLong(cpu->gs); -+ cpu->eax = OSSwapInt32(cpu->eax); -+ cpu->ebx = OSSwapInt32(cpu->ebx); -+ cpu->ecx = OSSwapInt32(cpu->ecx); -+ cpu->edx = OSSwapInt32(cpu->edx); -+ cpu->edi = OSSwapInt32(cpu->edi); -+ cpu->esi = OSSwapInt32(cpu->esi); -+ cpu->ebp = OSSwapInt32(cpu->ebp); -+ cpu->esp = OSSwapInt32(cpu->esp); -+ cpu->ss = OSSwapInt32(cpu->ss); -+ cpu->eflags = OSSwapInt32(cpu->eflags); -+ cpu->eip = OSSwapInt32(cpu->eip); -+ cpu->cs = OSSwapInt32(cpu->cs); -+ cpu->ds = OSSwapInt32(cpu->ds); -+ cpu->es = OSSwapInt32(cpu->es); -+ cpu->fs = OSSwapInt32(cpu->fs); -+ cpu->gs = OSSwapInt32(cpu->gs); - } - - #ifdef x86_THREAD_STATE64 -@@ -163,27 +164,27 @@ - x86_thread_state64_t *cpu, - enum NXByteOrder target_byte_sex) - { -- cpu->rax = NXSwapLongLong(cpu->rax); -- cpu->rbx = NXSwapLongLong(cpu->rbx); -- cpu->rcx = NXSwapLongLong(cpu->rcx); -- cpu->rdx = NXSwapLongLong(cpu->rdx); -- cpu->rdi = NXSwapLongLong(cpu->rdi); -- cpu->rsi = NXSwapLongLong(cpu->rsi); -- cpu->rbp = NXSwapLongLong(cpu->rbp); -- cpu->rsp = NXSwapLongLong(cpu->rsp); -- cpu->rflags = NXSwapLongLong(cpu->rflags); -- cpu->rip = NXSwapLongLong(cpu->rip); -- cpu->r8 = NXSwapLongLong(cpu->r8); -- cpu->r9 = NXSwapLongLong(cpu->r9); -- cpu->r10 = NXSwapLongLong(cpu->r10); -- cpu->r11 = NXSwapLongLong(cpu->r11); -- cpu->r12 = NXSwapLongLong(cpu->r12); -- cpu->r13 = NXSwapLongLong(cpu->r13); -- cpu->r14 = NXSwapLongLong(cpu->r14); -- cpu->r15 = NXSwapLongLong(cpu->r15); -- cpu->cs = NXSwapLongLong(cpu->cs); -- cpu->fs = NXSwapLongLong(cpu->fs); -- cpu->gs = NXSwapLongLong(cpu->gs); -+ cpu->rax = OSSwapInt64(cpu->rax); -+ cpu->rbx = OSSwapInt64(cpu->rbx); -+ cpu->rcx = OSSwapInt64(cpu->rcx); -+ cpu->rdx = OSSwapInt64(cpu->rdx); -+ cpu->rdi = OSSwapInt64(cpu->rdi); -+ cpu->rsi = OSSwapInt64(cpu->rsi); -+ cpu->rbp = OSSwapInt64(cpu->rbp); -+ cpu->rsp = OSSwapInt64(cpu->rsp); -+ cpu->rflags = OSSwapInt64(cpu->rflags); -+ cpu->rip = OSSwapInt64(cpu->rip); -+ cpu->r8 = OSSwapInt64(cpu->r8); -+ cpu->r9 = OSSwapInt64(cpu->r9); -+ cpu->r10 = OSSwapInt64(cpu->r10); -+ cpu->r11 = OSSwapInt64(cpu->r11); -+ cpu->r12 = OSSwapInt64(cpu->r12); -+ cpu->r13 = OSSwapInt64(cpu->r13); -+ cpu->r14 = OSSwapInt64(cpu->r14); -+ cpu->r15 = OSSwapInt64(cpu->r15); -+ cpu->cs = OSSwapInt64(cpu->cs); -+ cpu->fs = OSSwapInt64(cpu->fs); -+ cpu->gs = OSSwapInt64(cpu->gs); - } - - void -@@ -191,8 +192,8 @@ - x86_state_hdr_t *hdr, - enum NXByteOrder target_byte_sex) - { -- hdr->flavor = NXSwapLong(hdr->flavor); -- hdr->count = NXSwapLong(hdr->count); -+ hdr->flavor = OSSwapInt32(hdr->flavor); -+ hdr->count = OSSwapInt32(hdr->count); - } - - void -@@ -247,13 +248,13 @@ - - host_byte_sex = NXHostByteOrder(); - -- fpu->fpu_reserved[0] = NXSwapLong(fpu->fpu_reserved[0]); -- fpu->fpu_reserved[1] = NXSwapLong(fpu->fpu_reserved[1]); -+ fpu->fpu_reserved[0] = OSSwapInt32(fpu->fpu_reserved[0]); -+ fpu->fpu_reserved[1] = OSSwapInt32(fpu->fpu_reserved[1]); - - if(target_byte_sex == host_byte_sex){ - memcpy(&sfpc, &(fpu->fpu_fcw), - sizeof(struct swapped_fp_control)); -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - fpu->fpu_fcw.rc = sfpc.u.fields.rc; - fpu->fpu_fcw.pc = sfpc.u.fields.pc; - fpu->fpu_fcw.precis = sfpc.u.fields.precis; -@@ -265,7 +266,7 @@ - - memcpy(&sfps, &(fpu->fpu_fsw), - sizeof(struct swapped_fp_status)); -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - fpu->fpu_fsw.busy = sfps.u.fields.busy; - fpu->fpu_fsw.c3 = sfps.u.fields.c3; - fpu->fpu_fsw.tos = sfps.u.fields.tos; -@@ -290,7 +291,7 @@ - sfpc.u.fields.zdiv = fpu->fpu_fcw.zdiv; - sfpc.u.fields.denorm = fpu->fpu_fcw.denorm; - sfpc.u.fields.invalid = fpu->fpu_fcw.invalid; -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - memcpy(&(fpu->fpu_fcw), &sfpc, - sizeof(struct swapped_fp_control)); - -@@ -308,20 +309,20 @@ - sfps.u.fields.zdiv = fpu->fpu_fsw.zdiv; - sfps.u.fields.denorm = fpu->fpu_fsw.denorm; - sfps.u.fields.invalid = fpu->fpu_fsw.invalid; -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - memcpy(&(fpu->fpu_fsw), &sfps, - sizeof(struct swapped_fp_status)); - } -- fpu->fpu_fop = NXSwapShort(fpu->fpu_fop); -- fpu->fpu_ip = NXSwapLong(fpu->fpu_ip); -- fpu->fpu_cs = NXSwapShort(fpu->fpu_cs); -- fpu->fpu_rsrv2 = NXSwapShort(fpu->fpu_rsrv2); -- fpu->fpu_dp = NXSwapLong(fpu->fpu_dp); -- fpu->fpu_ds = NXSwapShort(fpu->fpu_ds); -- fpu->fpu_rsrv3 = NXSwapShort(fpu->fpu_rsrv3); -- fpu->fpu_mxcsr = NXSwapLong(fpu->fpu_mxcsr); -- fpu->fpu_mxcsrmask = NXSwapLong(fpu->fpu_mxcsrmask); -- fpu->fpu_reserved1 = NXSwapLong(fpu->fpu_reserved1); -+ fpu->fpu_fop = OSSwapInt16(fpu->fpu_fop); -+ fpu->fpu_ip = OSSwapInt32(fpu->fpu_ip); -+ fpu->fpu_cs = OSSwapInt16(fpu->fpu_cs); -+ fpu->fpu_rsrv2 = OSSwapInt16(fpu->fpu_rsrv2); -+ fpu->fpu_dp = OSSwapInt32(fpu->fpu_dp); -+ fpu->fpu_ds = OSSwapInt16(fpu->fpu_ds); -+ fpu->fpu_rsrv3 = OSSwapInt16(fpu->fpu_rsrv3); -+ fpu->fpu_mxcsr = OSSwapInt32(fpu->fpu_mxcsr); -+ fpu->fpu_mxcsrmask = OSSwapInt32(fpu->fpu_mxcsrmask); -+ fpu->fpu_reserved1 = OSSwapInt32(fpu->fpu_reserved1); - } - - void -@@ -329,9 +330,9 @@ - x86_exception_state64_t *exc, - enum NXByteOrder target_byte_sex) - { -- exc->trapno = NXSwapLong(exc->trapno); -- exc->err = NXSwapLong(exc->err); -- exc->faultvaddr = NXSwapLongLong(exc->faultvaddr); -+ exc->trapno = OSSwapInt32(exc->trapno); -+ exc->err = OSSwapInt32(exc->err); -+ exc->faultvaddr = OSSwapInt64(exc->faultvaddr); - } - - void -@@ -370,9 +371,13 @@ - - swap_x86_state_hdr(&fpu->fsh, target_byte_sex); - -+/* current i386 thread states */ -+#if i386_THREAD_STATE == 1 - if(hdr.flavor == x86_FLOAT_STATE32) - swap_i386_float_state(&fpu->ufs.fs32, target_byte_sex); -- else if(hdr.flavor == x86_FLOAT_STATE64) -+ else -+#endif -+ if(hdr.flavor == x86_FLOAT_STATE64) - swap_x86_float_state64(&fpu->ufs.fs64, target_byte_sex); - } - -@@ -391,9 +396,13 @@ - - swap_x86_state_hdr(&exc->esh, target_byte_sex); - -+/* current i386 thread states */ -+#if i386_THREAD_STATE == 1 - if(hdr.flavor == x86_EXCEPTION_STATE32) - swap_i386_exception_state(&exc->ues.es32, target_byte_sex); -- else if(hdr.flavor == x86_EXCEPTION_STATE64) -+ else -+#endif -+ if(hdr.flavor == x86_EXCEPTION_STATE64) - swap_x86_exception_state64(&exc->ues.es64, target_byte_sex); - } - -@@ -402,14 +411,14 @@ - x86_debug_state32_t *debug, - enum NXByteOrder target_byte_sex) - { -- debug->dr0 = NXSwapLong(debug->dr0); -- debug->dr1 = NXSwapLong(debug->dr1); -- debug->dr2 = NXSwapLong(debug->dr2); -- debug->dr3 = NXSwapLong(debug->dr3); -- debug->dr4 = NXSwapLong(debug->dr4); -- debug->dr5 = NXSwapLong(debug->dr5); -- debug->dr6 = NXSwapLong(debug->dr6); -- debug->dr7 = NXSwapLong(debug->dr7); -+ debug->dr0 = OSSwapInt32(debug->dr0); -+ debug->dr1 = OSSwapInt32(debug->dr1); -+ debug->dr2 = OSSwapInt32(debug->dr2); -+ debug->dr3 = OSSwapInt32(debug->dr3); -+ debug->dr4 = OSSwapInt32(debug->dr4); -+ debug->dr5 = OSSwapInt32(debug->dr5); -+ debug->dr6 = OSSwapInt32(debug->dr6); -+ debug->dr7 = OSSwapInt32(debug->dr7); - } - - void -@@ -417,14 +426,14 @@ - x86_debug_state64_t *debug, - enum NXByteOrder target_byte_sex) - { -- debug->dr0 = NXSwapLongLong(debug->dr0); -- debug->dr1 = NXSwapLongLong(debug->dr1); -- debug->dr2 = NXSwapLongLong(debug->dr2); -- debug->dr3 = NXSwapLongLong(debug->dr3); -- debug->dr4 = NXSwapLongLong(debug->dr4); -- debug->dr5 = NXSwapLongLong(debug->dr5); -- debug->dr6 = NXSwapLongLong(debug->dr6); -- debug->dr7 = NXSwapLongLong(debug->dr7); -+ debug->dr0 = OSSwapInt64(debug->dr0); -+ debug->dr1 = OSSwapInt64(debug->dr1); -+ debug->dr2 = OSSwapInt64(debug->dr2); -+ debug->dr3 = OSSwapInt64(debug->dr3); -+ debug->dr4 = OSSwapInt64(debug->dr4); -+ debug->dr5 = OSSwapInt64(debug->dr5); -+ debug->dr6 = OSSwapInt64(debug->dr6); -+ debug->dr7 = OSSwapInt64(debug->dr7); - } - - void -@@ -506,13 +515,13 @@ - - host_byte_sex = NXHostByteOrder(); - -- fpu->fpu_reserved[0] = NXSwapLong(fpu->fpu_reserved[0]); -- fpu->fpu_reserved[1] = NXSwapLong(fpu->fpu_reserved[1]); -+ fpu->fpu_reserved[0] = OSSwapInt32(fpu->fpu_reserved[0]); -+ fpu->fpu_reserved[1] = OSSwapInt32(fpu->fpu_reserved[1]); - - if(target_byte_sex == host_byte_sex){ - memcpy(&sfpc, &(fpu->fpu_fcw), - sizeof(struct swapped_fp_control)); -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - fpu->fpu_fcw.rc = sfpc.u.fields.rc; - fpu->fpu_fcw.pc = sfpc.u.fields.pc; - fpu->fpu_fcw.precis = sfpc.u.fields.precis; -@@ -524,7 +533,7 @@ - - memcpy(&sfps, &(fpu->fpu_fsw), - sizeof(struct swapped_fp_status)); -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - fpu->fpu_fsw.busy = sfps.u.fields.busy; - fpu->fpu_fsw.c3 = sfps.u.fields.c3; - fpu->fpu_fsw.tos = sfps.u.fields.tos; -@@ -549,7 +558,7 @@ - sfpc.u.fields.zdiv = fpu->fpu_fcw.zdiv; - sfpc.u.fields.denorm = fpu->fpu_fcw.denorm; - sfpc.u.fields.invalid = fpu->fpu_fcw.invalid; -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - memcpy(&(fpu->fpu_fcw), &sfpc, - sizeof(struct swapped_fp_control)); - -@@ -567,20 +576,20 @@ - sfps.u.fields.zdiv = fpu->fpu_fsw.zdiv; - sfps.u.fields.denorm = fpu->fpu_fsw.denorm; - sfps.u.fields.invalid = fpu->fpu_fsw.invalid; -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - memcpy(&(fpu->fpu_fsw), &sfps, - sizeof(struct swapped_fp_status)); - } -- fpu->fpu_fop = NXSwapShort(fpu->fpu_fop); -- fpu->fpu_ip = NXSwapLong(fpu->fpu_ip); -- fpu->fpu_cs = NXSwapShort(fpu->fpu_cs); -- fpu->fpu_rsrv2 = NXSwapShort(fpu->fpu_rsrv2); -- fpu->fpu_dp = NXSwapLong(fpu->fpu_dp); -- fpu->fpu_ds = NXSwapShort(fpu->fpu_ds); -- fpu->fpu_rsrv3 = NXSwapShort(fpu->fpu_rsrv3); -- fpu->fpu_mxcsr = NXSwapLong(fpu->fpu_mxcsr); -- fpu->fpu_mxcsrmask = NXSwapLong(fpu->fpu_mxcsrmask); -- fpu->fpu_reserved1 = NXSwapLong(fpu->fpu_reserved1); -+ fpu->fpu_fop = OSSwapInt16(fpu->fpu_fop); -+ fpu->fpu_ip = OSSwapInt32(fpu->fpu_ip); -+ fpu->fpu_cs = OSSwapInt16(fpu->fpu_cs); -+ fpu->fpu_rsrv2 = OSSwapInt16(fpu->fpu_rsrv2); -+ fpu->fpu_dp = OSSwapInt32(fpu->fpu_dp); -+ fpu->fpu_ds = OSSwapInt16(fpu->fpu_ds); -+ fpu->fpu_rsrv3 = OSSwapInt16(fpu->fpu_rsrv3); -+ fpu->fpu_mxcsr = OSSwapInt32(fpu->fpu_mxcsr); -+ fpu->fpu_mxcsrmask = OSSwapInt32(fpu->fpu_mxcsrmask); -+ fpu->fpu_reserved1 = OSSwapInt32(fpu->fpu_reserved1); - - #endif /* !defined(i386_EXCEPTION_STATE_COUNT) */ - } -@@ -590,9 +599,9 @@ - i386_exception_state_t *exc, - enum NXByteOrder target_byte_sex) - { -- exc->trapno = NXSwapLong(exc->trapno); -- exc->err = NXSwapLong(exc->err); -- exc->faultvaddr = NXSwapLong(exc->faultvaddr); -+ exc->trapno = OSSwapInt32(exc->trapno); -+ exc->err = OSSwapInt32(exc->err); -+ exc->faultvaddr = OSSwapInt32(exc->faultvaddr); - } - #endif /* i386_THREAD_STATE == 1 */ - -@@ -690,18 +699,18 @@ - } ss; - - enum NXByteOrder host_byte_sex; -- unsigned long i; -+ int i; - - host_byte_sex = NXHostByteOrder(); - -- fpu->environ.ip = NXSwapLong(fpu->environ.ip); -- fpu->environ.opcode = NXSwapShort(fpu->environ.opcode); -- fpu->environ.dp = NXSwapLong(fpu->environ.dp); -+ fpu->environ.ip = OSSwapInt32(fpu->environ.ip); -+ fpu->environ.opcode = OSSwapInt16(fpu->environ.opcode); -+ fpu->environ.dp = OSSwapInt32(fpu->environ.dp); - - if(target_byte_sex == host_byte_sex){ - memcpy(&sfpc, &(fpu->environ.control), - sizeof(struct swapped_fp_control)); -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - fpu->environ.control.rc = sfpc.u.fields.rc; - fpu->environ.control.pc = sfpc.u.fields.pc; - fpu->environ.control.precis = sfpc.u.fields.precis; -@@ -713,7 +722,7 @@ - - memcpy(&sfps, &(fpu->environ.status), - sizeof(struct swapped_fp_status)); -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - fpu->environ.status.busy = sfps.u.fields.busy; - fpu->environ.status.c3 = sfps.u.fields.c3; - fpu->environ.status.tos = sfps.u.fields.tos; -@@ -731,7 +740,7 @@ - - memcpy(&sfpt, &(fpu->environ.tag), - sizeof(struct swapped_fp_tag)); -- sfpt.u.half = NXSwapShort(sfpt.u.half); -+ sfpt.u.half = OSSwapInt16(sfpt.u.half); - fpu->environ.tag.tag7 = sfpt.u.fields.tag7; - fpu->environ.tag.tag6 = sfpt.u.fields.tag6; - fpu->environ.tag.tag5 = sfpt.u.fields.tag5; -@@ -743,14 +752,14 @@ - - memcpy(&ss, &(fpu->environ.cs), - sizeof(struct swapped_sel)); -- ss.u.half = NXSwapShort(ss.u.half); -+ ss.u.half = OSSwapInt16(ss.u.half); - fpu->environ.cs.index = ss.u.fields.index; - fpu->environ.cs.ti = ss.u.fields.ti; - fpu->environ.cs.rpl = ss.u.fields.rpl; - - memcpy(&ss, &(fpu->environ.ds), - sizeof(struct swapped_sel)); -- ss.u.half = NXSwapShort(ss.u.half); -+ ss.u.half = OSSwapInt16(ss.u.half); - fpu->environ.ds.index = ss.u.fields.index; - fpu->environ.ds.ti = ss.u.fields.ti; - fpu->environ.ds.rpl = ss.u.fields.rpl; -@@ -758,11 +767,11 @@ - for(i = 0; i < 8; i++){ - memcpy(&sfpd, &(fpu->stack.ST[i]), - sizeof(struct swapped_fp_data_reg)); -- fpu->stack.ST[i].mant = NXSwapShort(sfpd.mant); -- fpu->stack.ST[i].mant1 = NXSwapShort(sfpd.mant1); -- fpu->stack.ST[i].mant2 = NXSwapShort(sfpd.mant2); -- fpu->stack.ST[i].mant3 = NXSwapShort(sfpd.mant3); -- sfpd.u.half = NXSwapShort(sfpd.u.half); -+ fpu->stack.ST[i].mant = OSSwapInt16(sfpd.mant); -+ fpu->stack.ST[i].mant1 = OSSwapInt16(sfpd.mant1); -+ fpu->stack.ST[i].mant2 = OSSwapInt16(sfpd.mant2); -+ fpu->stack.ST[i].mant3 = OSSwapInt16(sfpd.mant3); -+ sfpd.u.half = OSSwapInt16(sfpd.u.half); - fpu->stack.ST[i].exp = sfpd.u.fields.exp; - fpu->stack.ST[i].sign = sfpd.u.fields.sign; - } -@@ -776,7 +785,7 @@ - sfpc.u.fields.zdiv = fpu->environ.control.zdiv; - sfpc.u.fields.denorm = fpu->environ.control.denorm; - sfpc.u.fields.invalid = fpu->environ.control.invalid; -- sfpc.u.half = NXSwapShort(sfpc.u.half); -+ sfpc.u.half = OSSwapInt16(sfpc.u.half); - memcpy(&(fpu->environ.control), &sfpc, - sizeof(struct swapped_fp_control)); - -@@ -794,7 +803,7 @@ - sfps.u.fields.zdiv = fpu->environ.status.zdiv; - sfps.u.fields.denorm = fpu->environ.status.denorm; - sfps.u.fields.invalid = fpu->environ.status.invalid; -- sfps.u.half = NXSwapShort(sfps.u.half); -+ sfps.u.half = OSSwapInt16(sfps.u.half); - memcpy(&(fpu->environ.status), &sfps, - sizeof(struct swapped_fp_status)); - -@@ -806,32 +815,32 @@ - sfpt.u.fields.tag2 = fpu->environ.tag.tag2; - sfpt.u.fields.tag1 = fpu->environ.tag.tag1; - sfpt.u.fields.tag0 = fpu->environ.tag.tag0; -- sfpt.u.half = NXSwapShort(sfpt.u.half); -+ sfpt.u.half = OSSwapInt16(sfpt.u.half); - memcpy(&(fpu->environ.tag), &sfpt, - sizeof(struct swapped_fp_tag)); - - ss.u.fields.index = fpu->environ.cs.index; - ss.u.fields.ti = fpu->environ.cs.ti; - ss.u.fields.rpl = fpu->environ.cs.rpl; -- ss.u.half = NXSwapShort(ss.u.half); -+ ss.u.half = OSSwapInt16(ss.u.half); - memcpy(&(fpu->environ.cs), &ss, - sizeof(struct swapped_sel)); - - ss.u.fields.index = fpu->environ.ds.index; - ss.u.fields.ti = fpu->environ.ds.ti; - ss.u.fields.rpl = fpu->environ.ds.rpl; -- ss.u.half = NXSwapShort(ss.u.half); -+ ss.u.half = OSSwapInt16(ss.u.half); - memcpy(&(fpu->environ.cs), &ss, - sizeof(struct swapped_sel)); - - for(i = 0; i < 8; i++){ -- sfpd.mant = NXSwapShort(fpu->stack.ST[i].mant); -- sfpd.mant1 = NXSwapShort(fpu->stack.ST[i].mant1); -- sfpd.mant2 = NXSwapShort(fpu->stack.ST[i].mant2); -- sfpd.mant3 = NXSwapShort(fpu->stack.ST[i].mant3); -+ sfpd.mant = OSSwapInt16(fpu->stack.ST[i].mant); -+ sfpd.mant1 = OSSwapInt16(fpu->stack.ST[i].mant1); -+ sfpd.mant2 = OSSwapInt16(fpu->stack.ST[i].mant2); -+ sfpd.mant3 = OSSwapInt16(fpu->stack.ST[i].mant3); - sfpd.u.fields.exp = fpu->stack.ST[i].exp; - sfpd.u.fields.sign = fpu->stack.ST[i].sign; -- sfpd.u.half = NXSwapShort(sfpd.u.half); -+ sfpd.u.half = OSSwapInt16(sfpd.u.half); - memcpy(&(fpu->stack.ST[i]), &sfpd, - sizeof(struct swapped_fp_data_reg)); - } -@@ -857,19 +866,19 @@ - wrtflt :1, - prot :1; - } pgfault; -- unsigned long word; -+ uint32_t word; - } u; - } sec; -- unsigned long word; -+ uint32_t word; - enum NXByteOrder host_byte_sex; - - host_byte_sex = NXHostByteOrder(); - -- exc->trapno = NXSwapLong(exc->trapno); -+ exc->trapno = OSSwapInt32(exc->trapno); - if(exc->trapno == 14){ - if(target_byte_sex == host_byte_sex){ - memcpy(&sec, &(exc->err), sizeof(struct swapped_err_code)); -- sec.u.word = NXSwapLong(sec.u.word); -+ sec.u.word = OSSwapInt32(sec.u.word); - exc->err.pgfault.user = sec.u.pgfault.user; - exc->err.pgfault.wrtflt = sec.u.pgfault.wrtflt; - exc->err.pgfault.prot = sec.u.pgfault.prot; -@@ -878,16 +887,16 @@ - sec.u.pgfault.prot = exc->err.pgfault.prot; - sec.u.pgfault.wrtflt = exc->err.pgfault.wrtflt; - sec.u.pgfault.user = exc->err.pgfault.user; -- sec.u.word = NXSwapLong(sec.u.word); -+ sec.u.word = OSSwapInt32(sec.u.word); - memcpy(&(exc->err), &sec, sizeof(struct swapped_err_code)); - } - } - else{ - if(target_byte_sex == host_byte_sex){ - memcpy(&sec, &(exc->err), sizeof(struct swapped_err_code)); -- sec.u.word = NXSwapLong(sec.u.word); -+ sec.u.word = OSSwapInt32(sec.u.word); - word = sec.u.normal.index; -- exc->err.normal.index = NXSwapLong(word); -+ exc->err.normal.index = OSSwapInt32(word); - exc->err.normal.tbl = sec.u.normal.tbl; - exc->err.normal.ext = sec.u.normal.ext; - } -@@ -895,8 +904,8 @@ - sec.u.normal.ext = exc->err.normal.ext; - sec.u.normal.tbl = exc->err.normal.tbl; - word = exc->err.normal.index; -- sec.u.normal.index = NXSwapLong(word); -- sec.u.word = NXSwapLong(sec.u.word); -+ sec.u.normal.index = OSSwapInt32(word); -+ sec.u.word = OSSwapInt32(sec.u.word); - memcpy(&(exc->err), &sec, sizeof(struct swapped_err_code)); - } - } -@@ -907,7 +916,7 @@ - i386_thread_cthreadstate_t *user, - enum NXByteOrder target_byte_sex) - { -- user->self = NXSwapLong(user->self); -+ user->self = OSSwapInt32(user->self); - } - #endif /* i386_THREAD_STATE == -1 */ - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/libmacho/i860_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/i860_swap.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/i860_swap.c 2013-09-03 21:08:01.873209515 +0000 -@@ -28,34 +28,34 @@ - struct i860_thread_state_regs *cpu, - enum NXByteOrder target_byte_sex) - { -- unsigned long i; -+ int i; - - for(i = 0; i < 31; i++) -- cpu->ireg[i] = NXSwapLong(cpu->ireg[i]); -+ cpu->ireg[i] = OSSwapInt32(cpu->ireg[i]); - for(i = 0; i < 30; i++) -- cpu->freg[i] = NXSwapLong(cpu->freg[i]); -- cpu->psr = NXSwapLong(cpu->psr); -- cpu->epsr = NXSwapLong(cpu->epsr); -- cpu->db = NXSwapLong(cpu->db); -- cpu->pc = NXSwapLong(cpu->pc); -- cpu->_padding_ = NXSwapLong(cpu->_padding_); -- cpu->Mres3 = NXSwapDouble(cpu->Mres3); -- cpu->Ares3 = NXSwapDouble(cpu->Ares3); -- cpu->Mres2 = NXSwapDouble(cpu->Mres2); -- cpu->Ares2 = NXSwapDouble(cpu->Ares2); -- cpu->Mres1 = NXSwapDouble(cpu->Mres1); -- cpu->Ares1 = NXSwapDouble(cpu->Ares1); -- cpu->Ires1 = NXSwapDouble(cpu->Ires1); -- cpu->Lres3m = NXSwapDouble(cpu->Lres3m); -- cpu->Lres2m = NXSwapDouble(cpu->Lres2m); -- cpu->Lres1m = NXSwapDouble(cpu->Lres1m); -- cpu->KR = NXSwapDouble(cpu->KR); -- cpu->KI = NXSwapDouble(cpu->KI); -- cpu->T = NXSwapDouble(cpu->T); -- cpu->Fsr3 = NXSwapLong(cpu->Fsr3); -- cpu->Fsr2 = NXSwapLong(cpu->Fsr2); -- cpu->Fsr1 = NXSwapLong(cpu->Fsr1); -- cpu->Mergelo32 = NXSwapLong(cpu->Mergelo32); -- cpu->Mergehi32 = NXSwapLong(cpu->Mergehi32); -+ cpu->freg[i] = OSSwapInt32(cpu->freg[i]); -+ cpu->psr = OSSwapInt32(cpu->psr); -+ cpu->epsr = OSSwapInt32(cpu->epsr); -+ cpu->db = OSSwapInt32(cpu->db); -+ cpu->pc = OSSwapInt32(cpu->pc); -+ cpu->_padding_ = OSSwapInt32(cpu->_padding_); -+ cpu->Mres3 = OSSwapInt64(cpu->Mres3); -+ cpu->Ares3 = OSSwapInt64(cpu->Ares3); -+ cpu->Mres2 = OSSwapInt64(cpu->Mres2); -+ cpu->Ares2 = OSSwapInt64(cpu->Ares2); -+ cpu->Mres1 = OSSwapInt64(cpu->Mres1); -+ cpu->Ares1 = OSSwapInt64(cpu->Ares1); -+ cpu->Ires1 = OSSwapInt64(cpu->Ires1); -+ cpu->Lres3m = OSSwapInt64(cpu->Lres3m); -+ cpu->Lres2m = OSSwapInt64(cpu->Lres2m); -+ cpu->Lres1m = OSSwapInt64(cpu->Lres1m); -+ cpu->KR = OSSwapInt64(cpu->KR); -+ cpu->KI = OSSwapInt64(cpu->KI); -+ cpu->T = OSSwapInt64(cpu->T); -+ cpu->Fsr3 = OSSwapInt32(cpu->Fsr3); -+ cpu->Fsr2 = OSSwapInt32(cpu->Fsr2); -+ cpu->Fsr1 = OSSwapInt32(cpu->Fsr1); -+ cpu->Mergelo32 = OSSwapInt32(cpu->Mergelo32); -+ cpu->Mergehi32 = OSSwapInt32(cpu->Mergehi32); - } - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/libmacho/m68k_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/m68k_swap.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/m68k_swap.c 2013-09-03 21:08:01.873209515 +0000 -@@ -28,15 +28,15 @@ - struct m68k_thread_state_regs *cpu, - enum NXByteOrder target_byte_sex) - { -- unsigned long i; -+ uint32_t i; - - for(i = 0; i < 8; i++) -- cpu->dreg[i] = NXSwapLong(cpu->dreg[i]); -+ cpu->dreg[i] = OSSwapInt32(cpu->dreg[i]); - for(i = 0; i < 8; i++) -- cpu->areg[i] = NXSwapLong(cpu->areg[i]); -- cpu->pad0 = NXSwapShort(cpu->pad0); -- cpu->sr = NXSwapShort(cpu->sr); -- cpu->pc = NXSwapLong(cpu->pc); -+ cpu->areg[i] = OSSwapInt32(cpu->areg[i]); -+ cpu->pad0 = OSSwapInt16(cpu->pad0); -+ cpu->sr = OSSwapInt16(cpu->sr); -+ cpu->pc = OSSwapInt32(cpu->pc); - } - - void -@@ -44,18 +44,18 @@ - struct m68k_thread_state_68882 *fpu, - enum NXByteOrder target_byte_sex) - { -- unsigned long i, tmp; -+ uint32_t i, tmp; - - for(i = 0; i < 8; i++){ -- tmp = NXSwapLong(fpu->regs[i].fp[0]); -- fpu->regs[i].fp[1] = NXSwapLong(fpu->regs[i].fp[1]); -- fpu->regs[i].fp[0] = NXSwapLong(fpu->regs[i].fp[2]); -+ tmp = OSSwapInt32(fpu->regs[i].fp[0]); -+ fpu->regs[i].fp[1] = OSSwapInt32(fpu->regs[i].fp[1]); -+ fpu->regs[i].fp[0] = OSSwapInt32(fpu->regs[i].fp[2]); - fpu->regs[i].fp[2] = tmp; - } -- fpu->cr = NXSwapLong(fpu->cr); -- fpu->sr = NXSwapLong(fpu->sr); -- fpu->iar = NXSwapLong(fpu->iar); -- fpu->state = NXSwapLong(fpu->state); -+ fpu->cr = OSSwapInt32(fpu->cr); -+ fpu->sr = OSSwapInt32(fpu->sr); -+ fpu->iar = OSSwapInt32(fpu->iar); -+ fpu->state = OSSwapInt32(fpu->state); - } - - void -@@ -63,6 +63,6 @@ - struct m68k_thread_state_user_reg *user_reg, - enum NXByteOrder target_byte_sex) - { -- user_reg->user_reg = NXSwapLong(user_reg->user_reg); -+ user_reg->user_reg = OSSwapInt32(user_reg->user_reg); - } - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/libmacho/m88k_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/m88k_swap.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/m88k_swap.c 2013-09-03 21:08:01.873209515 +0000 -@@ -30,40 +30,40 @@ - m88k_thread_state_grf_t *cpu, - enum NXByteOrder target_byte_sex) - { -- cpu->r1 = NXSwapLong(cpu->r1); -- cpu->r2 = NXSwapLong(cpu->r2); -- cpu->r3 = NXSwapLong(cpu->r3); -- cpu->r4 = NXSwapLong(cpu->r4); -- cpu->r5 = NXSwapLong(cpu->r5); -- cpu->r6 = NXSwapLong(cpu->r6); -- cpu->r7 = NXSwapLong(cpu->r7); -- cpu->r8 = NXSwapLong(cpu->r8); -- cpu->r9 = NXSwapLong(cpu->r9); -- cpu->r10 = NXSwapLong(cpu->r10); -- cpu->r11 = NXSwapLong(cpu->r11); -- cpu->r12 = NXSwapLong(cpu->r12); -- cpu->r13 = NXSwapLong(cpu->r13); -- cpu->r14 = NXSwapLong(cpu->r14); -- cpu->r15 = NXSwapLong(cpu->r15); -- cpu->r16 = NXSwapLong(cpu->r16); -- cpu->r17 = NXSwapLong(cpu->r17); -- cpu->r18 = NXSwapLong(cpu->r18); -- cpu->r19 = NXSwapLong(cpu->r19); -- cpu->r20 = NXSwapLong(cpu->r20); -- cpu->r21 = NXSwapLong(cpu->r21); -- cpu->r22 = NXSwapLong(cpu->r22); -- cpu->r23 = NXSwapLong(cpu->r23); -- cpu->r24 = NXSwapLong(cpu->r24); -- cpu->r25 = NXSwapLong(cpu->r25); -- cpu->r26 = NXSwapLong(cpu->r26); -- cpu->r27 = NXSwapLong(cpu->r27); -- cpu->r28 = NXSwapLong(cpu->r28); -- cpu->r29 = NXSwapLong(cpu->r29); -- cpu->r30 = NXSwapLong(cpu->r30); -- cpu->r31 = NXSwapLong(cpu->r31); -- cpu->xip = NXSwapLong(cpu->xip); -- cpu->xip_in_bd = NXSwapLong(cpu->xip_in_bd); -- cpu->nip = NXSwapLong(cpu->nip); -+ cpu->r1 = OSSwapInt32(cpu->r1); -+ cpu->r2 = OSSwapInt32(cpu->r2); -+ cpu->r3 = OSSwapInt32(cpu->r3); -+ cpu->r4 = OSSwapInt32(cpu->r4); -+ cpu->r5 = OSSwapInt32(cpu->r5); -+ cpu->r6 = OSSwapInt32(cpu->r6); -+ cpu->r7 = OSSwapInt32(cpu->r7); -+ cpu->r8 = OSSwapInt32(cpu->r8); -+ cpu->r9 = OSSwapInt32(cpu->r9); -+ cpu->r10 = OSSwapInt32(cpu->r10); -+ cpu->r11 = OSSwapInt32(cpu->r11); -+ cpu->r12 = OSSwapInt32(cpu->r12); -+ cpu->r13 = OSSwapInt32(cpu->r13); -+ cpu->r14 = OSSwapInt32(cpu->r14); -+ cpu->r15 = OSSwapInt32(cpu->r15); -+ cpu->r16 = OSSwapInt32(cpu->r16); -+ cpu->r17 = OSSwapInt32(cpu->r17); -+ cpu->r18 = OSSwapInt32(cpu->r18); -+ cpu->r19 = OSSwapInt32(cpu->r19); -+ cpu->r20 = OSSwapInt32(cpu->r20); -+ cpu->r21 = OSSwapInt32(cpu->r21); -+ cpu->r22 = OSSwapInt32(cpu->r22); -+ cpu->r23 = OSSwapInt32(cpu->r23); -+ cpu->r24 = OSSwapInt32(cpu->r24); -+ cpu->r25 = OSSwapInt32(cpu->r25); -+ cpu->r26 = OSSwapInt32(cpu->r26); -+ cpu->r27 = OSSwapInt32(cpu->r27); -+ cpu->r28 = OSSwapInt32(cpu->r28); -+ cpu->r29 = OSSwapInt32(cpu->r29); -+ cpu->r30 = OSSwapInt32(cpu->r30); -+ cpu->r31 = OSSwapInt32(cpu->r31); -+ cpu->xip = OSSwapInt32(cpu->xip); -+ cpu->xip_in_bd = OSSwapInt32(cpu->xip_in_bd); -+ cpu->nip = OSSwapInt32(cpu->nip); - } - - void -@@ -85,7 +85,7 @@ - unsigned xmod:BIT_WIDTH(16); - unsigned :BITS_WIDTH(31,17); - } fields; -- unsigned long word; -+ uint32_t word; - } u; - } ssr; - struct swapped_m88k_fpcr { -@@ -100,140 +100,140 @@ - m88k_fpcr_rm_t rm:BITS_WIDTH(15,14); - unsigned :BITS_WIDTH(31,16); - } fields; -- unsigned long word; -+ uint32_t word; - } u; - } scr; - - host_byte_sex = NXHostByteOrder(); - -- fpu->x1.x[0] = NXSwapLong(fpu->x1.x[0]); -- fpu->x1.x[1] = NXSwapLong(fpu->x1.x[1]); -- fpu->x1.x[2] = NXSwapLong(fpu->x1.x[2]); -- fpu->x1.x[3] = NXSwapLong(fpu->x1.x[3]); -- fpu->x2.x[0] = NXSwapLong(fpu->x2.x[0]); -- fpu->x2.x[1] = NXSwapLong(fpu->x2.x[1]); -- fpu->x2.x[2] = NXSwapLong(fpu->x2.x[2]); -- fpu->x2.x[3] = NXSwapLong(fpu->x2.x[3]); -- fpu->x3.x[0] = NXSwapLong(fpu->x3.x[0]); -- fpu->x3.x[1] = NXSwapLong(fpu->x3.x[1]); -- fpu->x3.x[2] = NXSwapLong(fpu->x3.x[2]); -- fpu->x3.x[3] = NXSwapLong(fpu->x3.x[3]); -- fpu->x4.x[0] = NXSwapLong(fpu->x4.x[0]); -- fpu->x4.x[1] = NXSwapLong(fpu->x4.x[1]); -- fpu->x4.x[2] = NXSwapLong(fpu->x4.x[2]); -- fpu->x4.x[3] = NXSwapLong(fpu->x4.x[3]); -- fpu->x5.x[0] = NXSwapLong(fpu->x5.x[0]); -- fpu->x5.x[1] = NXSwapLong(fpu->x5.x[1]); -- fpu->x5.x[2] = NXSwapLong(fpu->x5.x[2]); -- fpu->x5.x[3] = NXSwapLong(fpu->x5.x[3]); -- fpu->x6.x[0] = NXSwapLong(fpu->x6.x[0]); -- fpu->x6.x[1] = NXSwapLong(fpu->x6.x[1]); -- fpu->x6.x[2] = NXSwapLong(fpu->x6.x[2]); -- fpu->x6.x[3] = NXSwapLong(fpu->x6.x[3]); -- fpu->x7.x[0] = NXSwapLong(fpu->x7.x[0]); -- fpu->x7.x[1] = NXSwapLong(fpu->x7.x[1]); -- fpu->x7.x[2] = NXSwapLong(fpu->x7.x[2]); -- fpu->x7.x[3] = NXSwapLong(fpu->x7.x[3]); -- fpu->x8.x[0] = NXSwapLong(fpu->x8.x[0]); -- fpu->x8.x[1] = NXSwapLong(fpu->x8.x[1]); -- fpu->x8.x[2] = NXSwapLong(fpu->x8.x[2]); -- fpu->x8.x[3] = NXSwapLong(fpu->x8.x[3]); -- fpu->x9.x[0] = NXSwapLong(fpu->x9.x[0]); -- fpu->x9.x[1] = NXSwapLong(fpu->x9.x[1]); -- fpu->x9.x[2] = NXSwapLong(fpu->x9.x[2]); -- fpu->x9.x[3] = NXSwapLong(fpu->x9.x[3]); -- fpu->x10.x[0] = NXSwapLong(fpu->x10.x[0]); -- fpu->x10.x[1] = NXSwapLong(fpu->x10.x[1]); -- fpu->x10.x[2] = NXSwapLong(fpu->x10.x[2]); -- fpu->x10.x[3] = NXSwapLong(fpu->x10.x[3]); -- fpu->x11.x[0] = NXSwapLong(fpu->x11.x[0]); -- fpu->x11.x[1] = NXSwapLong(fpu->x11.x[1]); -- fpu->x11.x[2] = NXSwapLong(fpu->x11.x[2]); -- fpu->x11.x[3] = NXSwapLong(fpu->x11.x[3]); -- fpu->x12.x[0] = NXSwapLong(fpu->x12.x[0]); -- fpu->x12.x[1] = NXSwapLong(fpu->x12.x[1]); -- fpu->x12.x[2] = NXSwapLong(fpu->x12.x[2]); -- fpu->x12.x[3] = NXSwapLong(fpu->x12.x[3]); -- fpu->x13.x[0] = NXSwapLong(fpu->x13.x[0]); -- fpu->x13.x[1] = NXSwapLong(fpu->x13.x[1]); -- fpu->x13.x[2] = NXSwapLong(fpu->x13.x[2]); -- fpu->x13.x[3] = NXSwapLong(fpu->x13.x[3]); -- fpu->x14.x[0] = NXSwapLong(fpu->x14.x[0]); -- fpu->x14.x[1] = NXSwapLong(fpu->x14.x[1]); -- fpu->x14.x[2] = NXSwapLong(fpu->x14.x[2]); -- fpu->x14.x[3] = NXSwapLong(fpu->x14.x[3]); -- fpu->x15.x[0] = NXSwapLong(fpu->x15.x[0]); -- fpu->x15.x[1] = NXSwapLong(fpu->x15.x[1]); -- fpu->x15.x[2] = NXSwapLong(fpu->x15.x[2]); -- fpu->x15.x[3] = NXSwapLong(fpu->x15.x[3]); -- fpu->x16.x[0] = NXSwapLong(fpu->x16.x[0]); -- fpu->x16.x[1] = NXSwapLong(fpu->x16.x[1]); -- fpu->x16.x[2] = NXSwapLong(fpu->x16.x[2]); -- fpu->x16.x[3] = NXSwapLong(fpu->x16.x[3]); -- fpu->x17.x[0] = NXSwapLong(fpu->x17.x[0]); -- fpu->x17.x[1] = NXSwapLong(fpu->x17.x[1]); -- fpu->x17.x[2] = NXSwapLong(fpu->x17.x[2]); -- fpu->x17.x[3] = NXSwapLong(fpu->x17.x[3]); -- fpu->x18.x[0] = NXSwapLong(fpu->x18.x[0]); -- fpu->x18.x[1] = NXSwapLong(fpu->x18.x[1]); -- fpu->x18.x[2] = NXSwapLong(fpu->x18.x[2]); -- fpu->x18.x[3] = NXSwapLong(fpu->x18.x[3]); -- fpu->x19.x[0] = NXSwapLong(fpu->x19.x[0]); -- fpu->x19.x[1] = NXSwapLong(fpu->x19.x[1]); -- fpu->x19.x[2] = NXSwapLong(fpu->x19.x[2]); -- fpu->x19.x[3] = NXSwapLong(fpu->x19.x[3]); -- fpu->x20.x[0] = NXSwapLong(fpu->x20.x[0]); -- fpu->x20.x[1] = NXSwapLong(fpu->x20.x[1]); -- fpu->x20.x[2] = NXSwapLong(fpu->x20.x[2]); -- fpu->x20.x[3] = NXSwapLong(fpu->x20.x[3]); -- fpu->x21.x[0] = NXSwapLong(fpu->x21.x[0]); -- fpu->x21.x[1] = NXSwapLong(fpu->x21.x[1]); -- fpu->x21.x[2] = NXSwapLong(fpu->x21.x[2]); -- fpu->x21.x[3] = NXSwapLong(fpu->x21.x[3]); -- fpu->x22.x[0] = NXSwapLong(fpu->x22.x[0]); -- fpu->x22.x[1] = NXSwapLong(fpu->x22.x[1]); -- fpu->x22.x[2] = NXSwapLong(fpu->x22.x[2]); -- fpu->x22.x[3] = NXSwapLong(fpu->x22.x[3]); -- fpu->x23.x[0] = NXSwapLong(fpu->x23.x[0]); -- fpu->x23.x[1] = NXSwapLong(fpu->x23.x[1]); -- fpu->x23.x[2] = NXSwapLong(fpu->x23.x[2]); -- fpu->x23.x[3] = NXSwapLong(fpu->x23.x[3]); -- fpu->x24.x[0] = NXSwapLong(fpu->x24.x[0]); -- fpu->x24.x[1] = NXSwapLong(fpu->x24.x[1]); -- fpu->x24.x[2] = NXSwapLong(fpu->x24.x[2]); -- fpu->x24.x[3] = NXSwapLong(fpu->x24.x[3]); -- fpu->x25.x[0] = NXSwapLong(fpu->x25.x[0]); -- fpu->x25.x[1] = NXSwapLong(fpu->x25.x[1]); -- fpu->x25.x[2] = NXSwapLong(fpu->x25.x[2]); -- fpu->x25.x[3] = NXSwapLong(fpu->x25.x[3]); -- fpu->x26.x[0] = NXSwapLong(fpu->x26.x[0]); -- fpu->x26.x[1] = NXSwapLong(fpu->x26.x[1]); -- fpu->x26.x[2] = NXSwapLong(fpu->x26.x[2]); -- fpu->x26.x[3] = NXSwapLong(fpu->x26.x[3]); -- fpu->x27.x[0] = NXSwapLong(fpu->x27.x[0]); -- fpu->x27.x[1] = NXSwapLong(fpu->x27.x[1]); -- fpu->x27.x[2] = NXSwapLong(fpu->x27.x[2]); -- fpu->x27.x[3] = NXSwapLong(fpu->x27.x[3]); -- fpu->x28.x[0] = NXSwapLong(fpu->x28.x[0]); -- fpu->x28.x[1] = NXSwapLong(fpu->x28.x[1]); -- fpu->x28.x[2] = NXSwapLong(fpu->x28.x[2]); -- fpu->x28.x[3] = NXSwapLong(fpu->x28.x[3]); -- fpu->x29.x[0] = NXSwapLong(fpu->x29.x[0]); -- fpu->x29.x[1] = NXSwapLong(fpu->x29.x[1]); -- fpu->x29.x[2] = NXSwapLong(fpu->x29.x[2]); -- fpu->x29.x[3] = NXSwapLong(fpu->x29.x[3]); -- fpu->x30.x[0] = NXSwapLong(fpu->x30.x[0]); -- fpu->x30.x[1] = NXSwapLong(fpu->x30.x[1]); -- fpu->x30.x[2] = NXSwapLong(fpu->x30.x[2]); -- fpu->x30.x[3] = NXSwapLong(fpu->x30.x[3]); -- fpu->x31.x[0] = NXSwapLong(fpu->x31.x[0]); -- fpu->x31.x[1] = NXSwapLong(fpu->x31.x[1]); -- fpu->x31.x[2] = NXSwapLong(fpu->x31.x[2]); -- fpu->x31.x[3] = NXSwapLong(fpu->x31.x[3]); -+ fpu->x1.x[0] = OSSwapInt32(fpu->x1.x[0]); -+ fpu->x1.x[1] = OSSwapInt32(fpu->x1.x[1]); -+ fpu->x1.x[2] = OSSwapInt32(fpu->x1.x[2]); -+ fpu->x1.x[3] = OSSwapInt32(fpu->x1.x[3]); -+ fpu->x2.x[0] = OSSwapInt32(fpu->x2.x[0]); -+ fpu->x2.x[1] = OSSwapInt32(fpu->x2.x[1]); -+ fpu->x2.x[2] = OSSwapInt32(fpu->x2.x[2]); -+ fpu->x2.x[3] = OSSwapInt32(fpu->x2.x[3]); -+ fpu->x3.x[0] = OSSwapInt32(fpu->x3.x[0]); -+ fpu->x3.x[1] = OSSwapInt32(fpu->x3.x[1]); -+ fpu->x3.x[2] = OSSwapInt32(fpu->x3.x[2]); -+ fpu->x3.x[3] = OSSwapInt32(fpu->x3.x[3]); -+ fpu->x4.x[0] = OSSwapInt32(fpu->x4.x[0]); -+ fpu->x4.x[1] = OSSwapInt32(fpu->x4.x[1]); -+ fpu->x4.x[2] = OSSwapInt32(fpu->x4.x[2]); -+ fpu->x4.x[3] = OSSwapInt32(fpu->x4.x[3]); -+ fpu->x5.x[0] = OSSwapInt32(fpu->x5.x[0]); -+ fpu->x5.x[1] = OSSwapInt32(fpu->x5.x[1]); -+ fpu->x5.x[2] = OSSwapInt32(fpu->x5.x[2]); -+ fpu->x5.x[3] = OSSwapInt32(fpu->x5.x[3]); -+ fpu->x6.x[0] = OSSwapInt32(fpu->x6.x[0]); -+ fpu->x6.x[1] = OSSwapInt32(fpu->x6.x[1]); -+ fpu->x6.x[2] = OSSwapInt32(fpu->x6.x[2]); -+ fpu->x6.x[3] = OSSwapInt32(fpu->x6.x[3]); -+ fpu->x7.x[0] = OSSwapInt32(fpu->x7.x[0]); -+ fpu->x7.x[1] = OSSwapInt32(fpu->x7.x[1]); -+ fpu->x7.x[2] = OSSwapInt32(fpu->x7.x[2]); -+ fpu->x7.x[3] = OSSwapInt32(fpu->x7.x[3]); -+ fpu->x8.x[0] = OSSwapInt32(fpu->x8.x[0]); -+ fpu->x8.x[1] = OSSwapInt32(fpu->x8.x[1]); -+ fpu->x8.x[2] = OSSwapInt32(fpu->x8.x[2]); -+ fpu->x8.x[3] = OSSwapInt32(fpu->x8.x[3]); -+ fpu->x9.x[0] = OSSwapInt32(fpu->x9.x[0]); -+ fpu->x9.x[1] = OSSwapInt32(fpu->x9.x[1]); -+ fpu->x9.x[2] = OSSwapInt32(fpu->x9.x[2]); -+ fpu->x9.x[3] = OSSwapInt32(fpu->x9.x[3]); -+ fpu->x10.x[0] = OSSwapInt32(fpu->x10.x[0]); -+ fpu->x10.x[1] = OSSwapInt32(fpu->x10.x[1]); -+ fpu->x10.x[2] = OSSwapInt32(fpu->x10.x[2]); -+ fpu->x10.x[3] = OSSwapInt32(fpu->x10.x[3]); -+ fpu->x11.x[0] = OSSwapInt32(fpu->x11.x[0]); -+ fpu->x11.x[1] = OSSwapInt32(fpu->x11.x[1]); -+ fpu->x11.x[2] = OSSwapInt32(fpu->x11.x[2]); -+ fpu->x11.x[3] = OSSwapInt32(fpu->x11.x[3]); -+ fpu->x12.x[0] = OSSwapInt32(fpu->x12.x[0]); -+ fpu->x12.x[1] = OSSwapInt32(fpu->x12.x[1]); -+ fpu->x12.x[2] = OSSwapInt32(fpu->x12.x[2]); -+ fpu->x12.x[3] = OSSwapInt32(fpu->x12.x[3]); -+ fpu->x13.x[0] = OSSwapInt32(fpu->x13.x[0]); -+ fpu->x13.x[1] = OSSwapInt32(fpu->x13.x[1]); -+ fpu->x13.x[2] = OSSwapInt32(fpu->x13.x[2]); -+ fpu->x13.x[3] = OSSwapInt32(fpu->x13.x[3]); -+ fpu->x14.x[0] = OSSwapInt32(fpu->x14.x[0]); -+ fpu->x14.x[1] = OSSwapInt32(fpu->x14.x[1]); -+ fpu->x14.x[2] = OSSwapInt32(fpu->x14.x[2]); -+ fpu->x14.x[3] = OSSwapInt32(fpu->x14.x[3]); -+ fpu->x15.x[0] = OSSwapInt32(fpu->x15.x[0]); -+ fpu->x15.x[1] = OSSwapInt32(fpu->x15.x[1]); -+ fpu->x15.x[2] = OSSwapInt32(fpu->x15.x[2]); -+ fpu->x15.x[3] = OSSwapInt32(fpu->x15.x[3]); -+ fpu->x16.x[0] = OSSwapInt32(fpu->x16.x[0]); -+ fpu->x16.x[1] = OSSwapInt32(fpu->x16.x[1]); -+ fpu->x16.x[2] = OSSwapInt32(fpu->x16.x[2]); -+ fpu->x16.x[3] = OSSwapInt32(fpu->x16.x[3]); -+ fpu->x17.x[0] = OSSwapInt32(fpu->x17.x[0]); -+ fpu->x17.x[1] = OSSwapInt32(fpu->x17.x[1]); -+ fpu->x17.x[2] = OSSwapInt32(fpu->x17.x[2]); -+ fpu->x17.x[3] = OSSwapInt32(fpu->x17.x[3]); -+ fpu->x18.x[0] = OSSwapInt32(fpu->x18.x[0]); -+ fpu->x18.x[1] = OSSwapInt32(fpu->x18.x[1]); -+ fpu->x18.x[2] = OSSwapInt32(fpu->x18.x[2]); -+ fpu->x18.x[3] = OSSwapInt32(fpu->x18.x[3]); -+ fpu->x19.x[0] = OSSwapInt32(fpu->x19.x[0]); -+ fpu->x19.x[1] = OSSwapInt32(fpu->x19.x[1]); -+ fpu->x19.x[2] = OSSwapInt32(fpu->x19.x[2]); -+ fpu->x19.x[3] = OSSwapInt32(fpu->x19.x[3]); -+ fpu->x20.x[0] = OSSwapInt32(fpu->x20.x[0]); -+ fpu->x20.x[1] = OSSwapInt32(fpu->x20.x[1]); -+ fpu->x20.x[2] = OSSwapInt32(fpu->x20.x[2]); -+ fpu->x20.x[3] = OSSwapInt32(fpu->x20.x[3]); -+ fpu->x21.x[0] = OSSwapInt32(fpu->x21.x[0]); -+ fpu->x21.x[1] = OSSwapInt32(fpu->x21.x[1]); -+ fpu->x21.x[2] = OSSwapInt32(fpu->x21.x[2]); -+ fpu->x21.x[3] = OSSwapInt32(fpu->x21.x[3]); -+ fpu->x22.x[0] = OSSwapInt32(fpu->x22.x[0]); -+ fpu->x22.x[1] = OSSwapInt32(fpu->x22.x[1]); -+ fpu->x22.x[2] = OSSwapInt32(fpu->x22.x[2]); -+ fpu->x22.x[3] = OSSwapInt32(fpu->x22.x[3]); -+ fpu->x23.x[0] = OSSwapInt32(fpu->x23.x[0]); -+ fpu->x23.x[1] = OSSwapInt32(fpu->x23.x[1]); -+ fpu->x23.x[2] = OSSwapInt32(fpu->x23.x[2]); -+ fpu->x23.x[3] = OSSwapInt32(fpu->x23.x[3]); -+ fpu->x24.x[0] = OSSwapInt32(fpu->x24.x[0]); -+ fpu->x24.x[1] = OSSwapInt32(fpu->x24.x[1]); -+ fpu->x24.x[2] = OSSwapInt32(fpu->x24.x[2]); -+ fpu->x24.x[3] = OSSwapInt32(fpu->x24.x[3]); -+ fpu->x25.x[0] = OSSwapInt32(fpu->x25.x[0]); -+ fpu->x25.x[1] = OSSwapInt32(fpu->x25.x[1]); -+ fpu->x25.x[2] = OSSwapInt32(fpu->x25.x[2]); -+ fpu->x25.x[3] = OSSwapInt32(fpu->x25.x[3]); -+ fpu->x26.x[0] = OSSwapInt32(fpu->x26.x[0]); -+ fpu->x26.x[1] = OSSwapInt32(fpu->x26.x[1]); -+ fpu->x26.x[2] = OSSwapInt32(fpu->x26.x[2]); -+ fpu->x26.x[3] = OSSwapInt32(fpu->x26.x[3]); -+ fpu->x27.x[0] = OSSwapInt32(fpu->x27.x[0]); -+ fpu->x27.x[1] = OSSwapInt32(fpu->x27.x[1]); -+ fpu->x27.x[2] = OSSwapInt32(fpu->x27.x[2]); -+ fpu->x27.x[3] = OSSwapInt32(fpu->x27.x[3]); -+ fpu->x28.x[0] = OSSwapInt32(fpu->x28.x[0]); -+ fpu->x28.x[1] = OSSwapInt32(fpu->x28.x[1]); -+ fpu->x28.x[2] = OSSwapInt32(fpu->x28.x[2]); -+ fpu->x28.x[3] = OSSwapInt32(fpu->x28.x[3]); -+ fpu->x29.x[0] = OSSwapInt32(fpu->x29.x[0]); -+ fpu->x29.x[1] = OSSwapInt32(fpu->x29.x[1]); -+ fpu->x29.x[2] = OSSwapInt32(fpu->x29.x[2]); -+ fpu->x29.x[3] = OSSwapInt32(fpu->x29.x[3]); -+ fpu->x30.x[0] = OSSwapInt32(fpu->x30.x[0]); -+ fpu->x30.x[1] = OSSwapInt32(fpu->x30.x[1]); -+ fpu->x30.x[2] = OSSwapInt32(fpu->x30.x[2]); -+ fpu->x30.x[3] = OSSwapInt32(fpu->x30.x[3]); -+ fpu->x31.x[0] = OSSwapInt32(fpu->x31.x[0]); -+ fpu->x31.x[1] = OSSwapInt32(fpu->x31.x[1]); -+ fpu->x31.x[2] = OSSwapInt32(fpu->x31.x[2]); -+ fpu->x31.x[3] = OSSwapInt32(fpu->x31.x[3]); - - if(target_byte_sex == host_byte_sex){ - memcpy(&ssr, &(fpu->fpsr), sizeof(struct swapped_m88k_fpsr)); -- ssr.u.word = NXSwapLong(ssr.u.word); -+ ssr.u.word = OSSwapInt32(ssr.u.word); - fpu->fpsr.afinx = ssr.u.fields.afinx; - fpu->fpsr.afovf = ssr.u.fields.afovf; - fpu->fpsr.afunf = ssr.u.fields.afunf; -@@ -242,7 +242,7 @@ - fpu->fpsr.xmod = ssr.u.fields.xmod; - - memcpy(&scr, &(fpu->fpcr), sizeof(struct swapped_m88k_fpcr)); -- scr.u.word = NXSwapLong(scr.u.word); -+ scr.u.word = OSSwapInt32(scr.u.word); - fpu->fpcr.efinx = scr.u.fields.efinx; - fpu->fpcr.efovf = scr.u.fields.efovf; - fpu->fpcr.efunf = scr.u.fields.efunf; -@@ -257,7 +257,7 @@ - ssr.u.fields.afdvz = fpu->fpsr.afdvz; - ssr.u.fields.afinv = fpu->fpsr.afinv; - ssr.u.fields.xmod = fpu->fpsr.xmod; -- ssr.u.word = NXSwapLong(ssr.u.word); -+ ssr.u.word = OSSwapInt32(ssr.u.word); - memcpy(&(fpu->fpsr), &ssr, sizeof(struct swapped_m88k_fpsr)); - - scr.u.fields.efinx = fpu->fpcr.efinx; -@@ -266,7 +266,7 @@ - scr.u.fields.efdvz = fpu->fpcr.efdvz; - scr.u.fields.efinv = fpu->fpcr.efinv; - scr.u.fields.rm = fpu->fpcr.rm; -- scr.u.word = NXSwapLong(scr.u.word); -+ scr.u.word = OSSwapInt32(scr.u.word); - memcpy(&(fpu->fpcr), &scr, sizeof(struct swapped_m88k_fpcr)); - } - } -@@ -276,7 +276,7 @@ - m88k_thread_state_user_t *user, - enum NXByteOrder target_byte_sex) - { -- user->user = NXSwapLong(user->user); -+ user->user = OSSwapInt32(user->user); - } - - void -@@ -284,7 +284,7 @@ - m88110_thread_state_impl_t *spu, - enum NXByteOrder target_byte_sex) - { -- unsigned long i; -+ uint32_t i; - enum NXByteOrder host_byte_sex; - - struct swapped_m88110_bp_ctrl { -@@ -297,7 +297,7 @@ - unsigned rw:BIT_WIDTH(28); - unsigned :BITS_WIDTH(31,29); - } fields; -- unsigned long word; -+ uint32_t word; - } u; - } sbpc; - -@@ -318,7 +318,7 @@ - unsigned le:BIT_WIDTH(30); - unsigned supr:BIT_WIDTH(31); - } fields; -- unsigned long word; -+ uint32_t word; - } u; - } spsr; - -@@ -338,7 +338,7 @@ - m88110_iresult_size_t iresult_size:BITS_WIDTH(15,14); - unsigned :BITS_WIDTH(31,16); - } fields; -- unsigned long word; -+ uint32_t word; - } u; - } sfps; - -@@ -346,10 +346,10 @@ - - if(target_byte_sex == host_byte_sex){ - for(i = 0; i < M88110_N_DATA_BP; i++){ -- spu->data_bp[i].addr = NXSwapLong(spu->data_bp[i].addr); -+ spu->data_bp[i].addr = OSSwapInt32(spu->data_bp[i].addr); - memcpy(&sbpc, &(spu->data_bp[i].ctrl), - sizeof(struct swapped_m88110_bp_ctrl)); -- sbpc.u.word = NXSwapLong(sbpc.u.word); -+ sbpc.u.word = OSSwapInt32(sbpc.u.word); - spu->data_bp[i].ctrl.v = sbpc.u.fields.v; - spu->data_bp[i].ctrl.addr_match = sbpc.u.fields.addr_match; - spu->data_bp[i].ctrl.rwm = sbpc.u.fields.rwm; -@@ -357,7 +357,7 @@ - } - - memcpy(&spsr, &(spu->psr), sizeof(struct swap_m88110_psr)); -- spsr.u.word = NXSwapLong(spsr.u.word); -+ spsr.u.word = OSSwapInt32(spsr.u.word); - spu->psr.mxm_dis = spsr.u.fields.mxm_dis; - spu->psr.sfu1dis = spsr.u.fields.sfu1dis; - spu->psr.trace = spsr.u.fields.trace; -@@ -370,7 +370,7 @@ - - memcpy(&sfps, &(spu->fp_trap_status), - sizeof(struct swapped_m88110_fp_trap_status)); -- sfps.u.word = NXSwapLong(sfps.u.word); -+ sfps.u.word = OSSwapInt32(sfps.u.word); - spu->fp_trap_status.efinx = sfps.u.fields.efinx; - spu->fp_trap_status.efovf = sfps.u.fields.efovf; - spu->fp_trap_status.efunf = sfps.u.fields.efunf; -@@ -383,12 +383,12 @@ - } - else{ - for(i = 0; i < M88110_N_DATA_BP; i++){ -- spu->data_bp[i].addr = NXSwapLong(spu->data_bp[i].addr); -+ spu->data_bp[i].addr = OSSwapInt32(spu->data_bp[i].addr); - sbpc.u.fields.v = spu->data_bp[i].ctrl.v; - sbpc.u.fields.addr_match = spu->data_bp[i].ctrl.addr_match; - sbpc.u.fields.rwm = spu->data_bp[i].ctrl.rwm; - sbpc.u.fields.rw = spu->data_bp[i].ctrl.rw; -- sbpc.u.word = NXSwapLong(sbpc.u.word); -+ sbpc.u.word = OSSwapInt32(sbpc.u.word); - memcpy(&(spu->data_bp[i].ctrl), &sbpc, - sizeof(struct swapped_m88110_bp_ctrl)); - } -@@ -402,7 +402,7 @@ - spsr.u.fields.se = spu->psr.se; - spsr.u.fields.le = spu->psr.le; - spsr.u.fields.supr = spu->psr.supr; -- spsr.u.word = NXSwapLong(spsr.u.word); -+ spsr.u.word = OSSwapInt32(spsr.u.word); - memcpy(&(spu->psr), &spsr, sizeof(struct swap_m88110_psr)); - - sfps.u.fields.efinx = spu->fp_trap_status.efinx; -@@ -414,17 +414,17 @@ - sfps.u.fields.unimp = spu->fp_trap_status.unimp; - sfps.u.fields.sfu1_disabled = spu->fp_trap_status.sfu1_disabled; - sfps.u.fields.iresult_size = spu->fp_trap_status.iresult_size; -- sfps.u.word = NXSwapLong(sfps.u.word); -+ sfps.u.word = OSSwapInt32(sfps.u.word); - memcpy(&(spu->fp_trap_status), &sfps, - sizeof(struct swapped_m88110_fp_trap_status)); - } - spu->intermediate_result.x[0] = -- NXSwapLong(spu->intermediate_result.x[0]); -+ OSSwapInt32(spu->intermediate_result.x[0]); - spu->intermediate_result.x[1] = -- NXSwapLong(spu->intermediate_result.x[1]); -+ OSSwapInt32(spu->intermediate_result.x[1]); - spu->intermediate_result.x[2] = -- NXSwapLong(spu->intermediate_result.x[2]); -+ OSSwapInt32(spu->intermediate_result.x[2]); - spu->intermediate_result.x[3] = -- NXSwapLong(spu->intermediate_result.x[3]); -+ OSSwapInt32(spu->intermediate_result.x[3]); - } - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/libmacho/ppc_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/ppc_swap.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/ppc_swap.c 2013-09-03 21:08:01.873209515 +0000 -@@ -79,46 +79,46 @@ - ppc_thread_state_t *cpu, - enum NXByteOrder target_byte_sex) - { -- cpu->srr0 = NXSwapLong(cpu->srr0); -- cpu->srr1 = NXSwapLong(cpu->srr1); -- cpu->r0 = NXSwapLong(cpu->r0); -- cpu->r1 = NXSwapLong(cpu->r1); -- cpu->r2 = NXSwapLong(cpu->r2); -- cpu->r3 = NXSwapLong(cpu->r3); -- cpu->r4 = NXSwapLong(cpu->r4); -- cpu->r5 = NXSwapLong(cpu->r5); -- cpu->r6 = NXSwapLong(cpu->r6); -- cpu->r7 = NXSwapLong(cpu->r7); -- cpu->r8 = NXSwapLong(cpu->r8); -- cpu->r9 = NXSwapLong(cpu->r9); -- cpu->r10 = NXSwapLong(cpu->r10); -- cpu->r11 = NXSwapLong(cpu->r11); -- cpu->r12 = NXSwapLong(cpu->r12); -- cpu->r13 = NXSwapLong(cpu->r13); -- cpu->r14 = NXSwapLong(cpu->r14); -- cpu->r15 = NXSwapLong(cpu->r15); -- cpu->r16 = NXSwapLong(cpu->r16); -- cpu->r17 = NXSwapLong(cpu->r17); -- cpu->r18 = NXSwapLong(cpu->r18); -- cpu->r19 = NXSwapLong(cpu->r19); -- cpu->r20 = NXSwapLong(cpu->r20); -- cpu->r21 = NXSwapLong(cpu->r21); -- cpu->r22 = NXSwapLong(cpu->r22); -- cpu->r23 = NXSwapLong(cpu->r23); -- cpu->r24 = NXSwapLong(cpu->r24); -- cpu->r25 = NXSwapLong(cpu->r25); -- cpu->r26 = NXSwapLong(cpu->r26); -- cpu->r27 = NXSwapLong(cpu->r27); -- cpu->r28 = NXSwapLong(cpu->r28); -- cpu->r29 = NXSwapLong(cpu->r29); -- cpu->r30 = NXSwapLong(cpu->r30); -- cpu->r31 = NXSwapLong(cpu->r31); -- cpu->lr = NXSwapLong(cpu->lr); -- cpu->cr = NXSwapLong(cpu->cr); -- cpu->xer = NXSwapLong(cpu->xer); -- cpu->ctr = NXSwapLong(cpu->ctr); -- cpu->mq = NXSwapLong(cpu->mq); -- cpu->vrsave = NXSwapLong(cpu->vrsave); -+ cpu->srr0 = OSSwapInt32(cpu->srr0); -+ cpu->srr1 = OSSwapInt32(cpu->srr1); -+ cpu->r0 = OSSwapInt32(cpu->r0); -+ cpu->r1 = OSSwapInt32(cpu->r1); -+ cpu->r2 = OSSwapInt32(cpu->r2); -+ cpu->r3 = OSSwapInt32(cpu->r3); -+ cpu->r4 = OSSwapInt32(cpu->r4); -+ cpu->r5 = OSSwapInt32(cpu->r5); -+ cpu->r6 = OSSwapInt32(cpu->r6); -+ cpu->r7 = OSSwapInt32(cpu->r7); -+ cpu->r8 = OSSwapInt32(cpu->r8); -+ cpu->r9 = OSSwapInt32(cpu->r9); -+ cpu->r10 = OSSwapInt32(cpu->r10); -+ cpu->r11 = OSSwapInt32(cpu->r11); -+ cpu->r12 = OSSwapInt32(cpu->r12); -+ cpu->r13 = OSSwapInt32(cpu->r13); -+ cpu->r14 = OSSwapInt32(cpu->r14); -+ cpu->r15 = OSSwapInt32(cpu->r15); -+ cpu->r16 = OSSwapInt32(cpu->r16); -+ cpu->r17 = OSSwapInt32(cpu->r17); -+ cpu->r18 = OSSwapInt32(cpu->r18); -+ cpu->r19 = OSSwapInt32(cpu->r19); -+ cpu->r20 = OSSwapInt32(cpu->r20); -+ cpu->r21 = OSSwapInt32(cpu->r21); -+ cpu->r22 = OSSwapInt32(cpu->r22); -+ cpu->r23 = OSSwapInt32(cpu->r23); -+ cpu->r24 = OSSwapInt32(cpu->r24); -+ cpu->r25 = OSSwapInt32(cpu->r25); -+ cpu->r26 = OSSwapInt32(cpu->r26); -+ cpu->r27 = OSSwapInt32(cpu->r27); -+ cpu->r28 = OSSwapInt32(cpu->r28); -+ cpu->r29 = OSSwapInt32(cpu->r29); -+ cpu->r30 = OSSwapInt32(cpu->r30); -+ cpu->r31 = OSSwapInt32(cpu->r31); -+ cpu->lr = OSSwapInt32(cpu->lr); -+ cpu->cr = OSSwapInt32(cpu->cr); -+ cpu->xer = OSSwapInt32(cpu->xer); -+ cpu->ctr = OSSwapInt32(cpu->ctr); -+ cpu->mq = OSSwapInt32(cpu->mq); -+ cpu->vrsave = OSSwapInt32(cpu->vrsave); - - } - -@@ -127,13 +127,13 @@ - ppc_float_state_t *fpu, - enum NXByteOrder target_byte_sex) - { -- unsigned long i; -+ uint32_t i; - - for(i = 0; i < 32; i++) -- fpu->fpregs[i] = NXSwapDouble(fpu->fpregs[i]); -+ fpu->fpregs[i] = OSSwapInt64(fpu->fpregs[i]); - -- fpu->fpscr_pad = NXSwapLong(fpu->fpscr_pad); -- fpu->fpscr = NXSwapLong(fpu->fpscr); -+ fpu->fpscr_pad = OSSwapInt32(fpu->fpscr_pad); -+ fpu->fpscr = OSSwapInt32(fpu->fpscr); - } - - void -@@ -141,14 +141,14 @@ - ppc_exception_state_t *state, - enum NXByteOrder target_byte_sex) - { -- unsigned long i; -+ uint32_t i; - -- state->dar = NXSwapLong(state->dar); -- state->dsisr = NXSwapLong(state->dsisr); -- state->exception = NXSwapLong(state->exception); -- state->pad0 = NXSwapLong(state->pad0); -+ state->dar = OSSwapInt32(state->dar); -+ state->dsisr = OSSwapInt32(state->dsisr); -+ state->exception = OSSwapInt32(state->exception); -+ state->pad0 = OSSwapInt32(state->pad0); - - for(i = 0; i < 4; i++) -- state->pad1[i] = NXSwapLong(state->pad1[i]); -+ state->pad1[i] = OSSwapInt32(state->pad1[i]); - } - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/libmacho/sparc_swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/sparc_swap.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/sparc_swap.c 2013-09-03 21:08:01.873209515 +0000 -@@ -54,29 +54,29 @@ - - host_byte_sex = NXHostByteOrder(); - -- cpu->regs.r_pc = NXSwapLong(cpu->regs.r_pc); -- cpu->regs.r_npc = NXSwapLong(cpu->regs.r_npc); -- cpu->regs.r_y = NXSwapLong(cpu->regs.r_y); -- cpu->regs.r_g1 = NXSwapLong(cpu->regs.r_g1); -- cpu->regs.r_g2 = NXSwapLong(cpu->regs.r_g2); -- cpu->regs.r_g3 = NXSwapLong(cpu->regs.r_g3); -- cpu->regs.r_g4 = NXSwapLong(cpu->regs.r_g4); -- cpu->regs.r_g5 = NXSwapLong(cpu->regs.r_g5); -- cpu->regs.r_g6 = NXSwapLong(cpu->regs.r_g6); -- cpu->regs.r_g7 = NXSwapLong(cpu->regs.r_g7); -- cpu->regs.r_o0 = NXSwapLong(cpu->regs.r_o0); -- cpu->regs.r_o1 = NXSwapLong(cpu->regs.r_o1); -- cpu->regs.r_o2 = NXSwapLong(cpu->regs.r_o2); -- cpu->regs.r_o3 = NXSwapLong(cpu->regs.r_o3); -- cpu->regs.r_o4 = NXSwapLong(cpu->regs.r_o4); -- cpu->regs.r_o5 = NXSwapLong(cpu->regs.r_o5); -- cpu->regs.r_o6 = NXSwapLong(cpu->regs.r_o6); -- cpu->regs.r_o7 = NXSwapLong(cpu->regs.r_o7); -+ cpu->regs.r_pc = OSSwapInt32(cpu->regs.r_pc); -+ cpu->regs.r_npc = OSSwapInt32(cpu->regs.r_npc); -+ cpu->regs.r_y = OSSwapInt32(cpu->regs.r_y); -+ cpu->regs.r_g1 = OSSwapInt32(cpu->regs.r_g1); -+ cpu->regs.r_g2 = OSSwapInt32(cpu->regs.r_g2); -+ cpu->regs.r_g3 = OSSwapInt32(cpu->regs.r_g3); -+ cpu->regs.r_g4 = OSSwapInt32(cpu->regs.r_g4); -+ cpu->regs.r_g5 = OSSwapInt32(cpu->regs.r_g5); -+ cpu->regs.r_g6 = OSSwapInt32(cpu->regs.r_g6); -+ cpu->regs.r_g7 = OSSwapInt32(cpu->regs.r_g7); -+ cpu->regs.r_o0 = OSSwapInt32(cpu->regs.r_o0); -+ cpu->regs.r_o1 = OSSwapInt32(cpu->regs.r_o1); -+ cpu->regs.r_o2 = OSSwapInt32(cpu->regs.r_o2); -+ cpu->regs.r_o3 = OSSwapInt32(cpu->regs.r_o3); -+ cpu->regs.r_o4 = OSSwapInt32(cpu->regs.r_o4); -+ cpu->regs.r_o5 = OSSwapInt32(cpu->regs.r_o5); -+ cpu->regs.r_o6 = OSSwapInt32(cpu->regs.r_o6); -+ cpu->regs.r_o7 = OSSwapInt32(cpu->regs.r_o7); - - pr_status = (struct p_status *) &(cpu->regs.r_psr); - if(target_byte_sex == host_byte_sex){ - memcpy(&spsr, &(cpu->regs.r_psr), sizeof(struct swapped_psr)); -- spsr.u.word = NXSwapLong(spsr.u.word); -+ spsr.u.word = OSSwapInt32(spsr.u.word); - pr_status->PSRREG.psr_bits.cwp = spsr.u.fields.cwp; - pr_status->PSRREG.psr_bits.ps = spsr.u.fields.ps; - pr_status->PSRREG.psr_bits.s = spsr.u.fields.s; -@@ -99,7 +99,7 @@ - spsr.u.fields.icc = pr_status->PSRREG.psr_bits.icc; - spsr.u.fields.ver = pr_status->PSRREG.psr_bits.et; - spsr.u.fields.impl = pr_status->PSRREG.psr_bits.impl; -- spsr.u.word = NXSwapLong(spsr.u.word); -+ spsr.u.word = OSSwapInt32(spsr.u.word); - memcpy(&(cpu->regs.r_psr), &spsr, sizeof(struct swapped_psr)); - } - } -@@ -127,7 +127,7 @@ - unsigned int word; - } u; - } sfsr; -- unsigned long i; -+ uint32_t i; - struct f_status *fpu_status; - enum NXByteOrder host_byte_sex; - -@@ -137,18 +137,18 @@ - /* floating point registers */ - for(i = 0; i < 16; i++) /* 16 doubles */ - fpu->fpu.fpu_fr.Fpu_dregs[i] = -- NXSwapDouble(fpu->fpu.fpu_fr.Fpu_dregs[i]); -+ OSSwapInt64(fpu->fpu.fpu_fr.Fpu_dregs[i]); - -- fpu->fpu.Fpu_q[0].FQu.whole = NXSwapDouble(fpu->fpu.Fpu_q[0].FQu.whole); -- fpu->fpu.Fpu_q[1].FQu.whole = NXSwapDouble(fpu->fpu.Fpu_q[1].FQu.whole); -- fpu->fpu.Fpu_flags = NXSwapLong(fpu->fpu.Fpu_flags); -- fpu->fpu.Fpu_extra = NXSwapLong(fpu->fpu.Fpu_extra); -- fpu->fpu.Fpu_qcnt = NXSwapLong(fpu->fpu.Fpu_qcnt); -+ fpu->fpu.Fpu_q[0].FQu.whole = OSSwapInt64(fpu->fpu.Fpu_q[0].FQu.whole); -+ fpu->fpu.Fpu_q[1].FQu.whole = OSSwapInt64(fpu->fpu.Fpu_q[1].FQu.whole); -+ fpu->fpu.Fpu_flags = OSSwapInt32(fpu->fpu.Fpu_flags); -+ fpu->fpu.Fpu_extra = OSSwapInt32(fpu->fpu.Fpu_extra); -+ fpu->fpu.Fpu_qcnt = OSSwapInt32(fpu->fpu.Fpu_qcnt); - - fpu_status = (struct f_status *) &(fpu->fpu.Fpu_fsr); - if(target_byte_sex == host_byte_sex){ - memcpy(&sfsr, &(fpu->fpu.Fpu_fsr), sizeof(unsigned int)); -- sfsr.u.word = NXSwapLong(sfsr.u.word); -+ sfsr.u.word = OSSwapInt32(sfsr.u.word); - fpu_status->FPUREG.Fpu_fsr_bits.rd = sfsr.u.fields.rd; - fpu_status->FPUREG.Fpu_fsr_bits.rp = sfsr.u.fields.rp; - fpu_status->FPUREG.Fpu_fsr_bits.tem = sfsr.u.fields.tem; -@@ -171,7 +171,7 @@ - sfsr.u.fields.fcc = fpu_status->FPUREG.Fpu_fsr_bits.fcc; - sfsr.u.fields.aexc = fpu_status->FPUREG.Fpu_fsr_bits.aexc; - sfsr.u.fields.cexc = fpu_status->FPUREG.Fpu_fsr_bits.cexc; -- sfsr.u.word = NXSwapLong(sfsr.u.word); -+ sfsr.u.word = OSSwapInt32(sfsr.u.word); - memcpy(&(fpu->fpu.Fpu_fsr), &sfsr, sizeof(struct swapped_fsr)); - } - } -Index: odcctools-9.2-ld/libmacho/swap.c -=================================================================== ---- odcctools-9.2-ld.orig/libmacho/swap.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/libmacho/swap.c 2013-09-03 21:08:01.877209515 +0000 -@@ -22,6 +22,7 @@ - */ - #ifndef RLD - #include <stdint.h> -+#include <libkern/OSByteOrder.h> - #include <mach-o/swap.h> - #include <string.h> - -@@ -30,8 +31,8 @@ - struct fat_header *fat_header, - enum NXByteOrder target_byte_sex) - { -- fat_header->magic = NXSwapLong(fat_header->magic); -- fat_header->nfat_arch = NXSwapLong(fat_header->nfat_arch); -+ fat_header->magic = OSSwapInt32(fat_header->magic); -+ fat_header->nfat_arch = OSSwapInt32(fat_header->nfat_arch); - } - - void -@@ -43,11 +44,11 @@ - uint32_t i; - - for(i = 0; i < nfat_arch; i++){ -- fat_archs[i].cputype = NXSwapLong(fat_archs[i].cputype); -- fat_archs[i].cpusubtype = NXSwapLong(fat_archs[i].cpusubtype); -- fat_archs[i].offset = NXSwapLong(fat_archs[i].offset); -- fat_archs[i].size = NXSwapLong(fat_archs[i].size); -- fat_archs[i].align = NXSwapLong(fat_archs[i].align); -+ fat_archs[i].cputype = OSSwapInt32(fat_archs[i].cputype); -+ fat_archs[i].cpusubtype = OSSwapInt32(fat_archs[i].cpusubtype); -+ fat_archs[i].offset = OSSwapInt32(fat_archs[i].offset); -+ fat_archs[i].size = OSSwapInt32(fat_archs[i].size); -+ fat_archs[i].align = OSSwapInt32(fat_archs[i].align); - } - } - -@@ -56,13 +57,13 @@ - struct mach_header *mh, - enum NXByteOrder target_byte_sex) - { -- mh->magic = NXSwapLong(mh->magic); -- mh->cputype = NXSwapLong(mh->cputype); -- mh->cpusubtype = NXSwapLong(mh->cpusubtype); -- mh->filetype = NXSwapLong(mh->filetype); -- mh->ncmds = NXSwapLong(mh->ncmds); -- mh->sizeofcmds = NXSwapLong(mh->sizeofcmds); -- mh->flags = NXSwapLong(mh->flags); -+ mh->magic = OSSwapInt32(mh->magic); -+ mh->cputype = OSSwapInt32(mh->cputype); -+ mh->cpusubtype = OSSwapInt32(mh->cpusubtype); -+ mh->filetype = OSSwapInt32(mh->filetype); -+ mh->ncmds = OSSwapInt32(mh->ncmds); -+ mh->sizeofcmds = OSSwapInt32(mh->sizeofcmds); -+ mh->flags = OSSwapInt32(mh->flags); - } - - void -@@ -70,14 +71,14 @@ - struct mach_header_64 *mh, - enum NXByteOrder target_byte_sex) - { -- mh->magic = NXSwapLong(mh->magic); -- mh->cputype = NXSwapLong(mh->cputype); -- mh->cpusubtype = NXSwapLong(mh->cpusubtype); -- mh->filetype = NXSwapLong(mh->filetype); -- mh->ncmds = NXSwapLong(mh->ncmds); -- mh->sizeofcmds = NXSwapLong(mh->sizeofcmds); -- mh->flags = NXSwapLong(mh->flags); -- mh->reserved = NXSwapLong(mh->reserved); -+ mh->magic = OSSwapInt32(mh->magic); -+ mh->cputype = OSSwapInt32(mh->cputype); -+ mh->cpusubtype = OSSwapInt32(mh->cpusubtype); -+ mh->filetype = OSSwapInt32(mh->filetype); -+ mh->ncmds = OSSwapInt32(mh->ncmds); -+ mh->sizeofcmds = OSSwapInt32(mh->sizeofcmds); -+ mh->flags = OSSwapInt32(mh->flags); -+ mh->reserved = OSSwapInt32(mh->reserved); - } - - void -@@ -85,8 +86,8 @@ - struct load_command *lc, - enum NXByteOrder target_byte_sex) - { -- lc->cmd = NXSwapLong(lc->cmd); -- lc->cmdsize = NXSwapLong(lc->cmdsize); -+ lc->cmd = OSSwapInt32(lc->cmd); -+ lc->cmdsize = OSSwapInt32(lc->cmdsize); - } - - void -@@ -95,16 +96,16 @@ - enum NXByteOrder target_byte_sex) - { - /* segname[16] */ -- sg->cmd = NXSwapLong(sg->cmd); -- sg->cmdsize = NXSwapLong(sg->cmdsize); -- sg->vmaddr = NXSwapLong(sg->vmaddr); -- sg->vmsize = NXSwapLong(sg->vmsize); -- sg->fileoff = NXSwapLong(sg->fileoff); -- sg->filesize = NXSwapLong(sg->filesize); -- sg->maxprot = NXSwapLong(sg->maxprot); -- sg->initprot = NXSwapLong(sg->initprot); -- sg->nsects = NXSwapLong(sg->nsects); -- sg->flags = NXSwapLong(sg->flags); -+ sg->cmd = OSSwapInt32(sg->cmd); -+ sg->cmdsize = OSSwapInt32(sg->cmdsize); -+ sg->vmaddr = OSSwapInt32(sg->vmaddr); -+ sg->vmsize = OSSwapInt32(sg->vmsize); -+ sg->fileoff = OSSwapInt32(sg->fileoff); -+ sg->filesize = OSSwapInt32(sg->filesize); -+ sg->maxprot = OSSwapInt32(sg->maxprot); -+ sg->initprot = OSSwapInt32(sg->initprot); -+ sg->nsects = OSSwapInt32(sg->nsects); -+ sg->flags = OSSwapInt32(sg->flags); - } - - void -@@ -113,16 +114,16 @@ - enum NXByteOrder target_byte_sex) - { - /* char segname[16] */ -- sg->cmd = NXSwapLong(sg->cmd); -- sg->cmdsize = NXSwapLong(sg->cmdsize); -- sg->vmaddr = NXSwapLongLong(sg->vmaddr); -- sg->vmsize = NXSwapLongLong(sg->vmsize); -- sg->fileoff = NXSwapLongLong(sg->fileoff); -- sg->filesize = NXSwapLongLong(sg->filesize); -- sg->maxprot = NXSwapLong(sg->maxprot); -- sg->initprot = NXSwapLong(sg->initprot); -- sg->nsects = NXSwapLong(sg->nsects); -- sg->flags = NXSwapLong(sg->flags); -+ sg->cmd = OSSwapInt32(sg->cmd); -+ sg->cmdsize = OSSwapInt32(sg->cmdsize); -+ sg->vmaddr = OSSwapInt64(sg->vmaddr); -+ sg->vmsize = OSSwapInt64(sg->vmsize); -+ sg->fileoff = OSSwapInt64(sg->fileoff); -+ sg->filesize = OSSwapInt64(sg->filesize); -+ sg->maxprot = OSSwapInt32(sg->maxprot); -+ sg->initprot = OSSwapInt32(sg->initprot); -+ sg->nsects = OSSwapInt32(sg->nsects); -+ sg->flags = OSSwapInt32(sg->flags); - } - - void -@@ -136,15 +137,15 @@ - for(i = 0; i < nsects; i++){ - /* sectname[16] */ - /* segname[16] */ -- s[i].addr = NXSwapLong(s[i].addr); -- s[i].size = NXSwapLong(s[i].size); -- s[i].offset = NXSwapLong(s[i].offset); -- s[i].align = NXSwapLong(s[i].align); -- s[i].reloff = NXSwapLong(s[i].reloff); -- s[i].nreloc = NXSwapLong(s[i].nreloc); -- s[i].flags = NXSwapLong(s[i].flags); -- s[i].reserved1 = NXSwapLong(s[i].reserved1); -- s[i].reserved2 = NXSwapLong(s[i].reserved2); -+ s[i].addr = OSSwapInt32(s[i].addr); -+ s[i].size = OSSwapInt32(s[i].size); -+ s[i].offset = OSSwapInt32(s[i].offset); -+ s[i].align = OSSwapInt32(s[i].align); -+ s[i].reloff = OSSwapInt32(s[i].reloff); -+ s[i].nreloc = OSSwapInt32(s[i].nreloc); -+ s[i].flags = OSSwapInt32(s[i].flags); -+ s[i].reserved1 = OSSwapInt32(s[i].reserved1); -+ s[i].reserved2 = OSSwapInt32(s[i].reserved2); - } - } - -@@ -159,16 +160,16 @@ - for(i = 0; i < nsects; i++){ - /* sectname[16] */ - /* segname[16] */ -- s[i].addr = NXSwapLongLong(s[i].addr); -- s[i].size = NXSwapLongLong(s[i].size); -- s[i].offset = NXSwapLong(s[i].offset); -- s[i].align = NXSwapLong(s[i].align); -- s[i].reloff = NXSwapLong(s[i].reloff); -- s[i].nreloc = NXSwapLong(s[i].nreloc); -- s[i].flags = NXSwapLong(s[i].flags); -- s[i].reserved1 = NXSwapLong(s[i].reserved1); -- s[i].reserved2 = NXSwapLong(s[i].reserved2); -- s[i].reserved3 = NXSwapLong(s[i].reserved3); -+ s[i].addr = OSSwapInt64(s[i].addr); -+ s[i].size = OSSwapInt64(s[i].size); -+ s[i].offset = OSSwapInt32(s[i].offset); -+ s[i].align = OSSwapInt32(s[i].align); -+ s[i].reloff = OSSwapInt32(s[i].reloff); -+ s[i].nreloc = OSSwapInt32(s[i].nreloc); -+ s[i].flags = OSSwapInt32(s[i].flags); -+ s[i].reserved1 = OSSwapInt32(s[i].reserved1); -+ s[i].reserved2 = OSSwapInt32(s[i].reserved2); -+ s[i].reserved3 = OSSwapInt32(s[i].reserved3); - } - } - -@@ -177,12 +178,12 @@ - struct symtab_command *st, - enum NXByteOrder target_byte_sex) - { -- st->cmd = NXSwapLong(st->cmd); -- st->cmdsize = NXSwapLong(st->cmdsize); -- st->symoff = NXSwapLong(st->symoff); -- st->nsyms = NXSwapLong(st->nsyms); -- st->stroff = NXSwapLong(st->stroff); -- st->strsize = NXSwapLong(st->strsize); -+ st->cmd = OSSwapInt32(st->cmd); -+ st->cmdsize = OSSwapInt32(st->cmdsize); -+ st->symoff = OSSwapInt32(st->symoff); -+ st->nsyms = OSSwapInt32(st->nsyms); -+ st->stroff = OSSwapInt32(st->stroff); -+ st->strsize = OSSwapInt32(st->strsize); - } - - void -@@ -190,26 +191,26 @@ - struct dysymtab_command *dyst, - enum NXByteOrder target_byte_sex) - { -- dyst->cmd = NXSwapLong(dyst->cmd); -- dyst->cmdsize = NXSwapLong(dyst->cmdsize); -- dyst->ilocalsym = NXSwapLong(dyst->ilocalsym); -- dyst->nlocalsym = NXSwapLong(dyst->nlocalsym); -- dyst->iextdefsym = NXSwapLong(dyst->iextdefsym); -- dyst->nextdefsym = NXSwapLong(dyst->nextdefsym); -- dyst->iundefsym = NXSwapLong(dyst->iundefsym); -- dyst->nundefsym = NXSwapLong(dyst->nundefsym); -- dyst->tocoff = NXSwapLong(dyst->tocoff); -- dyst->ntoc = NXSwapLong(dyst->ntoc); -- dyst->modtaboff = NXSwapLong(dyst->modtaboff); -- dyst->nmodtab = NXSwapLong(dyst->nmodtab); -- dyst->extrefsymoff = NXSwapLong(dyst->extrefsymoff); -- dyst->nextrefsyms = NXSwapLong(dyst->nextrefsyms); -- dyst->indirectsymoff = NXSwapLong(dyst->indirectsymoff); -- dyst->nindirectsyms = NXSwapLong(dyst->nindirectsyms); -- dyst->extreloff = NXSwapLong(dyst->extreloff); -- dyst->nextrel = NXSwapLong(dyst->nextrel); -- dyst->locreloff = NXSwapLong(dyst->locreloff); -- dyst->nlocrel = NXSwapLong(dyst->nlocrel); -+ dyst->cmd = OSSwapInt32(dyst->cmd); -+ dyst->cmdsize = OSSwapInt32(dyst->cmdsize); -+ dyst->ilocalsym = OSSwapInt32(dyst->ilocalsym); -+ dyst->nlocalsym = OSSwapInt32(dyst->nlocalsym); -+ dyst->iextdefsym = OSSwapInt32(dyst->iextdefsym); -+ dyst->nextdefsym = OSSwapInt32(dyst->nextdefsym); -+ dyst->iundefsym = OSSwapInt32(dyst->iundefsym); -+ dyst->nundefsym = OSSwapInt32(dyst->nundefsym); -+ dyst->tocoff = OSSwapInt32(dyst->tocoff); -+ dyst->ntoc = OSSwapInt32(dyst->ntoc); -+ dyst->modtaboff = OSSwapInt32(dyst->modtaboff); -+ dyst->nmodtab = OSSwapInt32(dyst->nmodtab); -+ dyst->extrefsymoff = OSSwapInt32(dyst->extrefsymoff); -+ dyst->nextrefsyms = OSSwapInt32(dyst->nextrefsyms); -+ dyst->indirectsymoff = OSSwapInt32(dyst->indirectsymoff); -+ dyst->nindirectsyms = OSSwapInt32(dyst->nindirectsyms); -+ dyst->extreloff = OSSwapInt32(dyst->extreloff); -+ dyst->nextrel = OSSwapInt32(dyst->nextrel); -+ dyst->locreloff = OSSwapInt32(dyst->locreloff); -+ dyst->nlocrel = OSSwapInt32(dyst->nlocrel); - } - - void -@@ -217,10 +218,10 @@ - struct symseg_command *ss, - enum NXByteOrder target_byte_sex) - { -- ss->cmd = NXSwapLong(ss->cmd); -- ss->cmdsize = NXSwapLong(ss->cmdsize); -- ss->offset = NXSwapLong(ss->offset); -- ss->size = NXSwapLong(ss->size); -+ ss->cmd = OSSwapInt32(ss->cmd); -+ ss->cmdsize = OSSwapInt32(ss->cmdsize); -+ ss->offset = OSSwapInt32(ss->offset); -+ ss->size = OSSwapInt32(ss->size); - } - - void -@@ -228,11 +229,11 @@ - struct fvmlib_command *fl, - enum NXByteOrder target_byte_sex) - { -- fl->cmd = NXSwapLong(fl->cmd); -- fl->cmdsize = NXSwapLong(fl->cmdsize); -- fl->fvmlib.name.offset = NXSwapLong(fl->fvmlib.name.offset); -- fl->fvmlib.minor_version = NXSwapLong(fl->fvmlib.minor_version); -- fl->fvmlib.header_addr = NXSwapLong(fl->fvmlib.header_addr); -+ fl->cmd = OSSwapInt32(fl->cmd); -+ fl->cmdsize = OSSwapInt32(fl->cmdsize); -+ fl->fvmlib.name.offset = OSSwapInt32(fl->fvmlib.name.offset); -+ fl->fvmlib.minor_version = OSSwapInt32(fl->fvmlib.minor_version); -+ fl->fvmlib.header_addr = OSSwapInt32(fl->fvmlib.header_addr); - } - - void -@@ -240,13 +241,13 @@ - struct dylib_command *dl, - enum NXByteOrder target_byte_sex) - { -- dl->cmd = NXSwapLong(dl->cmd); -- dl->cmdsize = NXSwapLong(dl->cmdsize); -- dl->dylib.name.offset = NXSwapLong(dl->dylib.name.offset); -- dl->dylib.timestamp = NXSwapLong(dl->dylib.timestamp); -- dl->dylib.current_version = NXSwapLong(dl->dylib.current_version); -+ dl->cmd = OSSwapInt32(dl->cmd); -+ dl->cmdsize = OSSwapInt32(dl->cmdsize); -+ dl->dylib.name.offset = OSSwapInt32(dl->dylib.name.offset); -+ dl->dylib.timestamp = OSSwapInt32(dl->dylib.timestamp); -+ dl->dylib.current_version = OSSwapInt32(dl->dylib.current_version); - dl->dylib.compatibility_version = -- NXSwapLong(dl->dylib.compatibility_version); -+ OSSwapInt32(dl->dylib.compatibility_version); - } - - void -@@ -254,9 +255,9 @@ - struct sub_framework_command *sub, - enum NXByteOrder target_byte_sex) - { -- sub->cmd = NXSwapLong(sub->cmd); -- sub->cmdsize = NXSwapLong(sub->cmdsize); -- sub->umbrella.offset = NXSwapLong(sub->umbrella.offset); -+ sub->cmd = OSSwapInt32(sub->cmd); -+ sub->cmdsize = OSSwapInt32(sub->cmdsize); -+ sub->umbrella.offset = OSSwapInt32(sub->umbrella.offset); - } - - void -@@ -264,9 +265,9 @@ - struct sub_umbrella_command *usub, - enum NXByteOrder target_byte_sex) - { -- usub->cmd = NXSwapLong(usub->cmd); -- usub->cmdsize = NXSwapLong(usub->cmdsize); -- usub->sub_umbrella.offset = NXSwapLong(usub->sub_umbrella.offset); -+ usub->cmd = OSSwapInt32(usub->cmd); -+ usub->cmdsize = OSSwapInt32(usub->cmdsize); -+ usub->sub_umbrella.offset = OSSwapInt32(usub->sub_umbrella.offset); - } - - void -@@ -274,9 +275,9 @@ - struct sub_library_command *lsub, - enum NXByteOrder target_byte_sex) - { -- lsub->cmd = NXSwapLong(lsub->cmd); -- lsub->cmdsize = NXSwapLong(lsub->cmdsize); -- lsub->sub_library.offset = NXSwapLong(lsub->sub_library.offset); -+ lsub->cmd = OSSwapInt32(lsub->cmd); -+ lsub->cmdsize = OSSwapInt32(lsub->cmdsize); -+ lsub->sub_library.offset = OSSwapInt32(lsub->sub_library.offset); - } - - void -@@ -284,9 +285,9 @@ - struct sub_client_command *csub, - enum NXByteOrder target_byte_sex) - { -- csub->cmd = NXSwapLong(csub->cmd); -- csub->cmdsize = NXSwapLong(csub->cmdsize); -- csub->client.offset = NXSwapLong(csub->client.offset); -+ csub->cmd = OSSwapInt32(csub->cmd); -+ csub->cmdsize = OSSwapInt32(csub->cmdsize); -+ csub->client.offset = OSSwapInt32(csub->client.offset); - } - - -@@ -295,12 +296,12 @@ - struct prebound_dylib_command *pbdylib, - enum NXByteOrder target_byte_sex) - { -- pbdylib->cmd = NXSwapLong(pbdylib->cmd); -- pbdylib->cmdsize = NXSwapLong(pbdylib->cmdsize); -- pbdylib->name.offset = NXSwapLong(pbdylib->name.offset); -- pbdylib->nmodules = NXSwapLong(pbdylib->nmodules); -+ pbdylib->cmd = OSSwapInt32(pbdylib->cmd); -+ pbdylib->cmdsize = OSSwapInt32(pbdylib->cmdsize); -+ pbdylib->name.offset = OSSwapInt32(pbdylib->name.offset); -+ pbdylib->nmodules = OSSwapInt32(pbdylib->nmodules); - pbdylib->linked_modules.offset = -- NXSwapLong(pbdylib->linked_modules.offset); -+ OSSwapInt32(pbdylib->linked_modules.offset); - } - - void -@@ -308,9 +309,9 @@ - struct dylinker_command *dyld, - enum NXByteOrder target_byte_sex) - { -- dyld->cmd = NXSwapLong(dyld->cmd); -- dyld->cmdsize = NXSwapLong(dyld->cmdsize); -- dyld->name.offset = NXSwapLong(dyld->name.offset); -+ dyld->cmd = OSSwapInt32(dyld->cmd); -+ dyld->cmdsize = OSSwapInt32(dyld->cmdsize); -+ dyld->name.offset = OSSwapInt32(dyld->name.offset); - } - - void -@@ -318,10 +319,10 @@ - struct fvmfile_command *ff, - enum NXByteOrder target_byte_sex) - { -- ff->cmd = NXSwapLong(ff->cmd); -- ff->cmdsize = NXSwapLong(ff->cmdsize); -- ff->name.offset = NXSwapLong(ff->name.offset); -- ff->header_addr = NXSwapLong(ff->header_addr); -+ ff->cmd = OSSwapInt32(ff->cmd); -+ ff->cmdsize = OSSwapInt32(ff->cmdsize); -+ ff->name.offset = OSSwapInt32(ff->name.offset); -+ ff->header_addr = OSSwapInt32(ff->header_addr); - } - - -@@ -330,8 +331,8 @@ - struct thread_command *ut, - enum NXByteOrder target_byte_sex) - { -- ut->cmd = NXSwapLong(ut->cmd); -- ut->cmdsize = NXSwapLong(ut->cmdsize); -+ ut->cmd = OSSwapInt32(ut->cmd); -+ ut->cmdsize = OSSwapInt32(ut->cmdsize); - } - - void -@@ -339,8 +340,8 @@ - struct ident_command *id_cmd, - enum NXByteOrder target_byte_sex) - { -- id_cmd->cmd = NXSwapLong(id_cmd->cmd); -- id_cmd->cmdsize = NXSwapLong(id_cmd->cmdsize); -+ id_cmd->cmd = OSSwapInt32(id_cmd->cmd); -+ id_cmd->cmdsize = OSSwapInt32(id_cmd->cmdsize); - } - - void -@@ -348,16 +349,16 @@ - struct routines_command *r_cmd, - enum NXByteOrder target_byte_sex) - { -- r_cmd->cmd = NXSwapLong(r_cmd->cmd); -- r_cmd->cmdsize = NXSwapLong(r_cmd->cmdsize); -- r_cmd->init_address = NXSwapLong(r_cmd->init_address); -- r_cmd->init_module = NXSwapLong(r_cmd->init_module); -- r_cmd->reserved1 = NXSwapLong(r_cmd->reserved1); -- r_cmd->reserved2 = NXSwapLong(r_cmd->reserved2); -- r_cmd->reserved3 = NXSwapLong(r_cmd->reserved3); -- r_cmd->reserved4 = NXSwapLong(r_cmd->reserved4); -- r_cmd->reserved5 = NXSwapLong(r_cmd->reserved5); -- r_cmd->reserved6 = NXSwapLong(r_cmd->reserved6); -+ r_cmd->cmd = OSSwapInt32(r_cmd->cmd); -+ r_cmd->cmdsize = OSSwapInt32(r_cmd->cmdsize); -+ r_cmd->init_address = OSSwapInt32(r_cmd->init_address); -+ r_cmd->init_module = OSSwapInt32(r_cmd->init_module); -+ r_cmd->reserved1 = OSSwapInt32(r_cmd->reserved1); -+ r_cmd->reserved2 = OSSwapInt32(r_cmd->reserved2); -+ r_cmd->reserved3 = OSSwapInt32(r_cmd->reserved3); -+ r_cmd->reserved4 = OSSwapInt32(r_cmd->reserved4); -+ r_cmd->reserved5 = OSSwapInt32(r_cmd->reserved5); -+ r_cmd->reserved6 = OSSwapInt32(r_cmd->reserved6); - } - - void -@@ -365,16 +366,16 @@ - struct routines_command_64 *r_cmd, - enum NXByteOrder target_byte_sex) - { -- r_cmd->cmd = NXSwapLong(r_cmd->cmd); -- r_cmd->cmdsize = NXSwapLong(r_cmd->cmdsize); -- r_cmd->init_address = NXSwapLongLong(r_cmd->init_address); -- r_cmd->init_module = NXSwapLongLong(r_cmd->init_module); -- r_cmd->reserved1 = NXSwapLongLong(r_cmd->reserved1); -- r_cmd->reserved2 = NXSwapLongLong(r_cmd->reserved2); -- r_cmd->reserved3 = NXSwapLongLong(r_cmd->reserved3); -- r_cmd->reserved4 = NXSwapLongLong(r_cmd->reserved4); -- r_cmd->reserved5 = NXSwapLongLong(r_cmd->reserved5); -- r_cmd->reserved6 = NXSwapLongLong(r_cmd->reserved6); -+ r_cmd->cmd = OSSwapInt32(r_cmd->cmd); -+ r_cmd->cmdsize = OSSwapInt32(r_cmd->cmdsize); -+ r_cmd->init_address = OSSwapInt64(r_cmd->init_address); -+ r_cmd->init_module = OSSwapInt64(r_cmd->init_module); -+ r_cmd->reserved1 = OSSwapInt64(r_cmd->reserved1); -+ r_cmd->reserved2 = OSSwapInt64(r_cmd->reserved2); -+ r_cmd->reserved3 = OSSwapInt64(r_cmd->reserved3); -+ r_cmd->reserved4 = OSSwapInt64(r_cmd->reserved4); -+ r_cmd->reserved5 = OSSwapInt64(r_cmd->reserved5); -+ r_cmd->reserved6 = OSSwapInt64(r_cmd->reserved6); - } - - void -@@ -382,9 +383,9 @@ - struct prebind_cksum_command *cksum_cmd, - enum NXByteOrder target_byte_sex) - { -- cksum_cmd->cmd = NXSwapLong(cksum_cmd->cmd); -- cksum_cmd->cmdsize = NXSwapLong(cksum_cmd->cmdsize); -- cksum_cmd->cksum = NXSwapLong(cksum_cmd->cksum); -+ cksum_cmd->cmd = OSSwapInt32(cksum_cmd->cmd); -+ cksum_cmd->cmdsize = OSSwapInt32(cksum_cmd->cmdsize); -+ cksum_cmd->cksum = OSSwapInt32(cksum_cmd->cksum); - } - - void -@@ -392,8 +393,8 @@ - struct uuid_command *uuid_cmd, - enum NXByteOrder target_byte_sex) - { -- uuid_cmd->cmd = NXSwapLong(uuid_cmd->cmd); -- uuid_cmd->cmdsize = NXSwapLong(uuid_cmd->cmdsize); -+ uuid_cmd->cmd = OSSwapInt32(uuid_cmd->cmd); -+ uuid_cmd->cmdsize = OSSwapInt32(uuid_cmd->cmdsize); - } - - void -@@ -405,11 +406,11 @@ - uint32_t i; - - for(i = 0; i < nsymbols; i++){ -- symbols[i].n_un.n_strx = NXSwapLong(symbols[i].n_un.n_strx); -+ symbols[i].n_un.n_strx = OSSwapInt32(symbols[i].n_un.n_strx); - /* n_type */ - /* n_sect */ -- symbols[i].n_desc = NXSwapShort(symbols[i].n_desc); -- symbols[i].n_value = NXSwapLong(symbols[i].n_value); -+ symbols[i].n_desc = OSSwapInt16(symbols[i].n_desc); -+ symbols[i].n_value = OSSwapInt32(symbols[i].n_value); - } - } - -@@ -422,11 +423,11 @@ - uint32_t i; - - for(i = 0; i < nsymbols; i++){ -- symbols[i].n_un.n_strx = NXSwapLong(symbols[i].n_un.n_strx); -+ symbols[i].n_un.n_strx = OSSwapInt32(symbols[i].n_un.n_strx); - /* n_type */ - /* n_sect */ -- symbols[i].n_desc = NXSwapShort(symbols[i].n_desc); -- symbols[i].n_value = NXSwapLongLong(symbols[i].n_value); -+ symbols[i].n_desc = OSSwapInt16(symbols[i].n_desc); -+ symbols[i].n_value = OSSwapInt64(symbols[i].n_value); - } - } - -@@ -439,8 +440,8 @@ - uint32_t i; - - for(i = 0; i < nranlibs; i++){ -- ranlibs[i].ran_un.ran_strx = NXSwapLong(ranlibs[i].ran_un.ran_strx); -- ranlibs[i].ran_off = NXSwapLong(ranlibs[i].ran_off); -+ ranlibs[i].ran_un.ran_strx = OSSwapInt32(ranlibs[i].ran_un.ran_strx); -+ ranlibs[i].ran_off = OSSwapInt32(ranlibs[i].ran_off); - } - } - -@@ -455,7 +456,7 @@ - uint32_t to_host_byte_sex, scattered; - - struct swapped_relocation_info { -- long r_address; -+ uint32_t r_address; - union { - struct { - unsigned int -@@ -471,7 +472,7 @@ - - struct swapped_scattered_relocation_info { - uint32_t word; -- long r_value; -+ uint32_t r_value; - } *ssr; - - host_byte_sex = NXHostByteOrder(); -@@ -479,14 +480,14 @@ - - for(i = 0; i < nrelocs; i++){ - if(to_host_byte_sex) -- scattered = (NXSwapLong(relocs[i].r_address) & R_SCATTERED) != 0; -+ scattered = (OSSwapInt32(relocs[i].r_address) & R_SCATTERED) != 0; - else - scattered = ((relocs[i].r_address) & R_SCATTERED) != 0; - if(scattered == FALSE){ - if(to_host_byte_sex){ - memcpy(&sr, relocs + i, sizeof(struct relocation_info)); -- sr.r_address = NXSwapLong(sr.r_address); -- sr.u.word = NXSwapLong(sr.u.word); -+ sr.r_address = OSSwapInt32(sr.r_address); -+ sr.u.word = OSSwapInt32(sr.u.word); - relocs[i].r_address = sr.r_address; - relocs[i].r_symbolnum = sr.u.fields.r_symbolnum; - relocs[i].r_pcrel = sr.u.fields.r_pcrel; -@@ -501,15 +502,15 @@ - sr.u.fields.r_pcrel = relocs[i].r_pcrel; - sr.u.fields.r_extern = relocs[i].r_extern; - sr.u.fields.r_type = relocs[i].r_type; -- sr.r_address = NXSwapLong(sr.r_address); -- sr.u.word = NXSwapLong(sr.u.word); -+ sr.r_address = OSSwapInt32(sr.r_address); -+ sr.u.word = OSSwapInt32(sr.u.word); - memcpy(relocs + i, &sr, sizeof(struct relocation_info)); - } - } - else{ - ssr = (struct swapped_scattered_relocation_info *)(relocs + i); -- ssr->word = NXSwapLong(ssr->word); -- ssr->r_value = NXSwapLong(ssr->r_value); -+ ssr->word = OSSwapInt32(ssr->word); -+ ssr->r_value = OSSwapInt32(ssr->r_value); - } - } - } -@@ -523,7 +524,7 @@ - uint32_t i; - - for(i = 0; i < nindirect_symbols; i++) -- indirect_symbols[i] = NXSwapLong(indirect_symbols[i]); -+ indirect_symbols[i] = OSSwapInt32(indirect_symbols[i]); - } - - void -@@ -551,14 +552,14 @@ - for(i = 0; i < nrefs; i++){ - if(target_byte_sex == host_byte_sex){ - memcpy(&sref, refs + i, sizeof(struct swapped_dylib_reference)); -- sref.u.word = NXSwapLong(sref.u.word); -+ sref.u.word = OSSwapInt32(sref.u.word); - refs[i].flags = sref.u.fields.flags; - refs[i].isym = sref.u.fields.isym; - } - else{ - sref.u.fields.isym = refs[i].isym; - sref.u.fields.flags = refs[i].flags; -- sref.u.word = NXSwapLong(sref.u.word); -+ sref.u.word = OSSwapInt32(sref.u.word); - memcpy(refs + i, &sref, sizeof(struct swapped_dylib_reference)); - } - } -@@ -574,19 +575,19 @@ - uint32_t i; - - for(i = 0; i < nmods; i++){ -- mods[i].module_name = NXSwapLong(mods[i].module_name); -- mods[i].iextdefsym = NXSwapLong(mods[i].iextdefsym); -- mods[i].nextdefsym = NXSwapLong(mods[i].nextdefsym); -- mods[i].irefsym = NXSwapLong(mods[i].irefsym); -- mods[i].nrefsym = NXSwapLong(mods[i].nrefsym); -- mods[i].ilocalsym = NXSwapLong(mods[i].ilocalsym); -- mods[i].nlocalsym = NXSwapLong(mods[i].nlocalsym); -- mods[i].iextrel = NXSwapLong(mods[i].iextrel); -- mods[i].nextrel = NXSwapLong(mods[i].nextrel); -- mods[i].iinit_iterm = NXSwapLong(mods[i].iinit_iterm); -- mods[i].ninit_nterm = NXSwapLong(mods[i].ninit_nterm); -- mods[i].objc_module_info_size = NXSwapLong(mods[i].objc_module_info_size); -- mods[i].objc_module_info_addr = NXSwapLong(mods[i].objc_module_info_addr); -+ mods[i].module_name = OSSwapInt32(mods[i].module_name); -+ mods[i].iextdefsym = OSSwapInt32(mods[i].iextdefsym); -+ mods[i].nextdefsym = OSSwapInt32(mods[i].nextdefsym); -+ mods[i].irefsym = OSSwapInt32(mods[i].irefsym); -+ mods[i].nrefsym = OSSwapInt32(mods[i].nrefsym); -+ mods[i].ilocalsym = OSSwapInt32(mods[i].ilocalsym); -+ mods[i].nlocalsym = OSSwapInt32(mods[i].nlocalsym); -+ mods[i].iextrel = OSSwapInt32(mods[i].iextrel); -+ mods[i].nextrel = OSSwapInt32(mods[i].nextrel); -+ mods[i].iinit_iterm = OSSwapInt32(mods[i].iinit_iterm); -+ mods[i].ninit_nterm = OSSwapInt32(mods[i].ninit_nterm); -+ mods[i].objc_module_info_size = OSSwapInt32(mods[i].objc_module_info_size); -+ mods[i].objc_module_info_addr = OSSwapInt32(mods[i].objc_module_info_addr); - } - } - -@@ -599,19 +600,19 @@ - uint32_t i; - - for(i = 0; i < nmods; i++){ -- mods[i].module_name = NXSwapLong(mods[i].module_name); -- mods[i].iextdefsym = NXSwapLong(mods[i].iextdefsym); -- mods[i].nextdefsym = NXSwapLong(mods[i].nextdefsym); -- mods[i].irefsym = NXSwapLong(mods[i].irefsym); -- mods[i].nrefsym = NXSwapLong(mods[i].nrefsym); -- mods[i].ilocalsym = NXSwapLong(mods[i].ilocalsym); -- mods[i].nlocalsym = NXSwapLong(mods[i].nlocalsym); -- mods[i].iextrel = NXSwapLong(mods[i].iextrel); -- mods[i].nextrel = NXSwapLong(mods[i].nextrel); -- mods[i].iinit_iterm = NXSwapLong(mods[i].iinit_iterm); -- mods[i].ninit_nterm = NXSwapLong(mods[i].ninit_nterm); -- mods[i].objc_module_info_size = NXSwapLong(mods[i].objc_module_info_size); -- mods[i].objc_module_info_addr = NXSwapLongLong(mods[i].objc_module_info_addr); -+ mods[i].module_name = OSSwapInt32(mods[i].module_name); -+ mods[i].iextdefsym = OSSwapInt32(mods[i].iextdefsym); -+ mods[i].nextdefsym = OSSwapInt32(mods[i].nextdefsym); -+ mods[i].irefsym = OSSwapInt32(mods[i].irefsym); -+ mods[i].nrefsym = OSSwapInt32(mods[i].nrefsym); -+ mods[i].ilocalsym = OSSwapInt32(mods[i].ilocalsym); -+ mods[i].nlocalsym = OSSwapInt32(mods[i].nlocalsym); -+ mods[i].iextrel = OSSwapInt32(mods[i].iextrel); -+ mods[i].nextrel = OSSwapInt32(mods[i].nextrel); -+ mods[i].iinit_iterm = OSSwapInt32(mods[i].iinit_iterm); -+ mods[i].ninit_nterm = OSSwapInt32(mods[i].ninit_nterm); -+ mods[i].objc_module_info_size = OSSwapInt32(mods[i].objc_module_info_size); -+ mods[i].objc_module_info_addr = OSSwapInt64(mods[i].objc_module_info_addr); - } - } - -@@ -624,8 +625,8 @@ - uint32_t i; - - for(i = 0; i < ntocs; i++){ -- tocs[i].symbol_index = NXSwapLong(tocs[i].symbol_index); -- tocs[i].module_index = NXSwapLong(tocs[i].module_index); -+ tocs[i].symbol_index = OSSwapInt32(tocs[i].symbol_index); -+ tocs[i].module_index = OSSwapInt32(tocs[i].module_index); - } - } - #endif /* !defined(RLD) */ -Index: odcctools-9.2-ld/include/mach/machine.h -=================================================================== ---- odcctools-9.2-ld.orig/include/mach/machine.h 2013-09-03 21:08:01.481209525 +0000 -+++ odcctools-9.2-ld/include/mach/machine.h 2013-09-03 21:08:01.881209515 +0000 -@@ -302,7 +302,14 @@ - #define CPU_SUBTYPE_ARM_A500 ((cpu_subtype_t) 2) - #define CPU_SUBTYPE_ARM_A440 ((cpu_subtype_t) 3) - #define CPU_SUBTYPE_ARM_M4 ((cpu_subtype_t) 4) --#define CPU_SUBTYPE_ARM_A680 ((cpu_subtype_t) 5) -+#define CPU_SUBTYPE_ARM_V4T ((cpu_subtype_t) 5) -+#define CPU_SUBTYPE_ARM_V6 ((cpu_subtype_t) 6) -+#define CPU_SUBTYPE_ARM_V5TEJ ((cpu_subtype_t) 7) -+#define CPU_SUBTYPE_ARM_XSCALE ((cpu_subtype_t) 8) -+#define CPU_SUBTYPE_ARM_V7 ((cpu_subtype_t) 9) -+#define CPU_SUBTYPE_ARM_V7F ((cpu_subtype_t) 10) /* Cortex A9 */ -+#define CPU_SUBTYPE_ARM_V7S ((cpu_subtype_t) 11) /* Swift */ -+#define CPU_SUBTYPE_ARM_V7K ((cpu_subtype_t) 12) /* Kirkwood40 */ - - /* - * MC88000 subtypes -@@ -380,11 +387,4 @@ - #define CPU_SUBTYPE_VEO_4 ((cpu_subtype_t) 4) - #define CPU_SUBTYPE_VEO_ALL CPU_SUBTYPE_VEO_2 - --#define CPU_SUBTYPE_ARM_V4T ((cpu_subtype_t) 5) --#define CPU_SUBTYPE_ARM_V6 ((cpu_subtype_t) 6) --#define CPU_SUBTYPE_ARM_V5TEJ ((cpu_subtype_t) 7) --#define CPU_SUBTYPE_ARM_XSCALE ((cpu_subtype_t) 8) --#define CPU_SUBTYPE_ARM_ALL ((cpu_subtype_t) 0) -- -- - #endif /* _MACH_MACHINE_H_ */ -Index: odcctools-9.2-ld/ar/archive.c -=================================================================== ---- odcctools-9.2-ld.orig/ar/archive.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/ar/archive.c 2013-09-03 21:08:01.881209515 +0000 -@@ -114,6 +114,9 @@ - if ((fd = open(archive, mode, DEFFILEMODE)) < 0) - error(archive); - -+ if((mode & O_ACCMODE) == O_RDONLY) -+ goto skip_flock; -+ - /* - * Attempt to place a lock on the opened file - if we get an - * error then someone is already working on this library (or -@@ -121,6 +124,18 @@ - */ - opened: - r = flock(fd, LOCK_EX|LOCK_NB); -+ if (r && errno == EAGAIN) { -+ /* -+ * If we get EAGAIN sleep for a second and loop up to 10 times -+ * trying again. -+ */ -+ static int tries = 0; -+ -+ sleep(1); -+ tries++; -+ if (tries < 10) -+ goto opened; -+ } - if (r) { - switch (errno) - { -@@ -152,12 +167,13 @@ - /* Locking seems to not be working */ - case ENOTSUP: - case EHOSTUNREACH: -- /*case EBADRPC:*/ -+ /* case EBADRPC: */ - default: - /* Filesystem does not support locking */ - break; - } - } -+skip_flock: - - /* - * If not created, O_RDONLY|O_RDWR indicates that it has to be -@@ -170,8 +186,8 @@ - badfmt(); - error(archive); - } else if (bcmp(buf, ARMAG, SARMAG)) { -- unsigned long magic; -- memcpy(&magic, buf, sizeof(unsigned long)); -+ uint32_t magic; -+ memcpy(&magic, buf, sizeof(uint32_t)); - #ifdef __BIG_ENDIAN__ - if(magic == FAT_MAGIC) - #endif /* __BIG_ENDIAN__ */ -@@ -288,6 +304,7 @@ - char *name; - struct ar_hdr *hdr; - off_t size; -+ long int tv_sec; - - /* - * If passed an sb structure, reading a file from disk. Get stat(2) -@@ -299,6 +316,8 @@ - name = rname(cfp->rname); - (void)fstat(cfp->rfd, sb); - -+ tv_sec = (long int)0; -+ - /* - * If not truncating names and the name is too long or contains - * a space, use extended format 1. -@@ -311,24 +330,24 @@ - name, OLDARMAXNAME, name); - (void)fflush(stderr); - } -- (void)sprintf(hb, HDR3, name, (long int)sb->st_mtime, -+ (void)sprintf(hb, HDR3, name, (long int)tv_sec, - (unsigned int)(u_short)sb->st_uid, - (unsigned int)(u_short)sb->st_gid, -- sb->st_mode, (long long int) sb->st_size, ARFMAG); -+ sb->st_mode, sb->st_size, ARFMAG); - lname = 0; - } else if (lname > sizeof(hdr->ar_name) || strchr(name, ' ')) - (void)sprintf(hb, HDR1, AR_EFMT1, (lname + 3) & ~3, -- (long int)sb->st_mtime, -+ (long int)tv_sec, - (unsigned int)(u_short)sb->st_uid, - (unsigned int)(u_short)sb->st_gid, -- sb->st_mode, (long long int) sb->st_size + ((lname + 3) & ~3), -+ sb->st_mode, sb->st_size + ((lname + 3) & ~3), - ARFMAG); - else { - lname = 0; -- (void)sprintf(hb, HDR2, name, (long int)sb->st_mtime, -+ (void)sprintf(hb, HDR2, name, (long int)tv_sec, - (unsigned int)(u_short)sb->st_uid, - (unsigned int)(u_short)sb->st_gid, -- sb->st_mode, (long long int) sb->st_size, ARFMAG); -+ sb->st_mode, sb->st_size, ARFMAG); - } - size = sb->st_size; - } else { -Index: odcctools-9.2-ld/ar/archive.h -=================================================================== ---- odcctools-9.2-ld.orig/ar/archive.h 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/ar/archive.h 2013-09-03 21:08:01.881209515 +0000 -@@ -121,10 +121,6 @@ - - #include <sys/cdefs.h> - --#if defined(__CYGWIN__) --#define DEFFILEMODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)/* 0666*/ --#endif -- - struct stat; - - void close_archive __P((int)); -Index: odcctools-9.2-ld/as/app.c -=================================================================== ---- odcctools-9.2-ld.orig/as/app.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/app.c 2013-09-03 21:08:01.881209515 +0000 -@@ -70,6 +70,7 @@ - memset(lex, '\0', sizeof(lex)); /* Trust NOBODY! */ - lex [' '] |= LEX_IS_WHITESPACE; - lex ['\t'] |= LEX_IS_WHITESPACE; -+ lex ['\r'] |= LEX_IS_WHITESPACE; - for (p =symbol_chars;*p;++p) - lex [(int)*p] |= LEX_IS_SYMBOL_COMPONENT; - lex ['\n'] |= LEX_IS_LINE_SEPERATOR; -@@ -289,6 +290,9 @@ - do ch= getc_unlocked(fp); - while(ch!='\n'); - state=0; -+#ifdef I386 -+ substate = 0; -+#endif - return ch; - } - -@@ -403,8 +407,12 @@ - return *out_string++; - - case ':': -- if(state!=3) -+ if(state!=3) { - state=0; -+#ifdef I386 -+ substate = 0; -+#endif -+ } - return ch; - - case '\n': -@@ -419,6 +427,9 @@ - case ';': - #endif - state=0; -+#ifdef I386 -+ substate = 0; -+#endif - return ch; - - default: -@@ -465,6 +476,9 @@ - if(ch==EOF) - as_warn("EOF in Comment: Newline inserted"); - state=0; -+#ifdef I386 -+ substate = 0; -+#endif - return '\n'; - } - ungetc(ch, fp); -@@ -479,6 +493,9 @@ - if(ch==EOF) - as_warn("EOF in comment: Newline inserted"); - state=0; -+#ifdef I386 -+ substate = 0; -+#endif - return '\n'; - - } else if(state==0) { -@@ -658,6 +675,9 @@ - do ch= scrub_from_string(); - while(ch!='\n'); - state=0; -+#ifdef I386 -+ substate = 0; -+#endif - return ch; - } - -@@ -757,8 +777,12 @@ - return *out_string++; - - case ':': -- if(state!=3) -+ if(state!=3) { - state=0; -+#ifdef I386 -+ substate = 0; -+#endif -+ } - return ch; - - case '\n': -@@ -773,6 +797,9 @@ - case ';': - #endif - state=0; -+#ifdef I386 -+ substate = 0; -+#endif - return ch; - - default: -@@ -792,6 +819,9 @@ - if(ch==EOF) - as_warn("EOF in Comment: Newline inserted"); - state=0; -+#ifdef I386 -+ substate = 0; -+#endif - return '\n'; - } - scrub_to_string(ch); -@@ -806,6 +836,9 @@ - if(ch==EOF) - as_warn("EOF in comment: Newline inserted"); - state=0; -+#ifdef I386 -+ substate = 0; -+#endif - return '\n'; - - } else if(state==0) { -Index: odcctools-9.2-ld/as/as.c -=================================================================== ---- odcctools-9.2-ld.orig/as/as.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/as.c 2013-09-03 21:08:01.881209515 +0000 -@@ -46,8 +46,12 @@ - #include "xmalloc.h" - #include "layout.h" - #include "write_object.h" -+#include "dwarf2dbg.h" - #include "stuff/arch.h" - -+/* Used for --gdwarf2 to generate dwarf2 debug info for assembly source files */ -+enum debug_info_type debug_type = DEBUG_NONE; -+ - /* ['x'] TRUE if "-x" seen. */ - char flagseen[128] = { 0 }; - -@@ -76,10 +80,11 @@ - struct directory_stack *include = NULL; /* First dir to search */ - static struct directory_stack *include_tail = NULL; /* Last in chain */ - --/* apple_version is in apple_version.c which is created by the Makefile */ --extern char apple_version[]; --/* this is only used here, thus defined here (was in version.c in GAS) */ --static char version_string[] = "GNU assembler version 1.38\n"; -+/* this is only used here, and in dwarf2dbg.c as the producer */ -+char version_string[] = "GNU assembler version 1.38"; -+ -+/* this is set here, and used in dwarf2dbg.c as the apple_flags */ -+char *apple_flags = NULL; - - /* - * The list of signals to catch if not ignored. -@@ -109,7 +114,7 @@ - char *arg; /* an arg to program */ - char a; /* an arg flag (after -) */ - char *out_file_name;/* name of object file, argument to -o if specified */ -- int i; -+ int i, apple_flags_size; - struct directory_stack *dirtmp; - - progname = argv[0]; -@@ -129,6 +134,20 @@ - /* This is the -dynamic flag, which is now the default */ - flagseen[(int)'k'] = TRUE; - -+ if(getenv("RC_DEBUG_OPTIONS") != NULL){ -+ apple_flags_size = 1; -+ for(i = 0; i < argc; i++) -+ apple_flags_size += strlen(argv[i]) + 2; -+ apple_flags = xmalloc(apple_flags_size); -+ apple_flags_size = 0; -+ for(i = 0; i < argc; i++){ -+ strcpy(apple_flags + apple_flags_size, argv[i]); -+ apple_flags_size += strlen(argv[i]); -+ apple_flags[apple_flags_size++] = ' '; -+ } -+ apple_flags[apple_flags_size] = '\0'; -+ } -+ - /* - * Parse arguments, but we are only interested in flags. - * When we find a flag, we process it then make it's argv[] NULL. -@@ -156,8 +175,10 @@ - *work_argv = NULL; /* NULL means 'not a file-name' */ - continue; - } -- if(strcmp(arg, "--gdwarf2") == 0){ -- as_fatal("%s: I don't understand %s flag!", progname, arg); -+ if(strcmp(arg, "--gdwarf2") == 0 || strcmp(arg, "-gdwarf-2") == 0){ -+ debug_type = DEBUG_DWARF2; -+ *work_argv = NULL; /* NULL means 'not a file-name' */ -+ continue; - } - - /* Keep scanning args looking for flags. */ -@@ -179,7 +200,7 @@ - (a != 'd') && (a != 's') && (a != 'k')) - as_warn("%s: Flag option -%c has already been seen!", - progname, a); -- if(a != 'f' && a != 'n') -+ if(a != 'f' && a != 'n' && a != 'g') - flagseen[(int)a] = TRUE; - switch(a){ - case 'f': -@@ -217,9 +238,8 @@ - break; - - case 'v': -- fprintf(stderr,"Apple Computer, Inc. version " -- "%s, ", apple_version); -- fprintf(stderr, version_string); -+ fprintf(stderr, APPLE_INC_VERSION " %s, ", apple_version); -+ fprintf(stderr, "%s\n", version_string); - if(*arg && strcmp(arg,"ersion")) - as_fatal("Unknown -v option ignored"); - while(*arg) -@@ -258,7 +278,10 @@ - break; - - case 'g': -- /* generate stabs for debugging assembly code */ -+ /* -g no longer means generate stabs for debugging -+ assembly code but to generate dwarf2 for assembly code. -+ If stabs if really wanted then --gstabs can be used. */ -+ debug_type = DEBUG_DWARF2; - break; - - case 'n': -@@ -683,6 +706,50 @@ - archflag_cpusubtype = - CPU_SUBTYPE_ARM_V6; - } -+ else if(strcmp(*work_argv, -+ "armv7") == 0){ -+ if(archflag_cpusubtype != -1 && -+ archflag_cpusubtype != -+ CPU_SUBTYPE_ARM_V7) -+ as_fatal("can't specify more " -+ "than one -arch flag "); -+ specific_archflag = *work_argv; -+ archflag_cpusubtype = -+ CPU_SUBTYPE_ARM_V7; -+ } -+ else if(strcmp(*work_argv, -+ "armv7f") == 0){ -+ if(archflag_cpusubtype != -1 && -+ archflag_cpusubtype != -+ CPU_SUBTYPE_ARM_V7F) -+ as_fatal("can't specify more " -+ "than one -arch flag "); -+ specific_archflag = *work_argv; -+ archflag_cpusubtype = -+ CPU_SUBTYPE_ARM_V7F; -+ } -+ else if(strcmp(*work_argv, -+ "armv7s") == 0){ -+ if(archflag_cpusubtype != -1 && -+ archflag_cpusubtype != -+ CPU_SUBTYPE_ARM_V7S) -+ as_fatal("can't specify more " -+ "than one -arch flag "); -+ specific_archflag = *work_argv; -+ archflag_cpusubtype = -+ CPU_SUBTYPE_ARM_V7S; -+ } -+ else if(strcmp(*work_argv, -+ "armv7k") == 0){ -+ if(archflag_cpusubtype != -1 && -+ archflag_cpusubtype != -+ CPU_SUBTYPE_ARM_V7K) -+ as_fatal("can't specify more " -+ "than one -arch flag "); -+ specific_archflag = *work_argv; -+ archflag_cpusubtype = -+ CPU_SUBTYPE_ARM_V7K; -+ } - else - as_fatal("I expected 'arm' after " - "-arch for this assembler."); -@@ -753,6 +820,12 @@ - perform_an_assembly_pass(argc, argv); /* Assemble it. */ - - if(seen_at_least_1_file() && bad_error != TRUE){ -+ /* -+ * If we've been collecting dwarf2 .debug_line info, either for -+ * assembly debugging or on behalf of the compiler, emit it now. -+ */ -+ dwarf2_finish(); -+ - layout_addresses(); - write_object(out_file_name); - } -Index: odcctools-9.2-ld/as/driver.c -=================================================================== ---- odcctools-9.2-ld.orig/as/driver.c 2013-09-03 21:08:01.409209526 +0000 -+++ odcctools-9.2-ld/as/driver.c 2013-09-03 21:08:01.881209515 +0000 -@@ -45,8 +45,8 @@ - #endif - const char *AS = "/as"; - -- int i; -- unsigned long count, verbose; -+ int i, j; -+ uint32_t count, verbose, run_clang; - char *p, c, *arch_name, *as, *as_local; - char *prefix, buf[MAXPATHLEN], resolved_name[PATH_MAX]; - uint32_t bufsize; -Index: odcctools-9.2-ld/as/i386.c -=================================================================== ---- odcctools-9.2-ld.orig/as/i386.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/i386.c 2013-09-03 21:08:01.885209515 +0000 -@@ -158,7 +158,7 @@ - #endif - #ifdef ARCH64 - #ifdef NeXT_MOD --static symbolS *x86_64_resolve_local_symbol(const symbolS *sym); -+static symbolS *x86_64_resolve_local_symbol(symbolS *sym); - #endif - #endif - -@@ -1022,7 +1022,7 @@ - } - - #ifndef NeXT_MOD --unsigned long -+uint32_t - i386_mach () - { - if (!strcmp (default_arch, "x86_64")) -@@ -1266,7 +1266,7 @@ - { - fprintf (stdout, " operation %d\n", e->X_op); - fprintf (stdout, " add_number %ld (%lx)\n", -- (long) e->X_add_number, (long) e->X_add_number); -+ (int32_t) e->X_add_number, (int32_t) e->X_add_number); - if (e->X_add_symbol) - { - fprintf (stdout, " add_symbol "); -@@ -1377,7 +1377,7 @@ - case 4: return BFD_RELOC_32_PCREL; - #endif - } -- as_bad (_("can not do %d byte pc-relative relocation"), size); -+ as_bad (_("cannot do %d byte pc-relative relocation"), size); - } - else - { -@@ -1408,7 +1408,7 @@ - case 8: return BFD_RELOC_64; - #endif - } -- as_bad (_("can not do %s %d byte relocation"), -+ as_bad (_("cannot do %s %d byte relocation"), - sign ? "signed" : "unsigned", size); - } - -@@ -5893,7 +5893,7 @@ - next instruction. That is, the address of the offset, plus its - size, since the offset is always the last part of the insn. */ - --long -+int32_t - md_pcrel_from (fixP) - #ifdef NeXT_MOD - const -@@ -5965,7 +5965,7 @@ - #if ARCH64 - static - symbolS * --x86_64_resolve_local_symbol(const symbolS *sym) -+x86_64_resolve_local_symbol(symbolS *sym) - { - symbolS *prev_symbol; - for (prev_symbol = sym->sy_prev_by_index; prev_symbol != NULL; prev_symbol = prev_symbol->sy_prev_by_index) -@@ -5988,7 +5988,7 @@ - return prev_symbol; - } - --long -+int32_t - x86_64_fixup_symbol(fixS *fix, int nsect, symbolS **sym) - { - /* -Index: odcctools-9.2-ld/as/i386.h -=================================================================== ---- odcctools-9.2-ld.orig/as/i386.h 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/i386.h 2013-09-03 21:08:01.885209515 +0000 -@@ -43,8 +43,9 @@ - #define ADDR_PREFIX 2 - #define DATA_PREFIX 3 - #define SEG_PREFIX 4 --#define REX_PREFIX 5 /* must come last. */ --#define MAX_PREFIXES 6 /* max prefixes per opcode */ -+#define MAN_PREFIX 5 /* 0xf2,0xf3,etc "mandatory" prefix, not REPs */ -+#define REX_PREFIX 6 /* must come last. */ -+#define MAX_PREFIXES 7 /* max prefixes per opcode */ - - /* we define the syntax here (modulo base,index,scale syntax) */ - #define REGISTER_PREFIX '%' -@@ -366,7 +367,7 @@ - - #ifdef NeXT_MOD - #if ARCH64 --long x86_64_fixup_symbol PARAMS ((fixS *, int, struct symbol **)); -+int32_t x86_64_fixup_symbol PARAMS ((fixS *, int, struct symbol **)); - #define TC_FIXUP_SYMBOL(FIX, SECT, SYM) x86_64_fixup_symbol(FIX, SECT, SYM) - #endif - #endif -Index: odcctools-9.2-ld/as/dwarf2dbg.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ odcctools-9.2-ld/as/dwarf2dbg.c 2013-09-03 21:08:01.885209515 +0000 -@@ -0,0 +1,2298 @@ -+/* dwarf2dbg.c - DWARF2 debug support -+ Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 -+ Free Software Foundation, Inc. -+ Contributed by David Mosberger-Tang <davidm@hpl.hp.com> -+ -+ This file is part of GAS, the GNU Assembler. -+ -+ GAS is free software; you can redistribute it and/or modify -+ it under the terms of the GNU General Public License as published by -+ the Free Software Foundation; either version 2, or (at your option) -+ any later version. -+ -+ GAS 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 GAS; see the file COPYING. If not, write to the Free -+ Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA -+ 02110-1301, USA. */ -+ -+/* Logical line numbers can be controlled by the compiler via the -+ following directives: -+ -+ .file FILENO "file.c" -+ .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \ -+ [epilogue_begin] [is_stmt VALUE] [isa VALUE] -+*/ -+ -+#include <stdlib.h> -+#include <string.h> -+#include <unistd.h> -+#include <sys/param.h> -+#include <libgen.h> -+#define ATTRIBUTE_UNUSED -+#define NO_LISTING -+ -+#include "as.h" -+#include "md.h" -+#include "obstack.h" -+/* Use ctype.h and these directly instead of "safe-ctype.h" */ -+#include "ctype.h" -+#define ISALPHA(c) isalpha(c) -+#define ISDIGIT(c) isdigit(c) -+ -+#ifdef HAVE_LIMITS_H -+#include <limits.h> -+#else -+#ifdef HAVE_SYS_PARAM_H -+#include <sys/param.h> -+#endif -+#ifndef INT_MAX -+#define INT_MAX (int) (((unsigned) (-1)) >> 1) -+#endif -+#endif -+ -+#include "dwarf2dbg.h" -+#include <filenames.h> -+ -+#ifdef HAVE_DOS_BASED_FILE_SYSTEM -+/* We need to decide which character to use as a directory separator. -+ Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not -+ necessarily mean that the backslash character is the one to use. -+ Some environments, eg Cygwin, can support both naming conventions. -+ So we use the heuristic that we only need to use the backslash if -+ the path is an absolute path starting with a DOS style drive -+ selector. eg C: or D: */ -+# define INSERT_DIR_SEPARATOR(string, offset) \ -+ do \ -+ { \ -+ if (offset > 1 \ -+ && string[0] != 0 \ -+ && string[1] == ':') \ -+ string [offset] = '\\'; \ -+ else \ -+ string [offset] = '/'; \ -+ } \ -+ while (0) -+#else -+# define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/' -+#endif -+ -+#ifndef DWARF2_FORMAT -+# define DWARF2_FORMAT() dwarf2_format_32bit -+#endif -+ -+#ifndef DWARF2_ADDR_SIZE -+# define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8) -+#endif -+ -+#include "sections.h" -+#include "frags.h" -+#include "read.h" -+#include "xmalloc.h" -+#include "input-scrub.h" -+#include "messages.h" -+#include "symbols.h" -+#include "layout.h" -+ -+#include "elf/dwarf2.h" -+ -+/* Since we can't generate the prolog until the body is complete, we -+ use three different subsegments for .debug_line: one holding the -+ prolog, one for the directory and filename info, and one for the -+ body ("statement program"). */ -+#define DL_PROLOG 0 -+#define DL_FILES 1 -+#define DL_BODY 2 -+ -+/* If linker relaxation might change offsets in the code, the DWARF special -+ opcodes and variable-length operands cannot be used. If this macro is -+ nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */ -+#ifndef DWARF2_USE_FIXED_ADVANCE_PC -+# define DWARF2_USE_FIXED_ADVANCE_PC 0 -+#endif -+ -+/* First special line opcde - leave room for the standard opcodes. -+ Note: If you want to change this, you'll have to update the -+ "standard_opcode_lengths" table that is emitted below in -+ out_debug_line(). */ -+#define DWARF2_LINE_OPCODE_BASE 13 -+ -+#ifndef DWARF2_LINE_BASE -+ /* Minimum line offset in a special line info. opcode. This value -+ was chosen to give a reasonable range of values. */ -+# define DWARF2_LINE_BASE -5 -+#endif -+ -+/* Range of line offsets in a special line info. opcode. */ -+#ifndef DWARF2_LINE_RANGE -+# define DWARF2_LINE_RANGE 14 -+#endif -+ -+#ifndef DWARF2_LINE_MIN_INSN_LENGTH -+ /* Define the architecture-dependent minimum instruction length (in -+ bytes). This value should be rather too small than too big. */ -+# define DWARF2_LINE_MIN_INSN_LENGTH 1 -+#endif -+ -+/* Flag that indicates the initial value of the is_stmt_start flag. */ -+#define DWARF2_LINE_DEFAULT_IS_STMT 1 -+ -+/* Given a special op, return the line skip amount. */ -+#define SPECIAL_LINE(op) \ -+ (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE) -+ -+/* Given a special op, return the address skip amount (in units of -+ DWARF2_LINE_MIN_INSN_LENGTH. */ -+#define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE) -+ -+/* The maximum address skip amount that can be encoded with a special op. */ -+#define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255) -+ -+struct line_entry { -+ struct line_entry *next; -+ symbolS *label; -+ struct dwarf2_line_info loc; -+}; -+ -+struct line_subseg { -+ struct line_subseg *next; -+ subsegT subseg; -+ struct line_entry *head; -+ struct line_entry **ptail; -+}; -+ -+struct line_seg { -+ struct line_seg *next; -+ segT seg; -+ struct line_subseg *head; -+ symbolS *text_start; -+ symbolS *text_end; -+}; -+ -+/* Collects data for all line table entries during assembly. */ -+static struct line_seg *all_segs; -+ -+struct file_entry { -+ char *filename; -+ unsigned int dir; -+}; -+ -+/* Table of files used by .debug_line. */ -+static struct file_entry *files; -+static unsigned int files_in_use; -+static unsigned int files_allocated; -+ -+/* Table of directories used by .debug_line. */ -+static char **dirs; -+static unsigned int dirs_in_use; -+static unsigned int dirs_allocated; -+ -+/* TRUE when we've seen a .loc directive recently. Used to avoid -+ doing work when there's nothing to do. */ -+static bfd_boolean loc_directive_seen; -+ -+/* TRUE when we're supposed to set the basic block mark whenever a -+ label is seen. */ -+bfd_boolean dwarf2_loc_mark_labels; -+ -+/* Current location as indicated by the most recent .loc directive. */ -+static struct dwarf2_line_info current = { -+ 1, 1, 0, 0, -+ DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0 -+}; -+ -+/* When creating dwarf2 debugging information for assembly files, the --gdwarf2 -+ flag is specified, the variable dwarf2_file_number is used to generate a -+ .file for each assembly source file in read_a_source_file(). */ -+uint32_t dwarf2_file_number = 0; -+ -+/* Info gathered where creating dwarf2 debugging information for assembly files -+ when --gdwarf2 is specified. This is done in make_subprogram_for_symbol() -+ in symbols.c . */ -+struct dwarf2_subprogram_info *dwarf2_subprograms_info = NULL; -+ -+/* The size of an address on the target. */ -+static unsigned int sizeof_address; -+ -+static struct line_subseg *get_line_subseg (segT, subsegT); -+static unsigned int get_filenum (char *, unsigned int); -+static struct frag *first_frag_for_seg (segT); -+static struct frag *last_frag_for_seg (segT); -+static void out_byte (int); -+static void out_opcode (int); -+static void out_two (int); -+static void out_four (int); -+static void out_abbrev (int, int); -+static void out_uleb128 (addressT); -+static void out_sleb128 (addressT); -+static offsetT get_frag_fix (fragS *, segT); -+static void out_set_addr (symbolS *); -+static int size_inc_line_addr (int, addressT); -+static void emit_inc_line_addr (int, addressT, char *, int); -+static void out_inc_line_addr (int, addressT); -+static void out_fixed_inc_line_addr (int, symbolS *, symbolS *); -+static void relax_inc_line_addr (int, symbolS *, symbolS *); -+static int process_entries (segT, struct line_entry *); -+static void out_file_list (void); -+static void out_debug_line (struct frchain *); -+static void out_debug_aranges (struct frchain *, struct frchain *); -+static void out_debug_abbrev (struct frchain *); -+ -+/* -+ * This version of emit_expr() was based on the one in GAS's read.c but greatly -+ * simplified for the ported specific uses in here and the Mach-O version of the -+ * expression stuct. As such this looks at the X_seg field (aka X_op) and only -+ * deals with the expressions which have "type's" of SEG_SECT (aka O_symbol), -+ * and SEG_DIFFSECT. -+ * -+ * The function of this routine is to: -+ * Put the contents of expression EXP into the object file using -+ * NBYTES bytes. -+ */ -+static -+void -+emit_expr (expressionS *exp, unsigned int nbytes) -+{ -+ segT X_seg; -+ char *p; -+ -+ X_seg = exp->X_seg; -+ if(X_seg != SEG_SECT && X_seg != SEG_DIFFSECT) -+ as_fatal("internal error, emit_expr() called with unexpected expression " -+ "type"); -+ -+ p = frag_more ((int) nbytes); -+ -+ fix_new(frag_now, -+ p - frag_now->fr_literal, -+ nbytes, -+ exp->X_add_symbol, -+ exp->X_subtract_symbol, -+ exp->X_add_number, -+ 0, -+ 0, -+ 0); -+} -+ -+#define TC_DWARF2_EMIT_OFFSET macho_dwarf2_emit_offset -+static void -+macho_dwarf2_emit_offset (symbolS *symbol, unsigned int size); -+ -+#ifndef TC_DWARF2_EMIT_OFFSET -+#define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset -+ -+/* Create an offset to .dwarf2_*. */ -+ -+static void -+generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size) -+{ -+ expressionS expr; -+ -+ memset(&expr, '\0', sizeof(expr)); -+ expr.X_op = O_symbol; -+ expr.X_add_symbol = symbol; -+ expr.X_add_number = 0; -+ emit_expr (&expr, size); -+} -+#endif -+ -+/* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */ -+ -+static struct line_subseg * -+get_line_subseg (segT seg, subsegT subseg) -+{ -+ static segT last_seg; -+ static subsegT last_subseg; -+ static struct line_subseg *last_line_subseg; -+ -+ struct line_seg **ps, *s; -+ struct line_subseg **pss, *ss; -+ -+ if (seg == last_seg && subseg == last_subseg) -+ return last_line_subseg; -+ -+ for (ps = &all_segs; (s = *ps) != NULL; ps = &s->next) -+ if (s->seg == seg) -+ goto found_seg; -+ -+ s = (struct line_seg *) xmalloc (sizeof (*s)); -+ s->next = NULL; -+ s->seg = seg; -+ s->head = NULL; -+ *ps = s; -+ -+ found_seg: -+ for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next) -+ { -+ if (ss->subseg == subseg) -+ goto found_subseg; -+ if (ss->subseg > subseg) -+ break; -+ } -+ -+ ss = (struct line_subseg *) xmalloc (sizeof (*ss)); -+ ss->next = *pss; -+ ss->subseg = subseg; -+ ss->head = NULL; -+ ss->ptail = &ss->head; -+ *pss = ss; -+ -+ found_subseg: -+ last_seg = seg; -+ last_subseg = subseg; -+ last_line_subseg = ss; -+ -+ return ss; -+} -+ -+/* Record an entry for LOC occurring at LABEL. */ -+ -+static void -+dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc) -+{ -+ struct line_subseg *ss; -+ struct line_entry *e; -+ -+ e = (struct line_entry *) xmalloc (sizeof (*e)); -+ e->next = NULL; -+ e->label = label; -+ e->loc = *loc; -+ -+ ss = get_line_subseg (now_seg, now_subseg); -+ *ss->ptail = e; -+ ss->ptail = &e->next; -+} -+ -+/* Record an entry for LOC occurring at OFS within the current fragment. */ -+ -+void -+dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc) -+{ -+ static unsigned int line = -1; -+ static unsigned int filenum = -1; -+ -+ symbolS *sym; -+ -+ /* Early out for as-yet incomplete location information. */ -+ if (loc->filenum == 0 || loc->line == 0) -+ return; -+ -+ /* Don't emit sequences of line symbols for the same line when the -+ symbols apply to assembler code. It is necessary to emit -+ duplicate line symbols when a compiler asks for them, because GDB -+ uses them to determine the end of the prologue. */ -+ if (debug_type == DEBUG_DWARF2 -+ && line == loc->line && filenum == loc->filenum) -+ return; -+ -+ line = loc->line; -+ filenum = loc->filenum; -+ -+ sym = symbol_temp_new (now_seg, ofs, frag_now); -+ dwarf2_gen_line_info_1 (sym, loc); -+} -+ -+/* Returns the current source information. If .file directives have -+ been encountered, the info for the corresponding source file is -+ returned. Otherwise, the info for the assembly source file is -+ returned. */ -+ -+void -+dwarf2_where (struct dwarf2_line_info *line) -+{ -+ if (debug_type == DEBUG_DWARF2) -+ { -+ char *filename; -+#ifdef OLD -+ as_where (&filename, &line->line); -+#else -+ as_file_and_line(&filename, &line->line); -+#endif -+ line->filenum = get_filenum (filename, 0); -+ line->column = 0; -+ line->flags = DWARF2_FLAG_IS_STMT; -+ line->isa = current.isa; -+ } -+ else -+ *line = current; -+} -+ -+/* A hook to allow the target backend to inform the line number state -+ machine of isa changes when assembler debug info is enabled. */ -+ -+void -+dwarf2_set_isa (unsigned int isa) -+{ -+ current.isa = isa; -+} -+ -+/* Called for each machine instruction, or relatively atomic group of -+ machine instructions (ie built-in macro). The instruction or group -+ is SIZE bytes in length. If dwarf2 line number generation is called -+ for, emit a line statement appropriately. */ -+ -+void -+dwarf2_emit_insn (int size) -+{ -+ struct dwarf2_line_info loc; -+ -+ if (loc_directive_seen) -+ { -+ /* Use the last location established by a .loc directive, not -+ the value returned by dwarf2_where(). That calls as_where() -+ which will return either the logical input file name (foo.c) -+ or the physical input file name (foo.s) and not the file name -+ specified in the most recent .loc directive (eg foo.h). */ -+ loc = current; -+ -+ /* Unless we generate DWARF2 debugging information for each -+ assembler line, we only emit one line symbol for one LOC. */ -+ if (debug_type != DEBUG_DWARF2) -+ loc_directive_seen = FALSE; -+ } -+ else if (debug_type != DEBUG_DWARF2 || frchain_now->frch_nsect != text_nsect) -+ return; -+ else -+ dwarf2_where (&loc); -+ -+ dwarf2_gen_line_info (frag_now_fix () - size, &loc); -+ -+ current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK -+ | DWARF2_FLAG_PROLOGUE_END -+ | DWARF2_FLAG_EPILOGUE_BEGIN); -+} -+ -+/* Called for each (preferably code) label. If dwarf2_loc_mark_labels -+ is enabled, emit a basic block marker. */ -+ -+void -+dwarf2_emit_label (symbolS *label) -+{ -+ struct dwarf2_line_info loc; -+ -+ if (!dwarf2_loc_mark_labels) -+ return; -+#ifdef OLD -+ if (S_GET_SEGMENT (label) != now_seg) -+#else -+ if (label->sy_nlist.n_sect != now_seg) -+#endif -+ return; -+#ifdef OLD -+ if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE)) -+#else -+ if ((get_section_by_nsect(now_seg)->frch_section.flags & -+ S_ATTR_SOME_INSTRUCTIONS) == 0) -+#endif -+ return; -+ -+ if (debug_type == DEBUG_DWARF2) -+ dwarf2_where (&loc); -+ else -+ { -+ loc = current; -+ loc_directive_seen = FALSE; -+ } -+ -+ loc.flags |= DWARF2_FLAG_BASIC_BLOCK; -+ -+ current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK -+ | DWARF2_FLAG_PROLOGUE_END -+ | DWARF2_FLAG_EPILOGUE_BEGIN); -+ -+ dwarf2_gen_line_info_1 (label, &loc); -+} -+ -+#ifndef OLD -+/* -+ * Internal lbasename() routine that must be used in this code. As it returns -+ * a pointer into the path as get_filenum() expects for the base name of the -+ * path. -+ */ -+static -+char * -+lbasename( -+char *path) -+{ -+ char *p; -+ -+ p = strrchr(path, '/'); -+ if(p != NULL) -+ return(p + 1); -+ else -+ return(path); -+} -+#endif /* !defined(OLD) */ -+ -+/* Get a .debug_line file number for FILENAME. If NUM is nonzero, -+ allocate it on that file table slot, otherwise return the first -+ empty one. */ -+ -+static unsigned int -+get_filenum (char *filename, unsigned int num) -+{ -+ static unsigned int last_used, last_used_dir_len; -+ char *file; -+ size_t dir_len; -+ unsigned int i, dir; -+ -+ if (num == 0 && last_used) -+ { -+ if (! files[last_used].dir -+ && strcmp (filename, files[last_used].filename) == 0) -+ return last_used; -+ if (files[last_used].dir -+ && strncmp (filename, dirs[files[last_used].dir], -+ last_used_dir_len) == 0 -+ && IS_DIR_SEPARATOR (filename [last_used_dir_len]) -+ && strcmp (filename + last_used_dir_len + 1, -+ files[last_used].filename) == 0) -+ return last_used; -+ } -+ -+ file = lbasename (filename); -+ /* Don't make empty string from / or A: from A:/ . */ -+#ifdef HAVE_DOS_BASED_FILE_SYSTEM -+ if (file <= filename + 3) -+ file = filename; -+#else -+ if (file == filename + 1) -+ file = filename; -+#endif -+ dir_len = file - filename; -+ -+ dir = 0; -+ if (dir_len) -+ { -+ --dir_len; -+ for (dir = 1; dir < dirs_in_use; ++dir) -+ if (strncmp (filename, dirs[dir], dir_len) == 0 -+ && dirs[dir][dir_len] == '\0') -+ break; -+ -+ if (dir >= dirs_in_use) -+ { -+ if (dir >= dirs_allocated) -+ { -+ dirs_allocated = dir + 32; -+ dirs = (char **) -+ xrealloc (dirs, (dir + 32) * sizeof (const char *)); -+ } -+ -+ dirs[dir] = xmalloc (dir_len + 1); -+ memcpy (dirs[dir], filename, dir_len); -+ dirs[dir][dir_len] = '\0'; -+ dirs_in_use = dir + 1; -+ } -+ } -+ -+ if (num == 0) -+ { -+ for (i = 1; i < files_in_use; ++i) -+ if (files[i].dir == dir -+ && files[i].filename -+ && strcmp (file, files[i].filename) == 0) -+ { -+ last_used = i; -+ last_used_dir_len = dir_len; -+ return i; -+ } -+ } -+ else -+ i = num; -+ -+ if (i >= files_allocated) -+ { -+ unsigned int old = files_allocated; -+ -+ files_allocated = i + 32; -+ files = (struct file_entry *) -+ xrealloc (files, (i + 32) * sizeof (struct file_entry)); -+ -+ memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry)); -+ } -+ -+#ifdef OLD -+ files[i].filename = num ? file : xstrdup (file); -+#else -+ if(num == 0) -+ files[i].filename = file; -+ else -+ { -+ files[i].filename = xmalloc(strlen(file) + 1); -+ strcpy(files[i].filename, file); -+ } -+#endif -+ files[i].dir = dir; -+ if (files_in_use < i + 1) -+ files_in_use = i + 1; -+ last_used = i; -+ last_used_dir_len = dir_len; -+ -+ return i; -+} -+ -+/* Handle two forms of .file directive: -+ - Pass .file "source.c" to s_app_file -+ - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table -+ -+ If an entry is added to the file table, return a pointer to the filename. */ -+ -+char * -+dwarf2_directive_file (uintptr_t dummy ATTRIBUTE_UNUSED) -+{ -+ offsetT num; -+ char *filename; -+ int filename_len; -+ -+ /* Continue to accept a bare string and pass it off. */ -+ SKIP_WHITESPACE (); -+ if (*input_line_pointer == '"') -+ { -+ s_app_file (0); -+ return NULL; -+ } -+ -+ num = get_absolute_expression (); -+ filename = demand_copy_C_string (&filename_len); -+ if (filename == NULL) -+ return NULL; -+ demand_empty_rest_of_line (); -+ -+ /* -+ * If the --gdwarf2 flag is present to generate dwarf2 for assembly code -+ * then it is an error to see a .file directive in the source. -+ */ -+ if (debug_type == DEBUG_DWARF2) -+ { -+ as_bad (_("input can't have .file dwarf directives when -g is used to " -+ "generate dwarf debug info for assembly code")); -+ return NULL; -+ } -+ -+ if (num < 1) -+ { -+ as_bad (_("file number less than one")); -+ return NULL; -+ } -+ -+ if (num < (int) files_in_use && files[num].filename != 0) -+ { -+ as_bad (_("file number %ld already allocated"), (long) num); -+ return NULL; -+ } -+ -+ get_filenum (filename, num); -+ -+ return filename; -+} -+ -+/* -+ * Same functionality as above but this is used when generating dwarf debugging -+ * info for assembly files with --gdwarf2. -+ */ -+void -+dwarf2_file ( -+char *filename, -+offsetT num) -+{ -+ get_filenum (filename, num); -+} -+ -+void -+dwarf2_directive_loc (uintptr_t dummy ATTRIBUTE_UNUSED) -+{ -+ offsetT filenum, line; -+ -+ filenum = get_absolute_expression (); -+ SKIP_WHITESPACE (); -+ line = get_absolute_expression (); -+ -+ if (filenum < 1) -+ { -+ as_bad (_("file number less than one")); -+ return; -+ } -+ if (filenum >= (int) files_in_use || files[filenum].filename == 0) -+ { -+ as_bad (_("unassigned file number %ld"), (long) filenum); -+ return; -+ } -+ -+ current.filenum = filenum; -+ current.line = line; -+ -+#ifndef NO_LISTING -+ if (listing) -+ { -+ if (files[filenum].dir) -+ { -+ size_t dir_len = strlen (dirs[files[filenum].dir]); -+ size_t file_len = strlen (files[filenum].filename); -+ char *cp = (char *) alloca (dir_len + 1 + file_len + 1); -+ -+ memcpy (cp, dirs[files[filenum].dir], dir_len); -+ INSERT_DIR_SEPARATOR (cp, dir_len); -+ memcpy (cp + dir_len + 1, files[filenum].filename, file_len); -+ cp[dir_len + file_len + 1] = '\0'; -+ listing_source_file (cp); -+ } -+ else -+ listing_source_file (files[filenum].filename); -+ listing_source_line (line); -+ } -+#endif -+ -+ SKIP_WHITESPACE (); -+ if (ISDIGIT (*input_line_pointer)) -+ { -+ current.column = get_absolute_expression (); -+ SKIP_WHITESPACE (); -+ } -+ -+ while (ISALPHA (*input_line_pointer)) -+ { -+ char *p, c; -+ offsetT value; -+ -+ p = input_line_pointer; -+ c = get_symbol_end (); -+ -+ if (strcmp (p, "basic_block") == 0) -+ { -+ current.flags |= DWARF2_FLAG_BASIC_BLOCK; -+ *input_line_pointer = c; -+ } -+ else if (strcmp (p, "prologue_end") == 0) -+ { -+ current.flags |= DWARF2_FLAG_PROLOGUE_END; -+ *input_line_pointer = c; -+ } -+ else if (strcmp (p, "epilogue_begin") == 0) -+ { -+ current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN; -+ *input_line_pointer = c; -+ } -+ else if (strcmp (p, "is_stmt") == 0) -+ { -+ *input_line_pointer = c; -+ value = get_absolute_expression (); -+ if (value == 0) -+ current.flags &= ~DWARF2_FLAG_IS_STMT; -+ else if (value == 1) -+ current.flags |= DWARF2_FLAG_IS_STMT; -+ else -+ { -+ as_bad (_("is_stmt value not 0 or 1")); -+ return; -+ } -+ } -+ else if (strcmp (p, "isa") == 0) -+ { -+ *input_line_pointer = c; -+ value = get_absolute_expression (); -+ if (value >= 0) -+ current.isa = value; -+ else -+ { -+ as_bad (_("isa number less than zero")); -+ return; -+ } -+ } -+ else -+ { -+ as_bad (_("unknown .loc sub-directive `%s'"), p); -+ *input_line_pointer = c; -+ return; -+ } -+ -+ SKIP_WHITESPACE (); -+ } -+ -+ demand_empty_rest_of_line (); -+ loc_directive_seen = TRUE; -+} -+ -+/* -+ * Same functionality as above but this is used when generating dwarf debugging -+ * info for assembly files with --gdwarf2. -+ */ -+void -+dwarf2_loc (offsetT filenum, offsetT line) -+{ -+ current.filenum = filenum; -+ current.line = line; -+} -+ -+void -+dwarf2_directive_loc_mark_labels (uintptr_t dummy ATTRIBUTE_UNUSED) -+{ -+ offsetT value = get_absolute_expression (); -+ -+ if (value != 0 && value != 1) -+ { -+ as_bad (_("expected 0 or 1")); -+ ignore_rest_of_line (); -+ } -+ else -+ { -+ dwarf2_loc_mark_labels = value != 0; -+ demand_empty_rest_of_line (); -+ } -+} -+ -+static struct frag * -+first_frag_for_seg (segT seg) -+{ -+ return get_section_by_nsect(seg)->frch_root; -+} -+ -+static struct frag * -+last_frag_for_seg (segT seg) -+{ -+ frchainS *f = get_section_by_nsect(seg); -+ -+#ifdef OLD -+ while (f->frch_next != NULL) -+ f = f->frch_next; -+#endif -+ -+ return f->frch_last; -+} -+ -+/* Emit a single byte into the current segment. */ -+ -+static inline void -+out_byte (int byte) -+{ -+ FRAG_APPEND_1_CHAR (byte); -+} -+ -+/* Emit a statement program opcode into the current segment. */ -+ -+static inline void -+out_opcode (int opc) -+{ -+ out_byte (opc); -+} -+ -+/* Emit a two-byte word into the current segment. */ -+ -+static inline void -+out_two (int data) -+{ -+ md_number_to_chars (frag_more (2), data, 2); -+} -+ -+/* Emit a four byte word into the current segment. */ -+ -+static inline void -+out_four (int data) -+{ -+ md_number_to_chars (frag_more (4), data, 4); -+} -+ -+/* Emit an unsigned "little-endian base 128" number. */ -+ -+static void -+out_uleb128 (addressT value) -+{ -+ output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0); -+} -+ -+/* Emit a signed "little-endian base 128" number. */ -+ -+static void -+out_sleb128 (addressT value) -+{ -+ output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1); -+} -+ -+/* Emit a tuple for .debug_abbrev. */ -+ -+static inline void -+out_abbrev (int name, int form) -+{ -+ out_uleb128 (name); -+ out_uleb128 (form); -+} -+ -+/* Get the size of a fragment. */ -+ -+static offsetT -+get_frag_fix (fragS *frag, segT seg) -+{ -+#ifdef OLD -+#endif -+ frchainS *fr; -+ -+ if (frag->fr_next) -+ return frag->fr_fix; -+ -+ /* If a fragment is the last in the chain, special measures must be -+ taken to find its size before relaxation, since it may be pending -+ on some subsegment chain. */ -+ for (fr = get_section_by_nsect(seg); fr; fr = fr->frch_next) -+ if (fr->frch_last == frag) { -+#ifdef OLD -+ return (char *) obstack_next_free (&frags /* was &fr->frch_obstack */) - frag->fr_literal; -+ -+ abort (); -+#else -+ /* This depends on add_last_frags_to_sections() being called to make -+ sure the last frag in a section is a ".fill 0". Since in the Mach-O -+ assembler we don't have an obstack per section using the above -+ code to subtract the frag's fr_literal from what ever was the last -+ frag allocated will not work. */ -+ return(0); -+#endif -+ } -+ as_fatal("internal error, did not find frag in section in " -+ "get_frag_fix()"); -+ return(0); /* not reached, but here remove compiler warning */ -+} -+ -+/* Set an absolute address (may result in a relocation entry). */ -+ -+static void -+out_set_addr (symbolS *sym) -+{ -+ expressionS expr; -+ -+ out_opcode (DW_LNS_extended_op); -+ out_uleb128 (sizeof_address + 1); -+ -+ out_opcode (DW_LNE_set_address); -+ memset(&expr, '\0', sizeof(expr)); -+ expr.X_op = O_symbol; -+ expr.X_add_symbol = sym; -+ expr.X_add_number = 0; -+ emit_expr (&expr, sizeof_address); -+} -+ -+#if DWARF2_LINE_MIN_INSN_LENGTH > 1 -+static void scale_addr_delta (addressT *); -+ -+static void -+scale_addr_delta (addressT *addr_delta) -+{ -+ static int printed_this = 0; -+ if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0) -+ { -+ if (!printed_this) -+ as_bad("unaligned opcodes detected in executable segment"); -+ printed_this = 1; -+ } -+ *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH; -+} -+#else -+#define scale_addr_delta(A) -+#endif -+ -+/* Encode a pair of line and address skips as efficiently as possible. -+ Note that the line skip is signed, whereas the address skip is unsigned. -+ -+ The following two routines *must* be kept in sync. This is -+ enforced by making emit_inc_line_addr abort if we do not emit -+ exactly the expected number of bytes. */ -+ -+static int -+size_inc_line_addr (int line_delta, addressT addr_delta) -+{ -+ unsigned int tmp, opcode; -+ int len = 0; -+ -+ /* Scale the address delta by the minimum instruction length. */ -+ scale_addr_delta (&addr_delta); -+ -+ /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. -+ We cannot use special opcodes here, since we want the end_sequence -+ to emit the matrix entry. */ -+ if (line_delta == INT_MAX) -+ { -+ if (addr_delta == MAX_SPECIAL_ADDR_DELTA) -+ len = 1; -+ else -+ len = 1 + sizeof_leb128 (addr_delta, 0); -+ return len + 3; -+ } -+ -+ /* Bias the line delta by the base. */ -+ tmp = line_delta - DWARF2_LINE_BASE; -+ -+ /* If the line increment is out of range of a special opcode, we -+ must encode it with DW_LNS_advance_line. */ -+ if (tmp >= DWARF2_LINE_RANGE) -+ { -+ len = 1 + sizeof_leb128 (line_delta, 1); -+ line_delta = 0; -+ tmp = 0 - DWARF2_LINE_BASE; -+ } -+ -+ /* Bias the opcode by the special opcode base. */ -+ tmp += DWARF2_LINE_OPCODE_BASE; -+ -+ /* Avoid overflow when addr_delta is large. */ -+ if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA) -+ { -+ /* Try using a special opcode. */ -+ opcode = tmp + addr_delta * DWARF2_LINE_RANGE; -+ if (opcode <= 255) -+ return len + 1; -+ -+ /* Try using DW_LNS_const_add_pc followed by special op. */ -+ opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE; -+ if (opcode <= 255) -+ return len + 2; -+ } -+ -+ /* Otherwise use DW_LNS_advance_pc. */ -+ len += 1 + sizeof_leb128 (addr_delta, 0); -+ -+ /* DW_LNS_copy or special opcode. */ -+ len += 1; -+ -+ return len; -+} -+ -+static void -+emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len) -+{ -+ unsigned int tmp, opcode; -+ int need_copy = 0; -+ char *end = p + len; -+ -+ /* Line number sequences cannot go backward in addresses. This means -+ we've incorrectly ordered the statements in the sequence. */ -+ assert ((offsetT) addr_delta >= 0); -+ -+ /* Scale the address delta by the minimum instruction length. */ -+ scale_addr_delta (&addr_delta); -+ -+ /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. -+ We cannot use special opcodes here, since we want the end_sequence -+ to emit the matrix entry. */ -+ if (line_delta == INT_MAX) -+ { -+ if (addr_delta == MAX_SPECIAL_ADDR_DELTA) -+ *p++ = DW_LNS_const_add_pc; -+ else -+ { -+ *p++ = DW_LNS_advance_pc; -+ p += output_leb128 (p, addr_delta, 0); -+ } -+ -+ *p++ = DW_LNS_extended_op; -+ *p++ = 1; -+ *p++ = DW_LNE_end_sequence; -+ goto done; -+ } -+ -+ /* Bias the line delta by the base. */ -+ tmp = line_delta - DWARF2_LINE_BASE; -+ -+ /* If the line increment is out of range of a special opcode, we -+ must encode it with DW_LNS_advance_line. */ -+ if (tmp >= DWARF2_LINE_RANGE) -+ { -+ *p++ = DW_LNS_advance_line; -+ p += output_leb128 (p, line_delta, 1); -+ -+ line_delta = 0; -+ tmp = 0 - DWARF2_LINE_BASE; -+ need_copy = 1; -+ } -+ -+ /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0" -+ special opcode. */ -+ if (line_delta == 0 && addr_delta == 0) -+ { -+ *p++ = DW_LNS_copy; -+ goto done; -+ } -+ -+ /* Bias the opcode by the special opcode base. */ -+ tmp += DWARF2_LINE_OPCODE_BASE; -+ -+ /* Avoid overflow when addr_delta is large. */ -+ if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA) -+ { -+ /* Try using a special opcode. */ -+ opcode = tmp + addr_delta * DWARF2_LINE_RANGE; -+ if (opcode <= 255) -+ { -+ *p++ = opcode; -+ goto done; -+ } -+ -+ /* Try using DW_LNS_const_add_pc followed by special op. */ -+ opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE; -+ if (opcode <= 255) -+ { -+ *p++ = DW_LNS_const_add_pc; -+ *p++ = opcode; -+ goto done; -+ } -+ } -+ -+ /* Otherwise use DW_LNS_advance_pc. */ -+ *p++ = DW_LNS_advance_pc; -+ p += output_leb128 (p, addr_delta, 0); -+ -+ if (need_copy) -+ *p++ = DW_LNS_copy; -+ else -+ *p++ = tmp; -+ -+ done: -+ if (p != end) -+ as_fatal("internal error, p != end at the end of emit_inc_line_addr()"); -+} -+ -+/* Handy routine to combine calls to the above two routines. */ -+ -+static void -+out_inc_line_addr (int line_delta, addressT addr_delta) -+{ -+ int len = size_inc_line_addr (line_delta, addr_delta); -+ emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len); -+} -+ -+/* Write out an alternative form of line and address skips using -+ DW_LNS_fixed_advance_pc opcodes. This uses more space than the default -+ line and address information, but it helps support linker relaxation that -+ changes the code offsets. */ -+ -+static void -+out_fixed_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym) -+{ -+ expressionS expr; -+ -+ /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */ -+ if (line_delta == INT_MAX) -+ { -+ out_opcode (DW_LNS_fixed_advance_pc); -+ memset(&expr, '\0', sizeof(expr)); -+#ifdef OLD -+ expr.X_op = O_subtract; -+#else -+ expr.X_seg = SEG_DIFFSECT; -+#endif -+ expr.X_add_symbol = to_sym; -+#ifdef OLD -+ expr.X_op_symbol = from_sym; -+#else -+ expr.X_subtract_symbol = from_sym; -+#endif -+ expr.X_add_number = 0; -+ emit_expr (&expr, 2); -+ -+ out_opcode (DW_LNS_extended_op); -+ out_byte (1); -+ out_opcode (DW_LNE_end_sequence); -+ return; -+ } -+ -+ out_opcode (DW_LNS_advance_line); -+ out_sleb128 (line_delta); -+ -+ out_opcode (DW_LNS_fixed_advance_pc); -+ memset(&expr, '\0', sizeof(expr)); -+#ifdef OLD -+ expr.X_op = O_subtract; -+#else -+ expr.X_seg = SEG_DIFFSECT; -+#endif -+ expr.X_add_symbol = to_sym; -+#ifdef OLD -+ expr.X_op_symbol = from_sym; -+#else -+ expr.X_subtract_symbol = from_sym; -+#endif -+ expr.X_add_number = 0; -+ emit_expr (&expr, 2); -+ -+ out_opcode (DW_LNS_copy); -+} -+ -+/* Generate a variant frag that we can use to relax address/line -+ increments between fragments of the target segment. */ -+ -+static void -+relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym) -+{ -+ int max_chars; -+#ifdef OLD -+ expressionS expr; -+#else -+ symbolS *sym; -+ expressionS *expression; -+ -+ sym = symbol_temp_new(to_sym->sy_other, 0, NULL); -+ expression = xmalloc(sizeof(expressionS)); -+ memset(expression, '\0', sizeof(expressionS)); -+ sym->expression = expression; -+ sym->sy_frag = &zero_address_frag; -+#endif -+ -+#ifdef OLD -+ expr.X_op = O_subtract; -+ expr.X_add_symbol = to_sym; -+ expr.X_op_symbol = from_sym; -+ expr.X_add_number = 0; -+#else -+ expression->X_seg = SEG_DIFFSECT; -+ expression->X_add_symbol = to_sym; -+ expression->X_subtract_symbol = from_sym; -+ expression->X_add_number = 0; -+#endif -+ -+ /* The maximum size of the frag is the line delta with a maximum -+ sized address delta. */ -+ max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH); -+ -+#ifdef OLD -+ frag_var (rs_dwarf2dbg, max_chars, max_chars, 1, -+ make_expr_symbol (&expr), line_delta, NULL); -+#else -+ frag_var (rs_dwarf2dbg, max_chars, max_chars, 1, -+ sym, line_delta, NULL); -+#endif -+} -+ -+ -+/* The function estimates the size of a rs_dwarf2dbg variant frag -+ based on the current values of the symbols. It is called before -+ the relaxation loop. We set fr_subtype to the expected length. */ -+ -+int -+dwarf2dbg_estimate_size_before_relax (fragS *frag) -+{ -+ offsetT addr_delta; -+ int size; -+#ifndef OLD -+ expressionS *expression; -+#endif -+ -+#ifdef OLD -+ addr_delta = resolve_symbol_value (frag->fr_symbol); -+#else -+ if(frag->fr_symbol == NULL || frag->fr_symbol->expression == NULL) -+ as_bad("Internal error dwarf2dbg_estimate_size_before_relax() called with " -+ "frag without symbol or expression\n"); -+ -+ expression = (expressionS *)frag->fr_symbol->expression; -+ if(expression->X_seg != SEG_DIFFSECT || -+ expression->X_add_symbol == NULL || -+ expression->X_subtract_symbol == NULL) -+ as_bad("Internal error dwarf2dbg_estimate_size_before_relax() called with " -+ "frag symbol with bad expression\n"); -+ -+ addr_delta = (expression->X_add_symbol->sy_nlist.n_value + -+ expression->X_add_symbol->sy_frag->fr_address) -+ - (expression->X_subtract_symbol->sy_nlist.n_value + -+ expression->X_subtract_symbol->sy_frag->fr_address) -+ + expression->X_add_number; -+#endif -+ -+ size = size_inc_line_addr (frag->fr_offset, addr_delta); -+ -+ frag->fr_subtype = size; -+ -+ return size; -+} -+ -+/* This function relaxes a rs_dwarf2dbg variant frag based on the -+ current values of the symbols. fr_subtype is the current length -+ of the frag. This returns the change in frag length. */ -+ -+int -+dwarf2dbg_relax_frag (fragS *frag) -+{ -+ int old_size, new_size; -+ -+ old_size = frag->fr_subtype; -+ new_size = dwarf2dbg_estimate_size_before_relax (frag); -+ -+ return new_size - old_size; -+} -+ -+/* This function converts a rs_dwarf2dbg variant frag into a normal -+ fill frag. This is called after all relaxation has been done. -+ fr_subtype will be the desired length of the frag. */ -+ -+void -+dwarf2dbg_convert_frag (fragS *frag) -+{ -+ offsetT addr_diff; -+#ifndef OLD -+ expressionS *expression; -+#endif -+ -+#ifdef OLD -+ addr_diff = resolve_symbol_value (frag->fr_symbol); -+#else -+ if(frag->fr_symbol == NULL || frag->fr_symbol->expression == NULL) -+ as_bad("Internal error dwarf2dbg_convert_frag() called with " -+ "frag without symbol or expression\n"); -+ -+ expression = (expressionS *)frag->fr_symbol->expression; -+ if(expression->X_seg != SEG_DIFFSECT || -+ expression->X_add_symbol == NULL || -+ expression->X_subtract_symbol == NULL) -+ as_bad("Internal error dwarf2dbg_convert_frag() called with " -+ "frag symbol with bad expression\n"); -+ -+ addr_diff = expression->X_add_symbol->sy_nlist.n_value -+ - expression->X_subtract_symbol->sy_nlist.n_value -+ + expression->X_add_number; -+#endif -+ -+ /* fr_var carries the max_chars that we created the fragment with. -+ fr_subtype carries the current expected length. We must, of -+ course, have allocated enough memory earlier. */ -+ assert (frag->fr_var >= (int) frag->fr_subtype); -+ -+ emit_inc_line_addr (frag->fr_offset, addr_diff, -+ frag->fr_literal + frag->fr_fix, frag->fr_subtype); -+ -+ frag->fr_fix += frag->fr_subtype; -+ frag->fr_type = rs_fill; -+ frag->fr_var = 0; -+ frag->fr_offset = 0; -+} -+ -+/* Generate .debug_line content for the chain of line number entries -+ beginning at E, for segment SEG. */ -+ -+static int -+process_entries (segT seg, struct line_entry *e) -+{ -+ unsigned filenum = 1; -+ unsigned line = 1; -+ unsigned column = 0; -+ unsigned isa = 0; -+ unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0; -+ fragS *last_frag = NULL, *frag; -+ addressT last_frag_ofs = 0, frag_ofs; -+ symbolS *last_lab = NULL, *lab; -+ struct line_entry *next; -+ int output_something = 0; -+ -+ do -+ { -+ int line_delta; -+ -+ if (filenum != e->loc.filenum) -+ { -+ filenum = e->loc.filenum; -+ out_opcode (DW_LNS_set_file); -+ out_uleb128 (filenum); -+ } -+ -+ if (column != e->loc.column) -+ { -+ column = e->loc.column; -+ out_opcode (DW_LNS_set_column); -+ out_uleb128 (column); -+ } -+ -+ if (isa != e->loc.isa) -+ { -+ isa = e->loc.isa; -+ out_opcode (DW_LNS_set_isa); -+ out_uleb128 (isa); -+ } -+ -+ if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT) -+ { -+ flags = e->loc.flags; -+ out_opcode (DW_LNS_negate_stmt); -+ } -+ -+ if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK) -+ out_opcode (DW_LNS_set_basic_block); -+ -+ if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END) -+ out_opcode (DW_LNS_set_prologue_end); -+ -+ if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN) -+ out_opcode (DW_LNS_set_epilogue_begin); -+ -+ /* Don't try to optimize away redundant entries; gdb wants two -+ entries for a function where the code starts on the same line as -+ the open curly brace, and there's no way to identify that case here. -+ Trust gcc to optimize appropriately. */ -+ line_delta = e->loc.line - line; -+ lab = e->label; -+ frag = symbol_get_frag (lab); -+#ifdef OLD -+ frag_ofs = S_GET_VALUE (lab); -+#else -+ frag_ofs = lab->sy_nlist.n_value + frag->fr_address + frag->fr_offset; -+#endif -+ -+ if (last_frag == NULL) -+ { -+ out_set_addr (lab); -+ out_inc_line_addr (line_delta, 0); -+ } -+ else if (DWARF2_USE_FIXED_ADVANCE_PC) -+ out_fixed_inc_line_addr (line_delta, lab, last_lab); -+ else if (frag == last_frag) -+ out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs); -+ else -+ relax_inc_line_addr (line_delta, lab, last_lab); -+ -+ line = e->loc.line; -+ last_lab = lab; -+ last_frag = frag; -+ last_frag_ofs = frag_ofs; -+ -+ next = e->next; -+ free (e); -+ e = next; -+ output_something = 1; -+ } -+ while (e); -+ -+ /* Emit a DW_LNE_end_sequence for the end of the section. */ -+ frag = last_frag_for_seg (seg); -+ frag_ofs = get_frag_fix (frag, seg); -+ if (DWARF2_USE_FIXED_ADVANCE_PC) -+ { -+ lab = symbol_temp_new (seg, frag_ofs, frag); -+ out_fixed_inc_line_addr (INT_MAX, lab, last_lab); -+ } -+ else if (frag == last_frag) -+ out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs); -+ else -+ { -+ lab = symbol_temp_new (seg, frag_ofs, frag); -+ relax_inc_line_addr (INT_MAX, lab, last_lab); -+ } -+ -+ return (output_something); -+} -+ -+/* Emit the directory and file tables for .debug_line. */ -+ -+static void -+out_file_list (void) -+{ -+ size_t size; -+ char *cp; -+ unsigned int i; -+ -+ /* Emit directory list. */ -+ for (i = 1; i < dirs_in_use; ++i) -+ { -+ size = strlen (dirs[i]) + 1; -+ cp = frag_more (size); -+ memcpy (cp, dirs[i], size); -+ } -+ /* Terminate it. */ -+ out_byte ('\0'); -+ -+ for (i = 1; i < files_in_use; ++i) -+ { -+ if (files[i].filename == NULL) -+ { -+ as_bad (_("unassigned file number %ld"), (long) i); -+ /* Prevent a crash later, particularly for file 1. */ -+ files[i].filename = ""; -+ continue; -+ } -+ -+ size = strlen (files[i].filename) + 1; -+ cp = frag_more (size); -+ memcpy (cp, files[i].filename, size); -+ -+ out_uleb128 (files[i].dir); /* directory number */ -+ out_uleb128 (0); /* last modification timestamp */ -+ out_uleb128 (0); /* filesize */ -+ } -+ -+ /* Terminate filename list. */ -+ out_byte (0); -+} -+ -+/* Emit the collected .debug_line data. */ -+ -+static void -+out_debug_line( -+struct frchain *line_section) -+{ -+ expressionS expr; -+ symbolS *line_start; -+ symbolS *prologue_end; -+ symbolS *line_end; -+ struct line_seg *s; -+ enum dwarf2_format d2f; -+ int sizeof_offset, output_something; -+ -+ section_set(line_section); -+ -+ line_start = symbol_temp_new_now (); -+ prologue_end = symbol_temp_make (); -+ line_end = symbol_temp_make (); -+ -+ /* Total length of the information for this compilation unit. */ -+ memset(&expr, '\0', sizeof(expr)); -+#ifdef OLD -+ expr.X_op = O_subtract; -+#else -+ expr.X_seg = SEG_DIFFSECT; -+#endif -+ expr.X_add_symbol = line_end; -+#ifdef OLD -+ expr.X_op_symbol = line_start; -+#else -+ expr.X_subtract_symbol = line_start; -+#endif -+ -+ d2f = DWARF2_FORMAT (); -+ if (d2f == dwarf2_format_32bit) -+ { -+ expr.X_add_number = -4; -+ emit_expr (&expr, 4); -+ sizeof_offset = 4; -+ } -+ else if (d2f == dwarf2_format_64bit) -+ { -+ expr.X_add_number = -12; -+ out_four (-1); -+ emit_expr (&expr, 8); -+ sizeof_offset = 8; -+ } -+ else if (d2f == dwarf2_format_64bit_irix) -+ { -+ expr.X_add_number = -8; -+ emit_expr (&expr, 8); -+ sizeof_offset = 8; -+ } -+ else -+ { -+ as_fatal (_("internal error: unknown dwarf2 format")); -+ } -+ -+ /* Version. */ -+ out_two (2); -+ -+ memset(&expr, '\0', sizeof(expr)); -+ /* Length of the prologue following this length. */ -+#ifdef OLD -+ expr.X_op = O_subtract; -+#else -+ expr.X_seg = SEG_DIFFSECT; -+#endif -+ expr.X_add_symbol = prologue_end; -+#ifdef OLD -+ expr.X_op_symbol = line_start; -+#else -+ expr.X_subtract_symbol = line_start; -+#endif -+ expr.X_add_number = - (4 + 2 + 4); -+ emit_expr (&expr, sizeof_offset); -+ -+ /* Parameters of the state machine. */ -+ out_byte (DWARF2_LINE_MIN_INSN_LENGTH); -+ out_byte (DWARF2_LINE_DEFAULT_IS_STMT); -+ out_byte (DWARF2_LINE_BASE); -+ out_byte (DWARF2_LINE_RANGE); -+ out_byte (DWARF2_LINE_OPCODE_BASE); -+ -+ /* Standard opcode lengths. */ -+ out_byte (0); /* DW_LNS_copy */ -+ out_byte (1); /* DW_LNS_advance_pc */ -+ out_byte (1); /* DW_LNS_advance_line */ -+ out_byte (1); /* DW_LNS_set_file */ -+ out_byte (1); /* DW_LNS_set_column */ -+ out_byte (0); /* DW_LNS_negate_stmt */ -+ out_byte (0); /* DW_LNS_set_basic_block */ -+ out_byte (0); /* DW_LNS_const_add_pc */ -+ out_byte (1); /* DW_LNS_fixed_advance_pc */ -+ out_byte (0); /* DW_LNS_set_prologue_end */ -+ out_byte (0); /* DW_LNS_set_epilogue_begin */ -+ out_byte (1); /* DW_LNS_set_isa */ -+ -+ out_file_list (); -+ -+ symbol_set_value_now (prologue_end); -+ -+ /* For each section, emit a statement program. */ -+ output_something = 0; -+ for (s = all_segs; s; s = s->next) -+ output_something += process_entries (s->seg, s->head->head); -+ -+ /* -+ * If we have not output anything the tools on Mac OS X need to have a -+ * DW_LNE_set_address sequence to set the address to zero and a -+ * DW_LNE_end_sequence which consists of 3 bytes '00 01 01' -+ * (00 is the code for extended opcodes, followed by a ULEB128 length of the -+ * extended opcode (01), and the DW_LNE_end_sequence (01). -+ */ -+ if (output_something == 0) -+ { -+ /* -+ * This is the DW_LNE_set_address sequence to set the address to zero. -+ */ -+#ifdef ARCH64 -+ out_byte(0); -+ out_byte(9); -+ out_byte(2); -+ out_byte(0); -+ out_byte(0); -+ out_byte(0); -+ out_byte(0); -+ out_byte(0); -+ out_byte(0); -+ out_byte(0); -+ out_byte(0); -+#else -+ out_byte(0); -+ out_byte(5); -+ out_byte(2); -+ out_byte(0); -+ out_byte(0); -+ out_byte(0); -+ out_byte(0); -+#endif -+ out_byte(DW_LNS_extended_op); -+ out_byte(1); -+ out_byte(DW_LNE_end_sequence); -+ } -+ symbol_set_value_now (line_end); -+} -+ -+static void -+out_debug_ranges( -+struct frchain *ranges_section) -+{ -+ unsigned int addr_size = sizeof_address; -+ struct line_seg *s; -+ expressionS expr; -+ unsigned int i; -+ -+ section_set(ranges_section); -+ -+ /* Base Address Entry. */ -+ for (i = 0; i < addr_size; i++) -+ out_byte (0xff); -+ for (i = 0; i < addr_size; i++) -+ out_byte (0); -+ -+ /* Range List Entry. */ -+ for (s = all_segs; s; s = s->next) -+ { -+ fragS *frag; -+ symbolS *beg, *end; -+ -+ frag = first_frag_for_seg (s->seg); -+ beg = symbol_temp_new (s->seg, 0, frag); -+ s->text_start = beg; -+ -+ frag = last_frag_for_seg (s->seg); -+ end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag); -+ s->text_end = end; -+ -+ memset(&expr, '\0', sizeof(expr)); -+ expr.X_op = O_symbol; -+ expr.X_add_symbol = beg; -+ expr.X_add_number = 0; -+ emit_expr (&expr, addr_size); -+ -+ memset(&expr, '\0', sizeof(expr)); -+ expr.X_op = O_symbol; -+ expr.X_add_symbol = end; -+ expr.X_add_number = 0; -+ emit_expr (&expr, addr_size); -+ } -+ -+ /* End of Range Entry. */ -+ for (i = 0; i < addr_size; i++) -+ out_byte (0); -+ for (i = 0; i < addr_size; i++) -+ out_byte (0); -+} -+ -+/* When generating debug info directly for assembly files, this routine is -+ called to emit data for .debug_aranges and or set the text_end field which -+ is used by out_debug_info() in the compile_unit. */ -+ -+static -+void -+out_debug_aranges( -+struct frchain *aranges_section, -+struct frchain *info_section) -+{ -+ unsigned int addr_size = sizeof_address; -+ addressT size, skip; -+ struct line_seg *s; -+ expressionS expr; -+ char *p; -+ -+ size = 4 + 2 + 4 + 1 + 1; -+ -+ skip = 2 * addr_size - (size & (2 * addr_size - 1)); -+ if (skip == 2 * addr_size) -+ skip = 0; -+ size += skip; -+ -+ for (s = all_segs; s; s = s->next) -+ size += 2 * addr_size; -+ -+ size += 2 * addr_size; -+ -+ section_set(aranges_section); -+ -+ /* Length of the compilation unit. */ -+ out_four (size - 4); -+ -+ /* Version. */ -+ out_two (2); -+ -+ /* Offset to .debug_info. */ -+ /* ??? sizeof_offset */ -+ TC_DWARF2_EMIT_OFFSET (section_symbol (info_section), 4); -+ -+ /* Size of an address (offset portion). */ -+ out_byte (addr_size); -+ -+ /* Size of a segment descriptor. */ -+ out_byte (0); -+ -+ /* Align the header. */ -+ if (skip) -+ { -+ char fill; -+ -+ fill = '\0'; -+ frag_align (ffs (2 * addr_size) - 1, &fill, 1, 0); -+ } -+ -+ for (s = all_segs; s; s = s->next) -+ { -+ fragS *frag; -+ symbolS *beg, *end; -+ -+ frag = first_frag_for_seg (s->seg); -+ beg = symbol_temp_new (s->seg, 0, frag); -+ s->text_start = beg; -+ -+ frag = last_frag_for_seg (s->seg); -+ end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag); -+ s->text_end = end; -+ -+ memset(&expr, '\0', sizeof(expr)); -+ expr.X_op = O_symbol; -+ expr.X_add_symbol = beg; -+ expr.X_add_number = 0; -+ emit_expr (&expr, addr_size); -+ -+ memset(&expr, '\0', sizeof(expr)); -+#ifdef OLD -+ expr.X_op = O_subtract; -+#else -+ expr.X_seg = SEG_DIFFSECT; -+#endif -+ expr.X_add_symbol = end; -+#ifdef OLD -+ expr.X_op_symbol = beg; -+#else -+ expr.X_subtract_symbol = beg; -+#endif -+ expr.X_add_number = 0; -+ emit_expr (&expr, addr_size); -+ } -+ p = frag_more (2 * addr_size); -+ md_number_to_chars (p, 0, addr_size); -+ md_number_to_chars (p + addr_size, 0, addr_size); -+} -+ -+/* When generating debug info directly for assembly files, this routine is -+ called to output the data for .debug_abbrev. Note that this must be kept in -+ sync with out_debug_info below. */ -+ -+static -+void -+out_debug_abbrev( -+struct frchain * abbrev_section) -+{ -+ section_set(abbrev_section); -+ -+ /* DW_TAG_compile_unit DIE abbrev (1) */ -+ out_uleb128 (1); -+ out_uleb128 (DW_TAG_compile_unit); -+ out_byte (DW_CHILDREN_yes); -+ out_abbrev (DW_AT_stmt_list, DW_FORM_data4); -+ if (all_segs->next == NULL) -+ { -+ out_abbrev (DW_AT_low_pc, DW_FORM_addr); -+ out_abbrev (DW_AT_high_pc, DW_FORM_addr); -+ } -+ else -+ { -+ if (DWARF2_FORMAT () == dwarf2_format_32bit) -+ out_abbrev (DW_AT_ranges, DW_FORM_data4); -+ else -+ out_abbrev (DW_AT_ranges, DW_FORM_data8); -+ } -+ out_abbrev (DW_AT_name, DW_FORM_string); -+ out_abbrev (DW_AT_comp_dir, DW_FORM_string); -+ if(apple_flags != NULL) -+ out_abbrev (DW_AT_APPLE_flags, DW_FORM_string); -+ out_abbrev (DW_AT_producer, DW_FORM_string); -+ out_abbrev (DW_AT_language, DW_FORM_data2); -+ out_abbrev (0, 0); -+ -+ /* DW_TAG_subprogram DIE abbrev (2) */ -+ out_uleb128 (2); -+ out_uleb128 (DW_TAG_subprogram); -+ out_byte (DW_CHILDREN_yes); -+ out_abbrev (DW_AT_name, DW_FORM_string); -+ out_abbrev (DW_AT_decl_file, DW_FORM_data4); -+ out_abbrev (DW_AT_decl_line, DW_FORM_data4); -+ out_abbrev (DW_AT_low_pc, DW_FORM_addr); -+ out_abbrev (DW_AT_high_pc, DW_FORM_addr); -+ out_abbrev (DW_AT_prototyped, DW_FORM_flag); -+ out_abbrev (0, 0); -+ -+ /* DW_TAG_unspecified_parameters DIE abbrev (3) */ -+ out_uleb128 (3); -+ out_uleb128 (DW_TAG_unspecified_parameters); -+ out_byte (DW_CHILDREN_no); -+ out_abbrev (0, 0); -+ -+ /* Terminate the abbreviations for this compilation unit. */ -+ out_byte (0); -+} -+ -+/* When generating debug info directly for assembly files, this routine is -+ called to output the compilation unit and subprograms for .debug_info . */ -+ -+static -+void -+out_debug_info( -+struct frchain *info_section, -+struct frchain *abbrev_section, -+struct frchain *line_section, -+struct frchain *ranges_section) -+{ -+ char producer[128]; -+ char *comp_dir; -+ expressionS expr; -+ symbolS *info_start; -+ symbolS *info_end; -+ char *p; -+ int len; -+ enum dwarf2_format d2f; -+ int sizeof_offset; -+ struct dwarf2_subprogram_info *subs; -+ symbolS *prev_subs_symbol; -+ -+ sizeof_offset = 0; -+ section_set(info_section); -+ -+ info_start = symbol_temp_new_now (); -+ info_end = symbol_temp_make (); -+ -+ /* Compilation Unit length. */ -+ memset(&expr, '\0', sizeof(expr)); -+#ifdef OLD -+ expr.X_op = O_subtract; -+#else -+ expr.X_seg = SEG_DIFFSECT; -+#endif -+ expr.X_add_symbol = info_end; -+#ifdef OLD -+ expr.X_op_symbol = info_start; -+#else -+ expr.X_subtract_symbol = info_start; -+#endif -+ -+ d2f = DWARF2_FORMAT (); -+ if (d2f == dwarf2_format_32bit) -+ { -+ expr.X_add_number = -4; -+ emit_expr (&expr, 4); -+ sizeof_offset = 4; -+ } -+ else if (d2f == dwarf2_format_64bit) -+ { -+ expr.X_add_number = -12; -+ out_four (-1); -+ emit_expr (&expr, 8); -+ sizeof_offset = 8; -+ } -+ else if (d2f == dwarf2_format_64bit_irix) -+ { -+ expr.X_add_number = -8; -+ emit_expr (&expr, 8); -+ sizeof_offset = 8; -+ } -+ else -+ { -+ as_fatal (_("internal error: unknown dwarf2 format")); -+ } -+ -+ /* DWARF version. */ -+ out_two (2); -+ -+ /* .debug_abbrev offset */ -+ TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_section), sizeof_offset); -+ -+ /* Target address size. */ -+ out_byte (sizeof_address); -+ -+ /* DW_TAG_compile_unit DIE abbrev */ -+ out_uleb128 (1); -+ -+ /* DW_AT_stmt_list */ -+ /* ??? sizeof_offset */ -+ TC_DWARF2_EMIT_OFFSET (section_symbol (line_section), 4); -+ -+ /* These two attributes are emitted if all of the code is contiguous. */ -+ if (all_segs->next == NULL) -+ { -+ /* DW_AT_low_pc */ -+ memset(&expr, '\0', sizeof(expr)); -+ expr.X_op = O_symbol; -+ expr.X_add_symbol = all_segs->text_start; -+ expr.X_add_number = 0; -+ emit_expr (&expr, sizeof_address); -+ -+ /* DW_AT_high_pc */ -+ memset(&expr, '\0', sizeof(expr)); -+ expr.X_op = O_symbol; -+ expr.X_add_symbol = all_segs->text_end; -+ expr.X_add_number = 0; -+ emit_expr (&expr, sizeof_address); -+ } -+ else -+ { -+ /* This attribute is emitted if the code is disjoint. */ -+ /* DW_AT_ranges. */ -+ TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_section), sizeof_offset); -+ } -+ -+ /* DW_AT_name. We don't have the actual file name that was present -+ on the command line, so assume files[1] is the main input file. -+ We're not supposed to get called unless at least one line number -+ entry was emitted, so this should always be defined. */ -+ if (!files || files_in_use < 1) -+ abort (); -+ if (files[1].dir) -+ { -+ len = strlen (dirs[files[1].dir]); -+ p = frag_more (len + 1); -+ memcpy (p, dirs[files[1].dir], len); -+ INSERT_DIR_SEPARATOR (p, len); -+ } -+ len = strlen (files[1].filename) + 1; -+ p = frag_more (len); -+ memcpy (p, files[1].filename, len); -+ -+ /* DW_AT_comp_dir */ -+#ifdef OLD -+ comp_dir = getpwd (); -+#else -+ comp_dir = getwd(xmalloc(MAXPATHLEN + 1)); -+#endif -+ len = strlen (comp_dir) + 1; -+ p = frag_more (len); -+ memcpy (p, comp_dir, len); -+ -+ if(apple_flags != NULL){ -+ /* DW_AT_APPLE_flags */ -+ len = strlen (apple_flags) + 1; -+ p = frag_more (len); -+ memcpy (p, apple_flags, len); -+ } -+ -+ /* DW_AT_producer */ -+ sprintf (producer, "%s %s, %s", APPLE_INC_VERSION, apple_version, -+ version_string); -+ len = strlen (producer) + 1; -+ p = frag_more (len); -+ memcpy (p, producer, len); -+ -+ /* DW_AT_language. Yes, this is probably not really MIPS, but the -+ dwarf2 draft has no standard code for assembler. */ -+ out_two (DW_LANG_Mips_Assembler); -+ -+ prev_subs_symbol = NULL; -+ for(subs = dwarf2_subprograms_info; subs != NULL; subs = subs->next){ -+ uint32_t n_sect; -+ fragS *frag; -+ symbolS *end; -+ struct dwarf2_subprogram_info *subs_next; -+ -+ /* Don't emit zero length TAG_subprogram dwarf debug info. */ -+ if(prev_subs_symbol != NULL && -+ prev_subs_symbol->sy_frag == subs->symbol->sy_frag && -+ prev_subs_symbol->sy_value == subs->symbol->sy_value) -+ { -+ continue; -+ } -+ else -+ { -+ prev_subs_symbol = subs->symbol; -+ } -+ -+ /* DW_TAG_subprogram DIE abbrev */ -+ out_uleb128 (2); -+ -+ /* DW_AT_name */ -+ len = strlen (subs->name) + 1; -+ p = frag_more (len); -+ memcpy (p, subs->name, len); -+ -+ /* DW_AT_decl_file */ -+ out_four (subs->file_number); -+ -+ /* DW_AT_decl_line */ -+ out_four (subs->line_number); -+ -+ /* DW_AT_low_pc */ -+ memset(&expr, '\0', sizeof(expr)); -+ expr.X_op = O_symbol; -+ expr.X_add_symbol = subs->symbol; -+ expr.X_add_number = 0; -+ emit_expr (&expr, sizeof_address); -+ -+ /* DW_AT_high_pc */ -+ end = NULL; -+ if(subs->next != NULL) -+ { -+ end = subs->next->symbol; -+ subs_next = subs->next; -+ while(subs->symbol->sy_frag == end->sy_frag && -+ subs->symbol->sy_value == end->sy_value) -+ { -+ if(subs_next->next == NULL) -+ { -+ end = NULL; -+ break; -+ } -+ else -+ { -+ subs_next = subs_next->next; -+ end = subs_next->symbol; -+ } -+ } -+ } -+ if(end == NULL) -+ { -+ n_sect = subs->symbol->sy_nlist.n_sect; -+ frag = last_frag_for_seg (n_sect); -+ end = symbol_temp_new (n_sect, get_frag_fix (frag, n_sect), frag); -+ } -+ memset(&expr, '\0', sizeof(expr)); -+ expr.X_op = O_symbol; -+ expr.X_add_symbol = end; -+ expr.X_add_number = 0; -+ emit_expr (&expr, sizeof_address); -+ -+ /* DW_AT_prototyped */ -+ out_byte (0); -+ -+ /* DW_TAG_unspecified_parameters DIE abbrev */ -+ out_uleb128 (3); -+ /* Add the NULL DIE terminating the DW_TAG_unspecified_parameters DIE's. */ -+ out_byte (0); -+ } -+ -+ /* Add the NULL DIE terminating the Compile Unit DIE's. */ -+ out_byte (0); -+ -+ symbol_set_value_now (info_end); -+} -+ -+/* Finish the dwarf2 debug sections. We emit .debug.line if there -+ were any .file/.loc directives, or --gdwarf2 was given, or if the -+ file has a non-empty .debug_info section. If we emit .debug_line, -+ and the .debug_info section is empty, we also emit .debug_info, -+ .debug_aranges and .debug_abbrev. ALL_SEGS will be non-null if -+ there were any .file/.loc directives, or --gdwarf2 was given and -+ there were any located instructions emitted. */ -+ -+void -+dwarf2_finish (void) -+{ -+#ifdef OLD -+ segT info_seg; -+ segT line_seg; -+#else -+ struct frchain *info_section, *line_section; -+#endif -+ struct line_seg *s; -+ int emit_other_sections = 0; -+ -+#ifdef OLD -+ info_seg = bfd_get_section_by_name (stdoutput, ".debug_info"); -+ emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg); -+#else -+ info_section = get_section_by_name("__DWARF", "__debug_info"); -+ emit_other_sections = info_section == NULL || !seg_not_empty_p(info_section); -+#endif -+ -+ if (!all_segs && emit_other_sections && files_in_use == 0) -+ /* There is no line information and no non-empty .debug_info -+ section. */ -+ return; -+ -+ /* To make get_frag_fix() work we force what would happen in -+ layout_addresses to add a last zero sized frag to each section. */ -+ add_last_frags_to_sections(); -+ -+ /* Calculate the size of an address for the target machine. */ -+#ifdef OLD -+ sizeof_address = DWARF2_ADDR_SIZE (stdoutput); -+#else -+ if(md_cputype & CPU_ARCH_ABI64) -+ sizeof_address = 8; -+ else -+ sizeof_address = 4; -+#endif -+ -+ /* Create and switch to the line number section. */ -+#ifdef OLD -+ line_seg = subseg_new (".debug_line", 0); -+ bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING); -+#else -+ line_section = section_new("__DWARF", "__debug_line", -+ S_REGULAR, S_ATTR_DEBUG, 0); -+#endif -+ -+ /* For each subsection, chain the debug entries together. */ -+ for (s = all_segs; s; s = s->next) -+ { -+ struct line_subseg *ss = s->head; -+ struct line_entry **ptail = ss->ptail; -+ -+ while ((ss = ss->next) != NULL) -+ { -+ *ptail = ss->head; -+ ptail = ss->ptail; -+ } -+ } -+ -+#ifdef OLD -+ out_debug_line (line_seg); -+#else -+ /* If might be possible that an older compiler is not using .file and .loc -+ in that case make sure not to put out a second empty line table. But it -+ is possible only .file is used and in that case put out the line table. */ -+ if(all_segs != NULL || files_in_use) -+ out_debug_line (line_section); -+#endif -+ -+ /* If this is assembler generated line info, and there is no -+ debug_info already, we need .debug_info and .debug_abbrev -+ sections as well. */ -+ if (emit_other_sections) -+ { -+#ifdef OLD -+ segT abbrev_seg; -+ segT aranges_seg; -+ segT ranges_seg; -+#else -+ struct frchain *abbrev_section, *aranges_section, *ranges_section; -+#endif -+ -+ assert (all_segs); -+ -+#ifdef OLD -+ info_seg = subseg_new (".debug_info", 0); -+ abbrev_seg = subseg_new (".debug_abbrev", 0); -+ aranges_seg = subseg_new (".debug_aranges", 0); -+ -+ bfd_set_section_flags (stdoutput, info_seg, -+ SEC_READONLY | SEC_DEBUGGING); -+ bfd_set_section_flags (stdoutput, abbrev_seg, -+ SEC_READONLY | SEC_DEBUGGING); -+ bfd_set_section_flags (stdoutput, aranges_seg, -+ SEC_READONLY | SEC_DEBUGGING); -+ -+ record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1); -+#else -+ info_section = section_new("__DWARF", "__debug_info", -+ S_REGULAR, S_ATTR_DEBUG, 0); -+ abbrev_section = section_new("__DWARF", "__debug_abbrev", -+ S_REGULAR, S_ATTR_DEBUG, 0); -+ aranges_section = section_new("__DWARF", "__debug_aranges", -+ S_REGULAR, S_ATTR_DEBUG, 0); -+ /* -+ * The alignment of the Mach-O (__DWARF, __debug_aranges) is the default -+ * 1-byte alignment, 2^0, so the aranges_section->frch_section->align -+ * field should remain zero and not changed. -+ */ -+#endif -+ -+ if (all_segs == NULL || all_segs->next == NULL) -+#ifdef OLD -+ ranges_seg = NULL; -+#else -+ ranges_section = NULL; -+#endif -+ else -+ { -+#ifdef OLD -+ ranges_seg = subseg_new (".debug_ranges", 0); -+ bfd_set_section_flags (stdoutput, ranges_seg, -+ SEC_READONLY | SEC_DEBUGGING); -+ record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1); -+ out_debug_ranges (ranges_seg); -+#else -+ ranges_section = section_new("__DWARF", "__debug_ranges", -+ S_REGULAR, S_ATTR_DEBUG, 0); -+ /* -+ * The alignment of the Mach-O (__DWARF, __debug_ranges) is the -+ * default 1-byte alignment, 2^0, so the -+ * ranges_section->frch_section->align field should remain zero -+ * and not changed. -+ */ -+ out_debug_ranges (ranges_section); -+#endif -+ } -+ -+#ifdef OLD -+ out_debug_aranges (aranges_seg, info_seg); -+ out_debug_abbrev (abbrev_seg); -+ out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg); -+#else -+ if (all_segs != NULL && -+ (all_segs->next != NULL || debug_type == DEBUG_DWARF2)) -+ { -+ out_debug_aranges (aranges_section, info_section); -+ out_debug_abbrev (abbrev_section); -+ out_debug_info (info_section, abbrev_section, line_section, -+ ranges_section); -+ } -+#endif -+ } -+} -+ -+/* -+ * macho_dwarf2_emit_offset() is used via the TC_DWARF2_EMIT_OFFSET macro to -+ * output an "offset". Where it is used the offset is to the start of -+ * information in a specific section for a field in another section. This -+ * appears to always be passed the section_symbol() for the specific section -+ * and that offset is always to the start of that section. So this is why -+ * we put out zeros. -+ */ -+static void -+macho_dwarf2_emit_offset( -+symbolS *symbol, -+unsigned int size) -+{ -+ unsigned int i; -+ -+ for(i = 0; i < size; i++) -+ out_byte(0); -+} -Index: odcctools-9.2-ld/as/dwarf2dbg.h -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ odcctools-9.2-ld/as/dwarf2dbg.h 2013-09-03 21:08:01.885209515 +0000 -@@ -0,0 +1,139 @@ -+/* dwarf2dbg.h - DWARF2 debug support -+ Copyright 1999, 2000, 2002, 2003 Free Software Foundation, Inc. -+ -+ This file is part of GAS, the GNU Assembler. -+ -+ GAS is free software; you can redistribute it and/or modify -+ it under the terms of the GNU General Public License as published by -+ the Free Software Foundation; either version 2, or (at your option) -+ any later version. -+ -+ GAS 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 GAS; see the file COPYING. If not, write to the Free -+ Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA -+ 02110-1301, USA. */ -+ -+#ifndef AS_DWARF2DBG_H -+#define AS_DWARF2DBG_H -+ -+/* HACKS for bfd_* and BFD_RELOC_* These would come from bfd/reloc.c */ -+typedef int bfd_boolean; -+ -+#include "as.h" -+ -+#define DWARF2_FLAG_IS_STMT (1 << 0) -+#define DWARF2_FLAG_BASIC_BLOCK (1 << 1) -+#define DWARF2_FLAG_PROLOGUE_END (1 << 2) -+#define DWARF2_FLAG_EPILOGUE_BEGIN (1 << 3) -+ -+struct dwarf2_line_info { -+ unsigned int filenum; -+ unsigned int line; -+ unsigned int column; -+ unsigned int isa; -+ unsigned int flags; -+}; -+ -+/* When creating dwarf2 debugging information for assembly files, the variable -+ dwarf2_file_number is used to generate a .file for each assembly source file -+ in read_a_source_file() in read.c . */ -+extern uint32_t dwarf2_file_number; -+ -+/* Info that is needed to be gathered for each symbol that will have a -+ dwarf2_subprogram when generating debug info directly for assembly files. -+ This is done in make_subprogram_for_symbol() in symbols.c . */ -+struct dwarf2_subprogram_info { -+ char *name; /* without a leading underbar, if any */ -+ uint32_t file_number; /* the dwarf file number this symbol is in */ -+ uint32_t line_number; /* the line number this symbol is at */ -+ /* -+ * The low_pc for the dwarf2_subprogram is taken from the symbol's -+ * n_value. The high_pc is taken from the next symbol's value or -+ * the end of the section for the last symbol. -+ */ -+ symbolS *symbol; -+ struct dwarf2_subprogram_info *next; -+}; -+extern struct dwarf2_subprogram_info *dwarf2_subprograms_info; -+ -+/* Implements the .file FILENO "FILENAME" directive. FILENO can be 0 -+ to indicate that no file number has been assigned. All real file -+ number must be >0. */ -+extern char *dwarf2_directive_file (uintptr_t dummy); -+ -+/* -+ * dwarf2_file() is what is called when generating -+ * debug info directly for assembly files with --gdwarf2. -+ */ -+extern void dwarf2_file (char *filename, offsetT num); -+ -+/* Implements the .loc FILENO LINENO [COLUMN] directive. FILENO is -+ the file number, LINENO the line number and the (optional) COLUMN -+ the column of the source code that the following instruction -+ corresponds to. FILENO can be 0 to indicate that the filename -+ specified by the textually most recent .file directive should be -+ used. */ -+extern void dwarf2_directive_loc (uintptr_t dummy); -+ -+/* -+ * dwarf2_loc() is what is called when generating -+ * debug info directly for assembly files with --gdwarf2. -+ */ -+extern void dwarf2_loc (offsetT filenum, offsetT line); -+ -+/* Implements the .loc_mark_labels {0,1} directive. */ -+extern void dwarf2_directive_loc_mark_labels (uintptr_t dummy); -+ -+/* Returns the current source information. If .file directives have -+ been encountered, the info for the corresponding source file is -+ returned. Otherwise, the info for the assembly source file is -+ returned. */ -+extern void dwarf2_where (struct dwarf2_line_info *l); -+ -+/* A hook to allow the target backend to inform the line number state -+ machine of isa changes when assembler debug info is enabled. */ -+extern void dwarf2_set_isa (unsigned int isa); -+ -+/* This function generates .debug_line info based on the address and -+ source information passed in the arguments. ADDR should be the -+ frag-relative offset of the instruction the information is for and -+ L is the source information that should be associated with that -+ address. */ -+extern void dwarf2_gen_line_info (addressT addr, struct dwarf2_line_info *l); -+ -+/* Must be called for each generated instruction. */ -+extern void dwarf2_emit_insn (int); -+ -+/* Should be called for each code label. */ -+extern void dwarf2_emit_label (symbolS *); -+ -+/* True when we're supposed to set the basic block mark whenever a label -+ is seen. Unless the target is doing Something Weird, just call -+ dwarf2_emit_label. */ -+extern bfd_boolean dwarf2_loc_mark_labels; -+ -+extern void dwarf2_finish (void); -+ -+extern int dwarf2dbg_estimate_size_before_relax (fragS *); -+extern int dwarf2dbg_relax_frag (fragS *); -+extern void dwarf2dbg_convert_frag (fragS *); -+ -+/* An enumeration which describes the sizes of offsets (to DWARF sections) -+ and the mechanism by which the size is indicated. */ -+enum dwarf2_format { -+ /* 32-bit format: the initial length field is 4 bytes long. */ -+ dwarf2_format_32bit, -+ /* DWARF3 64-bit format: the representation of the initial length -+ (of a DWARF section) is 0xffffffff (4 bytes) followed by eight -+ bytes indicating the actual length. */ -+ dwarf2_format_64bit, -+ /* SGI extension to DWARF2: The initial length is eight bytes. */ -+ dwarf2_format_64bit_irix -+}; -+ -+#endif /* AS_DWARF2DBG_H */ -Index: odcctools-9.2-ld/as/expr.c -=================================================================== ---- odcctools-9.2-ld.orig/as/expr.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/expr.c 2013-09-03 21:08:01.889209515 +0000 -@@ -72,7 +72,9 @@ - - O_bit_inclusive_or, /* (16) | */ - O_bit_or_not, /* (17) ! */ -- two_char_operator /* (18) encoding for two char operator */ -+ O_logical_and, /* (18) && */ -+ O_logical_or, /* (19) || */ -+ two_char_operator /* (20) encoding for two char operator */ - } operatorT; - - static segT expr( -@@ -239,24 +241,26 @@ - * which is used to advance the input_line_pointer over the operator. - */ - static int op_size [] = -- { 0, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1 }; -+ { 0, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2 }; - - /* - * op_rank is indexed by an operatorT and tells the rank of the operator. - * - * Rank Examples -- * 8 * / % -- * 7 + - -- * 6 >> << -- * 5 < > <= >= -- * 4 == != -- * 3 & -- * 2 ^ -- * 1 | ! -+ * 10 * / % -+ * 9 + - -+ * 8 >> << -+ * 7 < > <= >= -+ * 6 == != -+ * 5 & -+ * 4 ^ -+ * 3 | ! -+ * 2 && -+ * 1 || - * 0 operand, (expression) - */ - static operator_rankT op_rank [] = -- { 0, 8, 8, 8, 7, 7, 6, 6, 5, 5, 5, 5, 4, 4, 3, 2, 1, 1 }; -+ { 0,10,10,10, 9, 9, 8, 8, 7, 7, 7, 7, 6, 6, 5, 4, 3, 3, 2, 1 }; - - /* - * op_encoding is indexed by a an ASCII character and maps it to an operator. -@@ -266,7 +270,7 @@ - __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, - __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, - -- __, two_char_operator, __, __, __, O_modulus, O_bit_and, __, -+ __, two_char_operator, __, __, __, O_modulus, two_char_operator, __, - __, __, O_multiply, O_add, __, O_subtract, __, O_divide, - __, __, __, __, __, __, __, __, - __, __, __, __, two_char_operator, two_char_operator, two_char_operator, __, -@@ -277,7 +281,7 @@ - __, __, __, __, __, __, __, __, - __, __, __, __, __, __, __, __, - __, __, __, __, __, __, __, __, -- __, __, __, __, O_bit_inclusive_or, __, __, __, -+ __, __, __, __, two_char_operator, __, __, __, - - __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, - __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, -@@ -448,7 +452,8 @@ - } - else{ - if(seg2 == SEG_ABSOLUTE){ -- resultP->X_seg = seg1; -+ if(resultP->X_seg != SEG_DIFFSECT) -+ resultP->X_seg = seg1; - } - else{ - /* also know seg2 != -1 (SEG_PASS1) */ -@@ -510,6 +515,19 @@ - */ - try_to_make_absolute(resultP); - try_to_make_absolute(&right); -+ /* -+ * If we have the special assembly time constant expression -+ * of the difference of two symbols defined in the same -+ * section then divided by exactly 2 mark the expression -+ * indicating this. -+ */ -+ if(resultP->X_seg == SEG_DIFFSECT && -+ right.X_seg == SEG_ABSOLUTE && -+ op_left == O_divide && -+ right.X_add_number == 2){ -+ resultP->X_sectdiff_divide_by_two = 1; -+ goto down; -+ } - resultP->X_subtract_symbol = NULL; - resultP->X_add_symbol = NULL; - if(resultP->X_seg != SEG_ABSOLUTE || -@@ -527,6 +545,11 @@ - case O_bit_inclusive_or: - resultP->X_add_number |= right.X_add_number; - break; -+ -+ case O_logical_or: -+ resultP->X_add_number = -+ resultP->X_add_number || right.X_add_number; -+ break; - - case O_modulus: - if(right.X_add_number){ -@@ -542,6 +565,11 @@ - case O_bit_and: - resultP->X_add_number &= right.X_add_number; - break; -+ -+ case O_logical_and: -+ resultP->X_add_number = -+ resultP->X_add_number && right.X_add_number; -+ break; - - case O_multiply: - resultP->X_add_number *= right.X_add_number; -@@ -618,6 +646,7 @@ - break; - } /* switch(op_left) */ - } -+down: ; - } /* If we have to force need_pass_2 */ - } /* If operator was + */ - op_left = op_right; -@@ -776,7 +805,7 @@ - LITTLENUM_TYPE *leader; - /* -> littlenum we are frobbing now. */ - LITTLENUM_TYPE *pointer; -- long carry; -+ int32_t carry; - - leader = generic_bignum; - generic_bignum [0] = 0; -@@ -789,7 +818,7 @@ - for(pointer = generic_bignum; - pointer <= leader; - pointer++){ -- long work; -+ int32_t work; - - work = carry + radix * *pointer; - *pointer = work & LITTLENUM_MASK; -@@ -827,68 +856,60 @@ - * mean the same as the (conventional) "9f". This is simply - * easier than checking for strict canonical form. - */ -- if(number < 10){ -- if(c == 'b'){ -- /* -- * Backward ref to local label. -- * Because it is backward, expect it to be DEFINED. -- */ -- /* -- * Construct a local label. -- */ -- name = local_label_name((int)number, 0); -- symbolP = symbol_table_lookup(name); -- if((symbolP != NULL) && -- (symbolP->sy_type & N_TYPE) != N_UNDF){ -- /* Expected path: symbol defined. */ -- /* Local labels are never absolute. Don't waste -- time checking absoluteness. */ -- know((symbolP->sy_type & N_TYPE) == N_SECT); -- expressionP->X_add_symbol = symbolP; -- expressionP->X_add_number = 0; -- expressionP->X_seg = SEG_SECT; -- } -- else{ /* Either not seen or not defined. */ -- as_warn("Backw. ref to unknown label \"%lld\"," -- "0 assumed.", number); -- expressionP->X_add_number = 0; -- expressionP->X_seg = SEG_ABSOLUTE; -- } -- } -- else if(c == 'f'){ -- /* -- * Forward reference. Expect symbol to be -- * undefined or unknown. Undefined: seen it -- * before. Unknown: never seen it in this pass. -- * Construct a local label name, then an -- * undefined symbol. Don't create a XSEG frag -- * for it: caller may do that. -- * Just return it as never seen before. -- */ -- name = local_label_name((int)number, 1); -- symbolP = symbol_table_lookup(name); -- if(symbolP != NULL){ -- /* We have no need to check symbol -- properties. */ -- know((symbolP->sy_type & N_TYPE) == N_UNDF || -- (symbolP->sy_type & N_TYPE) == N_SECT); -- } -- else{ -- symbolP = symbol_new(name, N_UNDF, 0,0,0, -- &zero_address_frag); -- symbol_table_insert(symbolP); -- } -- expressionP->X_add_symbol = symbolP; -- expressionP->X_seg = SEG_UNKNOWN; -- expressionP->X_subtract_symbol = NULL; -- expressionP->X_add_number = 0; -+ if(c == 'b'){ -+ /* -+ * Backward ref to local label. -+ * Because it is backward, expect it to be DEFINED. -+ */ -+ /* -+ * Construct a local label. -+ */ -+ name = fb_label_name((int)number, 0); -+ symbolP = symbol_table_lookup(name); -+ if((symbolP != NULL) && -+ (symbolP->sy_type & N_TYPE) != N_UNDF){ -+ /* Expected path: symbol defined. */ -+ /* Local labels are never absolute. Don't waste -+ time checking absoluteness. */ -+ know((symbolP->sy_type & N_TYPE) == N_SECT); -+ expressionP->X_add_symbol = symbolP; -+ expressionP->X_add_number = 0; -+ expressionP->X_seg = SEG_SECT; - } -- else{ /* Really a number, not a local label. */ -- ignore_c_ll_or_ull(c); -- expressionP->X_add_number = number; -+ else{ /* Either not seen or not defined. */ -+ as_warn("Backw. ref to unknown label \"%lld\"," -+ "0 assumed.", number); -+ expressionP->X_add_number = 0; - expressionP->X_seg = SEG_ABSOLUTE; -- input_line_pointer--; /* restore following char */ -- } -+ } -+ } -+ else if(c == 'f'){ -+ /* -+ * Forward reference. Expect symbol to be -+ * undefined or unknown. Undefined: seen it -+ * before. Unknown: never seen it in this pass. -+ * Construct a local label name, then an -+ * undefined symbol. Don't create a XSEG frag -+ * for it: caller may do that. -+ * Just return it as never seen before. -+ */ -+ name = fb_label_name((int)number, 1); -+ symbolP = symbol_table_lookup(name); -+ if(symbolP != NULL){ -+ /* We have no need to check symbol -+ properties. */ -+ know((symbolP->sy_type & N_TYPE) == N_UNDF || -+ (symbolP->sy_type & N_TYPE) == N_SECT); -+ } -+ else{ -+ symbolP = symbol_new(name, N_UNDF, 0,0,0, -+ &zero_address_frag); -+ symbol_table_insert(symbolP); -+ } -+ expressionP->X_add_symbol = symbolP; -+ expressionP->X_seg = SEG_UNKNOWN; -+ expressionP->X_subtract_symbol = NULL; -+ expressionP->X_add_number = 0; - } - else{ /* a number >= 10 */ - ignore_c_ll_or_ull(c); -@@ -988,7 +1009,7 @@ - * then assigning it to the 64-bit value the expression - * will be correct. - */ -- (long) -+ (int32_t) - #endif - symbolP->sy_value; - } -@@ -1333,7 +1354,7 @@ - * any machine dependent frags of variable length in the - * chain. - */ -- unsigned long size, fail; -+ uint32_t size, fail; - struct frag *frag; - - if(add_symbol->sy_frag != NULL && -@@ -1407,6 +1428,14 @@ - if(second_op_char == '=') - return(O_not_equal); - return O_not_equal; -+ case '&': -+ if(second_op_char == '&') -+ return(O_logical_and); -+ return(O_bit_and); -+ case '|': -+ if(second_op_char == '|') -+ return(O_logical_or); -+ return(O_bit_inclusive_or); - default: - BAD_CASE(first_op_char); - return O_illegal; -Index: odcctools-9.2-ld/as/expr.h -=================================================================== ---- odcctools-9.2-ld.orig/as/expr.h 2013-09-03 21:08:01.405209526 +0000 -+++ odcctools-9.2-ld/as/expr.h 2013-09-03 21:08:01.889209515 +0000 -@@ -102,7 +102,12 @@ - O_constant must be extended into a bignum (i.e., it is not used - when performing arithmetic on these values). - FIXME: This field is not set very reliably. */ -- unsigned int X_unsigned : 1; -+ unsigned int X_unsigned : 1, -+ -+ /* Non-zero if we have the special assembly time constant expression -+ of the difference of two symbols defined in the same section then divided -+ by exactly 2. */ -+ X_sectdiff_divide_by_two : 1; - } expressionS; - - extern segT expression( -Index: odcctools-9.2-ld/as/md.h -=================================================================== ---- odcctools-9.2-ld.orig/as/md.h 2013-09-03 21:08:01.405209526 +0000 -+++ odcctools-9.2-ld/as/md.h 2013-09-03 21:08:01.889209515 +0000 -@@ -161,5 +161,5 @@ - * md_pcrel_from() returns the PC-relative offset from the given fixup. - * This is not implemented or used for most targets. - */ --extern long md_pcrel_from( -+extern int32_t md_pcrel_from( - const fixS *fixP); -Index: odcctools-9.2-ld/as/struc-symbol.h -=================================================================== ---- odcctools-9.2-ld.orig/as/struc-symbol.h 2013-09-03 21:08:01.405209526 +0000 -+++ odcctools-9.2-ld/as/struc-symbol.h 2013-09-03 21:08:01.889209515 +0000 -@@ -33,17 +33,17 @@ - struct symbol /* our version of an nlist node */ - { - nlist_t sy_nlist; /* what we write in .o file (if permitted) */ --#ifdef ARCH64 - char *sy_name; /* symbol name */ --#endif -- long unsigned sy_name_offset; /* 1-origin position of sy_name in symbols */ -+ uint32_t sy_name_offset; /* 1-origin position of sy_name in symbols */ - /* part of object file. */ - /* 0 for (nameless) .stabd symbols. */ - /* Not used until write_object() time. */ -- long int sy_number; /* 24 bit symbol number. */ -+ uint32_t sy_number; /* 24 bit symbol number. */ - /* Symbol numbers start at 0 and are */ - /* unsigned. */ - struct symbol *sy_prev_by_index; /* backward chain, or NULL */ -+ int sy_has_been_resolved; /* if true the next fieid is set */ -+ struct symbol *sy_prev_resolved; /* first non local in backward chain */ - struct symbol *sy_next; /* forward chain, or NULL */ - struct frag *sy_frag; /* NULL or -> frag this symbol attaches to. */ - struct symbol *sy_forward; /* value is really that of this other symbol */ -@@ -57,11 +57,8 @@ - - typedef struct symbol symbolS; - --#ifndef ARCH64 --#define sy_name sy_nlist .n_un. n_name -- /* Name field always points to a string. */ -- /* 0 means .stabd-like anonymous symbol. */ --#endif -+/* sy_name - Name field always points to a string. */ -+/* 0 means .stabd-like anonymous symbol. */ - #define sy_type sy_nlist. n_type - #ifdef NeXT_MOD - #define sy_other sy_nlist. n_sect -@@ -77,7 +74,7 @@ - struct indirect_symbol { - char *isy_name; /* name of the indirect */ - struct frag *isy_frag; /* frag this indirect attaches to */ -- unsigned long isy_offset; /* offset into frag this attaches to */ -+ uint32_t isy_offset; /* offset into frag this attaches to */ - struct symbol *isy_symbol; /* symbol for the indirect */ - struct indirect_symbol *isy_next; /* forward chain, or NULL */ - }; -Index: odcctools-9.2-ld/as/symbols.c -=================================================================== ---- odcctools-9.2-ld.orig/as/symbols.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/symbols.c 2013-09-03 21:08:01.889209515 +0000 -@@ -19,6 +19,7 @@ - - #include <stdlib.h> - #include <string.h> -+#include <ctype.h> - #include "as.h" - #include "hash.h" - #include "obstack.h" /* For "symbols.h" */ -@@ -32,6 +33,7 @@ - #include "messages.h" - #include "fixes.h" - #include "input-scrub.h" -+#include "dwarf2dbg.h" - - /* symbol-name => struct symbol pointer */ - struct hash_control *sy_hash = NULL; -@@ -69,16 +71,14 @@ - - typedef short unsigned int local_label_countT; - --static local_label_countT local_label_counter[10]; -- --static /* Returned to caller, then copied. */ -- char symbol_name_build[12]; /* used for created names ("4f") */ -- --static long int symbol_count = 0; /* The number of symbols we've declared. */ -- - static void make_stab_for_symbol( - symbolS *symbolP); - -+static void make_subprogram_for_symbol( -+ symbolS *symbolP); -+ -+static void fb_label_init(void); -+ - - void - symbol_begin( -@@ -89,56 +89,225 @@ - sy_hash = hash_new(); - memset((char *)(&abs_symbol), '\0', sizeof(abs_symbol)); - abs_symbol.sy_type = N_ABS; /* Can't initialise a union. Sigh. */ -- memset((char *)(local_label_counter), '\0', sizeof(local_label_counter) ); -+ fb_label_init (); - } - --/* -- * local_label_name() -- * -- * Caller must copy returned name: we re-use the area for the next name. -- */ --char * /* Return local label name. */ --local_label_name( --int n, /* we just saw "n:", "nf" or "nb" : n a digit */ --int augend) /* 0 for nb, 1 for n:, nf */ -+ -+/* Somebody else's idea of local labels. They are made by "n:" where n -+ is any decimal digit. Refer to them with -+ "nb" for previous (backward) n: -+ or "nf" for next (forward) n:. -+ -+ We do a little better and let n be any number, not just a single digit, but -+ since the other guy's assembler only does ten, we treat the first ten -+ specially. -+ -+ Like someone else's assembler, we have one set of local label counters for -+ entire assembly, not one set per (sub)segment like in most assemblers. This -+ implies that one can refer to a label in another segment, and indeed some -+ crufty compilers have done just that. -+ -+ Since there could be a LOT of these things, treat them as a sparse -+ array. */ -+ -+#define LOCAL_LABEL_CHAR '\002' -+#define FB_LABEL_SPECIAL (10) -+ -+static int32_t fb_low_counter[FB_LABEL_SPECIAL]; -+static int32_t *fb_labels; -+static int32_t *fb_label_instances; -+static int32_t fb_label_count; -+static int32_t fb_label_max; -+ -+/* This must be more than FB_LABEL_SPECIAL. */ -+#define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6) -+ -+static void -+fb_label_init (void) -+{ -+ memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter)); -+} -+ -+/* Add one to the instance number of this fb label. */ -+ -+void -+fb_label_instance_inc (int32_t label) - { -- register char * p; -- register char * q; -- char symbol_name_temporary[10]; /* build up a number, BACKWARDS */ -+ int32_t *i; -+ -+ if (label < FB_LABEL_SPECIAL) -+ { -+ ++fb_low_counter[label]; -+ return; -+ } -+ -+ if (fb_labels != NULL) -+ { -+ for (i = fb_labels + FB_LABEL_SPECIAL; -+ i < fb_labels + fb_label_count; ++i) -+ { -+ if (*i == label) -+ { -+ ++fb_label_instances[i - fb_labels]; -+ return; -+ } /* if we find it */ -+ } /* for each existing label */ -+ } - -- know( n >= 0 ); -- know( augend == 0 || augend == 1 ); -+ /* If we get to here, we don't have label listed yet. */ -+ -+ if (fb_labels == NULL) -+ { -+ fb_labels = (int32_t *) xmalloc (FB_LABEL_BUMP_BY * sizeof (int32_t)); -+ fb_label_instances = (int32_t *) xmalloc (FB_LABEL_BUMP_BY * sizeof (int32_t)); -+ fb_label_max = FB_LABEL_BUMP_BY; -+ fb_label_count = FB_LABEL_SPECIAL; -+ -+ } -+ else if (fb_label_count == fb_label_max) -+ { -+ fb_label_max += FB_LABEL_BUMP_BY; -+ fb_labels = (int32_t *) xrealloc ((char *) fb_labels, -+ fb_label_max * sizeof (int32_t)); -+ fb_label_instances = (int32_t *) xrealloc ((char *) fb_label_instances, -+ fb_label_max * sizeof (int32_t)); -+ } /* if we needed to grow */ -+ -+ fb_labels[fb_label_count] = label; -+ fb_label_instances[fb_label_count] = 1; -+ ++fb_label_count; -+} -+ -+static int32_t -+fb_label_instance (int32_t label) -+{ -+ int32_t *i; -+ -+ if (label < FB_LABEL_SPECIAL) -+ { -+ return (fb_low_counter[label]); -+ } -+ -+ if (fb_labels != NULL) -+ { -+ for (i = fb_labels + FB_LABEL_SPECIAL; -+ i < fb_labels + fb_label_count; ++i) -+ { -+ if (*i == label) -+ { -+ return (fb_label_instances[i - fb_labels]); -+ } /* if we find it */ -+ } /* for each existing label */ -+ } -+ -+ /* We didn't find the label, so this must be a reference to the -+ first instance. */ -+ return 0; -+} -+ -+/* Caller must copy returned name: we re-use the area for the next name. -+ -+ The mth occurence of label n: is turned into the symbol "Ln^Bm" -+ where n is the label number and m is the instance number. "L" makes -+ it a label discarded unless debugging and "^B"('\2') ensures no -+ ordinary symbol SHOULD get the same name as a local label -+ symbol. The first "4:" is "L4^B1" - the m numbers begin at 1. */ -+ -+char * /* Return local label name. */ -+fb_label_name (int32_t n, /* We just saw "n:", "nf" or "nb" : n a number. */ -+ int32_t augend /* 0 for nb, 1 for n:, nf. */) -+{ -+ int32_t i; -+ /* Returned to caller, then copied. Used for created names ("4f"). */ -+ static char symbol_name_build[24]; -+ register char *p; -+ register char *q; -+ char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */ -+ -+ know (n >= 0); -+#ifdef TC_MMIX -+ know ((uint32_t) augend <= 2 /* See mmix_fb_label. */); -+#else -+ know ((uint32_t) augend <= 1); -+#endif - p = symbol_name_build; -- * p ++ = 'L'; -- * p ++ = n + '0'; /* Make into ASCII */ -- * p ++ = 1; /* ^A */ -- n = local_label_counter [ n ] + augend; -- /* version number of this local label */ -- /* -- * Next code just does sprintf( {}, "%d", n); -- * It is more elegant to do the next part recursively, but a procedure -- * call for each digit emitted is considered too costly. -- */ -+#ifdef LOCAL_LABEL_PREFIX -+ *p++ = LOCAL_LABEL_PREFIX; -+#endif -+ *p++ = 'L'; -+ -+ /* Next code just does sprintf( {}, "%d", n); */ -+ /* Label number. */ - q = symbol_name_temporary; -- for (*q++=0; n; q++) /* emits NOTHING if n starts as 0 */ -+ for (*q++ = 0, i = n; i; ++q) - { -- know(n>0); /* We expect n > 0 always */ -- *q = n % 10 + '0'; -- n /= 10; -+ *q = i % 10 + '0'; -+ i /= 10; - } -- while (( * p ++ = * -- q )) -+ while ((*p = *--q) != '\0') -+ ++p; -+ -+ *p++ = LOCAL_LABEL_CHAR; /* ^B */ -+ -+ /* Instance number. */ -+ q = symbol_name_temporary; -+ for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q) - { -+ *q = i % 10 + '0'; -+ i /= 10; - } -- /* The label, as a '\0' ended string, starts at symbol_name_build. */ -+ while ((*p++ = *--q) != '\0'); -+ -+ /* The label, as a '\0' ended string, starts at symbol_name_build. */ - return (symbol_name_build); - } - -+/* Decode name that may have been generated by foo_label_name() above. -+ If the name wasn't generated by foo_label_name(), then return it -+ unaltered. This is used for error messages. */ -+ -+char * -+decode_local_label_name (char *s) -+{ -+ char *p; -+ char *symbol_decode; -+ int label_number; -+ int instance_number; -+ char *type; -+ int index = 0; -+ -+#ifdef LOCAL_LABEL_PREFIX -+ if (s[index] == LOCAL_LABEL_PREFIX) -+ ++index; -+#endif -+ -+ if (s[index] != 'L') -+ return s; -+ -+ for (label_number = 0, p = s + index + 1; isdigit (*p); ++p) -+ label_number = (10 * label_number) + *p - '0'; -+ -+ if (*p == LOCAL_LABEL_CHAR) -+ type = "fb"; -+ else -+ return s; -+ -+ for (instance_number = 0, p++; isdigit (*p); ++p) -+ instance_number = (10 * instance_number) + *p - '0'; -+ -+#define MESSAGE_FORMAT "\"%d\" (instance number %d of a %s label)" -+ symbol_decode = obstack_alloc (¬es, strlen (MESSAGE_FORMAT) + 30); -+ sprintf (symbol_decode, MESSAGE_FORMAT, label_number, instance_number, type); -+ -+ return symbol_decode; -+} -+ - void - local_colon( - int n) /* just saw "n:" */ - { -- local_label_counter [n] ++; -- colon (local_label_name (n, 0)); -+ fb_label_instance_inc (n); -+ colon (fb_label_name (n, 0), 1); - } - - /* -@@ -184,6 +353,7 @@ - symbolP -> sy_value = value; - symbolP -> sy_frag = frag; - symbolP -> sy_prev_by_index = NULL; /* Don't know what this is yet. */ -+ symbolP -> sy_has_been_resolved = 0; - symbolP -> sy_next = NULL; /* End of chain. */ - symbolP -> sy_forward = NULL; /* JF */ - symbolP -> expression = NULL; -@@ -252,8 +422,9 @@ - - void - colon( /* just seen "x:" - rattle symbols & frags */ --char *sym_name) /* symbol name, as a cannonical string */ -+char *sym_name, /* symbol name, as a cannonical string */ - /* We copy this string: OK to alter later. */ -+int local_colon)/* non-zero if called from local_colon() */ - { - register struct symbol * symbolP; /* symbol we are working with */ - -@@ -263,6 +434,14 @@ - as_fatal("with -n a section directive must be seen before assembly " - "can begin"); - } -+ if (inlineasm_checks && local_colon == 0) -+ { -+ if (inlineasm_file_name) -+ as_warn_where_with_column(inlineasm_file_name, inlineasm_line_number, -+ inlineasm_column_number, "label definition in inlineasm"); -+ else -+ as_bad("label definition in inlineasm"); -+ } - if ((symbolP = symbol_table_lookup( sym_name ))) - { - /* -@@ -275,7 +454,8 @@ - /* bug #50416 -O causes this not to work for: - && ((symbolP->sy_desc) & (~REFERENCE_TYPE)) == 0 - */ -- && (temp & (~(REFERENCE_TYPE | N_WEAK_REF | N_WEAK_DEF | N_ARM_THUMB_DEF | -+ && (temp & (~(REFERENCE_TYPE | N_WEAK_REF | N_WEAK_DEF | -+ N_ARM_THUMB_DEF | N_SYMBOL_RESOLVER | - N_NO_DEAD_STRIP | REFERENCED_DYNAMICALLY))) == 0 - && symbolP -> sy_value == 0) - { -@@ -285,13 +465,8 @@ - symbolP -> sy_type |= N_SECT; /* keep N_EXT bit */ - symbolP -> sy_other = frchain_now->frch_nsect; - symbolP -> sy_desc &= ~REFERENCE_TYPE; -- symbolP -> sy_desc &= ~N_WEAK_REF; -+ symbolP -> sy_desc &= ~(N_WEAK_REF & N_WEAK_DEF); - symbol_assign_index(symbolP); -- if((symbolP->sy_desc & N_WEAK_DEF) == N_WEAK_DEF && -- (frchain_now->frch_section.flags & S_COALESCED) != S_COALESCED) -- as_fatal("symbol: %s can't be a weak_definition (currently " -- "only supported in section of type coalesced)", -- sym_name); - #ifdef NeXT_MOD /* generate stabs for debugging assembly code */ - if(flagseen['g']) - make_stab_for_symbol(symbolP); -@@ -454,6 +629,52 @@ - #endif /* NeXT generate stabs for debugging assembly code */ - - /* -+ * make_subprogram_for_symbol() gathers the info that is needed for each -+ * symbol that will have a dwarf2_subprogram when generating dwarf debugging -+ * info for assembly files. -+ */ -+static -+void -+make_subprogram_for_symbol( -+symbolS *symbolP) -+{ -+ struct dwarf2_subprogram_info *i; -+ static struct dwarf2_subprogram_info *last_dwarf2_subprogram_info = NULL; -+ -+ if(symbolP->sy_name[0] == 'L') -+ return; -+ if((symbolP->sy_type & N_TYPE) != N_SECT) -+ return; -+ if(symbolP->sy_other != text_nsect) -+ return; -+ -+ i = xmalloc(sizeof(struct dwarf2_subprogram_info)); -+ i->name = symbolP->sy_name; -+ if(i->name[0] == '_') -+ i->name++; -+ i->file_number = dwarf2_file_number; -+ i->line_number = logical_input_line; -+ /* -+ * We can't used the symbolP directly as it may have the N_ARM_THUMB_DEF -+ * bit set. And that will cause the AT_high_pc and AT_low_pc values to -+ * have the low bit set after relocation producing bad dwarf. So we -+ * create a temporary symbol that will not have the N_ARM_THUMB_DEF bit -+ * set. -+ */ -+ i->symbol = symbol_temp_new(symbolP->sy_other, symbolP->sy_value, -+ symbolP->sy_frag); -+ i->next = NULL; -+ if(dwarf2_subprograms_info == NULL){ -+ dwarf2_subprograms_info = i; -+ last_dwarf2_subprogram_info = i; -+ } -+ else{ -+ last_dwarf2_subprogram_info->next = i; -+ last_dwarf2_subprogram_info = i; -+ } -+} -+ -+/* - * indirect_symbol_new() - * - * Return a pointer to a new indirect_symbol. -@@ -465,16 +686,16 @@ - indirect_symbol_new( - char *name, /* We copy this: OK to alter your copy. */ - struct frag *frag, /* For sy_frag. */ --unsigned long offset) /* Offset from frag address. */ -+uint32_t offset) /* Offset from frag address. */ - { - isymbolS *isymbolP; - char *preserved_copy_of_name; -- unsigned long name_length; -+ uint32_t name_length; - char *p; - struct frag *fr_next; - symbolS *symbolP; - #ifdef CHECK_INDIRECTS -- unsigned long stride, fr_fix; -+ uint32_t stride, fr_fix; - #endif - - /* -@@ -528,7 +749,7 @@ - S_SYMBOL_STUBS) - stride = frchain_now->frch_section.reserved2; - else -- stride = sizeof(unsigned long); -+ stride = sizeof(uint32_t); - if(frag == frchain_now->frch_isym_last->isy_frag){ - if(offset - frchain_now->frch_isym_last->isy_offset != stride) - as_bad("missing or bad indirect symbol for section " -@@ -615,4 +836,66 @@ - - #endif /* TC_SYMFIELD_TYPE */ - -+int -+S_IS_LOCAL (symbolS *s) -+{ -+ const char *name; -+ -+ name = S_GET_NAME (s); -+ if(name == NULL) -+ return(1); -+ -+ if(name[0] == 'L' && flagseen['L'] == FALSE) -+ return(1); -+ else -+ return(0); -+} -+ -+fragS * -+symbol_get_frag (symbolS *s) -+{ -+ return(s->sy_frag); -+} -+ -+/* -+ * symbol_temp_new(), symbol_temp_new_now() are used by dwarf2dbg.c to make -+ * symbols in dwarf sections. symbol_temp_make() is used to make an undefined -+ * symbol that its values are later set by symbol_set_value_now() to the current -+ * address in a dwarf section. -+ * -+ * These are used in expressions, so the expression values can be put out in -+ * dwarf section contents. -+ */ -+symbolS * -+symbol_temp_new( -+segT nsect, -+valueT value, -+struct frag *frag) -+{ -+ return(symbol_new(FAKE_LABEL_NAME, N_SECT, nsect, 0, value, frag)); -+} -+ -+symbolS * -+symbol_temp_new_now(void) -+{ -+ return(symbol_temp_new(now_seg, frag_now_fix(), frag_now)); -+} -+ -+symbolS * -+symbol_temp_make(void) -+{ -+ return(symbol_new(FAKE_LABEL_NAME, N_UNDF, 0, 0, 0, & zero_address_frag)); -+} -+ -+/* Set the value of SYM to the current position in the current segment. */ -+void -+symbol_set_value_now( -+symbolS *sym) -+{ -+ sym->sy_type = N_SECT; -+ sym->sy_other = now_seg; -+ sym->sy_value = frag_now_fix(); -+ sym->sy_frag = frag_now; -+} -+ - /* end: symbols.c */ -Index: odcctools-9.2-ld/as/symbols.h -=================================================================== ---- odcctools-9.2-ld.orig/as/symbols.h 2013-09-03 21:08:01.409209526 +0000 -+++ odcctools-9.2-ld/as/symbols.h 2013-09-03 21:08:01.889209515 +0000 -@@ -28,9 +28,9 @@ - - extern void symbol_begin( - void); --extern char *local_label_name( -- int n, -- int augend); -+extern char *fb_label_name( -+ int32_t n, -+ int32_t augend); - extern void - local_colon( - int n); -@@ -49,7 +49,8 @@ - extern void symbol_assign_index( - struct symbol *symbolP); - extern void colon( -- char *sym_name); -+ char *sym_name, -+ int local_colon); - extern void symbol_table_insert( - struct symbol *symbolP); - extern symbolS *symbol_find_or_make( -@@ -63,7 +64,7 @@ - extern isymbolS *indirect_symbol_new( - char *name, - struct frag *frag, -- unsigned long offset); -+ uint32_t offset); - - /* FROM line 98 */ - extern int S_IS_DEFINED (symbolS *); -@@ -80,6 +81,8 @@ - extern void S_CLEAR_EXTERNAL (symbolS *); - extern void S_SET_WEAK (symbolS *); - extern void S_SET_THREAD_LOCAL (symbolS *); -+extern int S_IS_LOCAL (symbolS *s); -+extern fragS * symbol_get_frag (symbolS *s); - - /* FROM line tc-arm.h 104 */ - #define TC_SYMFIELD_TYPE unsigned int -@@ -95,3 +98,13 @@ - extern void arm_frob_label (symbolS *); - #endif - -+extern symbolS * symbol_temp_new( -+ segT nsect, -+ valueT value, -+ struct frag *frag); -+extern symbolS * symbol_temp_new_now( -+ void); -+extern symbolS * symbol_temp_make( -+ void); -+extern void symbol_set_value_now( -+ symbolS *sym); -Index: odcctools-9.2-ld/as/Makefile.arch.in -=================================================================== ---- odcctools-9.2-ld.orig/as/Makefile.arch.in 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/Makefile.arch.in 2013-09-03 21:08:01.889209515 +0000 -@@ -45,7 +45,7 @@ - CFILES = app.c as.c atof-generic.c atof-ieee.c expr.c fixes.c flonum-const.c \ - flonum-copy.c flonum-mult.c frags.c hash.c hex-value.c input-file.c \ - input-scrub.c layout.c messages.c obstack.c read.c sections.c \ -- symbols.c write_object.c xmalloc.c $(CFILES_$(ARCH)) -+ symbols.c write_object.c xmalloc.c dwarf2dbg.c $(CFILES_$(ARCH)) - - OBJS = $(CFILES:.c=.o) - -Index: odcctools-9.2-ld/as/fixes.h -=================================================================== ---- odcctools-9.2-ld.orig/as/fixes.h 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/fixes.h 2013-09-03 21:08:01.889209515 +0000 -@@ -31,25 +31,31 @@ - */ - struct fix { - fragS *fx_frag; /* which frag? */ -- long int fx_where; /* where is the 1st byte to fix up? */ -+ int32_t fx_where; /* where is the 1st byte to fix up? */ - symbolS *fx_addsy; /* NULL or Symbol whose value we add in */ - symbolS *fx_subsy; /* NULL or Symbol whose value we subtract */ - #if defined(I386) && defined(ARCH64) - symbolS *fx_localsy; /* NULL or pseudo-symbol for this fixup */ - #endif -- long int fx_offset; /* absolute number we add in */ -+ signed_expr_t -+ fx_offset; /* absolute number we add in */ - struct fix *fx_next; /* NULL or -> next fixS */ - char fx_size; /* how many bytes are involved? */ - char fx_pcrel; /* TRUE: pc-relative. */ - char fx_pcrel_reloc;/* force a pc-relative relocatation entry */ - char fx_r_type; /* relocation type */ -- long fx_value; /* the relocated value placed in the frag */ -+ int32_t fx_value; /* the relocated value placed in the frag */ - char *file; /* the file name this came from for errors */ - unsigned int line; /* the line number this came from for errors */ - - /* FROM write.h line 82 */ - /* Has this relocation already been applied? */ -- unsigned fx_done : 1; -+ unsigned fx_done : 1, -+ -+ /* Non-zero if we have the special assembly time constant expression -+ of the difference of two symbols defined in the same section then divided -+ by exactly 2. */ -+ fx_sectdiff_divide_by_two : 1; - - /* FROM write.h line 133 */ - /* This field is sort of misnamed. It appears to be a sort of random -Index: odcctools-9.2-ld/as/read.c -=================================================================== ---- odcctools-9.2-ld.orig/as/read.c 2013-09-03 21:08:01.285209529 +0000 -+++ odcctools-9.2-ld/as/read.c 2013-09-03 21:15:08.789199489 +0000 -@@ -62,6 +62,7 @@ - #if defined(I386) && defined(ARCH64) - #include "i386.h" - #endif -+#include "dwarf2dbg.h" - - #ifdef HAVE_CONFIG_H - #include <config.h> -@@ -194,19 +195,14 @@ - *ma_hash = NULL; /* use before set up: NULL-> address error */ - static struct obstack macros; /* obstack for macro text */ - static char *macro_name = NULL; /* name of macro we are defining */ --static struct macro_info *macro_info; /* info re. macro we are defining */ - static int count_lines = TRUE; /* turns line number counting on and off */ - static int macros_on = TRUE; /* .macros_on and .macros_off toggles this to - allow macros to be turned off, which allows - macros to override a machine instruction and - still use it. */ --static void expand_macro(struct macro_info *info); -+static void expand_macro(char *macro_contents); - static void macro_begin(void); - --/* iPhone binutils local: "repeat" command recording */ --int rept_recording = 0; --char *rept_record_start; --int rept_times = 0; - - /* - * The .dump and .load feature is implemented with these variables and -@@ -228,10 +224,8 @@ - #ifdef PPC - static void ppcasm_pseudo_op_begin(void); - #endif --static void pseudo_set(symbolS *symbolP); --static void stab(int what); --static char get_absolute_expression_and_terminator(long *val_pointer); --static char *demand_copy_C_string(int *len_pointer); -+static void stab(uintptr_t what); -+static char get_absolute_expression_and_terminator(int32_t *val_pointer); - static char *demand_copy_string(int *lenP); - static int is_it_end_of_statement(void); - static void equals(char *sym_name); -@@ -254,7 +248,7 @@ - * for used by the machine dependent md_assemble() to create line number stabs - * for assembly instructions in the text section when -g is seen. - */ --unsigned long text_nsect = 0; -+uint32_t text_nsect = 0; - - /* - * These are the names of the section types used by the .section directive. -@@ -279,6 +273,10 @@ - { "mod_term_funcs", S_MOD_TERM_FUNC_POINTERS }, - { "coalesced", S_COALESCED }, - { "interposing", S_INTERPOSING }, -+ { "thread_local_regular", S_THREAD_LOCAL_REGULAR }, -+ { "thread_local_variables", S_THREAD_LOCAL_VARIABLES }, -+ { "thread_local_init_function_pointers", -+ S_THREAD_LOCAL_INIT_FUNCTION_POINTERS }, - { NULL, 0 } - }; - -@@ -310,9 +308,9 @@ - char *directive; - char *segname; - char *sectname; -- unsigned long flags; /* type & attribute */ -- unsigned long default_align; -- unsigned long sizeof_stub; -+ uint32_t flags; /* type & attribute */ -+ uint32_t default_align; -+ uint32_t sizeof_stub; - }; - static const struct builtin_section builtin_sections[] = { - /* -@@ -385,6 +383,12 @@ - { "data", "__DATA", "__data" }, - { "static_data", "__DATA", "__static_data" }, - { "const_data", "__DATA", "__const" }, -+ { "tdata", "__DATA", "__thread_data", -+ S_THREAD_LOCAL_REGULAR }, -+ { "tlv", "__DATA", "__thread_vars", -+ S_THREAD_LOCAL_VARIABLES }, -+ { "thread_init_func", "__DATA", "__thread_init", -+ S_THREAD_LOCAL_INIT_FUNCTION_POINTERS }, - { "objc_class", "__OBJC", "__class", S_ATTR_NO_DEAD_STRIP }, - { "objc_meta_class", "__OBJC", "__meta_class", S_ATTR_NO_DEAD_STRIP }, - { "objc_string_object", "__OBJC", "__string_object", S_ATTR_NO_DEAD_STRIP}, -@@ -419,56 +423,56 @@ - * The routines that implement the pseudo-ops. - */ - #if !defined(I860) /* i860 has it's own align and org */ --static void s_balign(int value); --static void s_align(int value); -- --static --void --s_align_( --int fill_size, --int power_of_2_alignment); -- --static void s_org(int value); -+static void s_align(int value, int bytes_p); -+static void s_align_bytes(uintptr_t arg); -+static void s_align_ptwo(uintptr_t arg); -+static void s_org(uintptr_t value); - #endif --static void s_private_extern(int value); -+static void s_private_extern(uintptr_t value); - #if !(defined(I386) && defined(ARCH64)) --static void s_indirect_symbol(int value); -+static void s_indirect_symbol(uintptr_t value); - #endif --static void s_abort(int value); --static void s_comm(int value); --static void s_desc(int value); --static void s_file(int value); --static void s_fill(int value); --static void s_lcomm(int value); --static void s_lsym(int value); --static void s_set(int value); --static void s_reference(int value); --static void s_lazy_reference(int value); --static void s_weak_reference(int value); --static void s_weak_definition(int value); --static void s_no_dead_strip(int value); --static void s_include(int value); --static void s_dump(int value); --static void s_load(int value); --static void s_if(int value); --static void s_elseif(int value); --static void s_else(int value); --static void s_endif(int value); --static void s_macros_on(int value); --static void s_macros_off(int value); --static void s_section(int value); --static void s_zerofill(int value); --static unsigned long s_builtin_section(const struct builtin_section *s); --static void s_subsections_via_symbols(int value); --static void s_machine(int value); --static void s_secure_log_unique(int value); --static void s_secure_log_reset(int value); -+static void s_abort(uintptr_t value); -+static void s_comm(uintptr_t value); -+static void s_desc(uintptr_t value); -+static void s_fill(uintptr_t value); -+static void s_lcomm(uintptr_t value); -+static void s_lsym(uintptr_t value); -+static void s_set(uintptr_t value); -+static void s_reference(uintptr_t value); -+static void s_lazy_reference(uintptr_t value); -+static void s_weak_reference(uintptr_t value); -+static void s_weak_definition(uintptr_t value); -+static void s_weak_def_can_be_hidden(uintptr_t value); -+static void s_no_dead_strip(uintptr_t value); -+static void s_symbol_resolver(uintptr_t value); -+static void s_include(uintptr_t value); -+static void s_dump(uintptr_t value); -+static void s_load(uintptr_t value); -+static void s_if(uintptr_t value); -+static void s_elseif(uintptr_t value); -+static void s_else(uintptr_t value); -+static void s_endif(uintptr_t value); -+static void s_macros_on(uintptr_t value); -+static void s_macros_off(uintptr_t value); -+static void s_section(uintptr_t value); -+static void s_zerofill(uintptr_t value); -+static uint32_t s_builtin_section(const struct builtin_section *s); -+static void s_subsections_via_symbols(uintptr_t value); -+static void s_machine(uintptr_t value); -+static void s_secure_log_unique(uintptr_t value); -+static void s_secure_log_reset(uintptr_t value); -+static void s_inlineasm(uintptr_t value); -+static void s_leb128(uintptr_t sign); -+static void s_incbin(uintptr_t value); -+static void s_data_region(uintptr_t value); -+static void s_end_data_region(uintptr_t value); - - #ifdef PPC - /* - * The routines that implement the ppcasm pseudo-ops. - */ --static void s_ppcasm_end(int value); -+static void s_ppcasm_end(uintptr_t value); - #endif /* PPC */ - - /* -@@ -476,14 +480,14 @@ - */ - static const pseudo_typeS pseudo_table[] = { - #if !defined(I860) /* i860 has it's own align and org */ -- { "align", s_align, 1 }, -- { "align32", s_align, 4 }, -- { "balign", s_balign, 1 }, -- { "balignw", s_balign, 2 }, -- { "balignl", s_balign, 4 }, -- { "p2align", s_align, 1 }, -- { "p2alignw", s_align, 2 }, -- { "p2alignl", s_align, 4 }, -+ { "align", s_align_ptwo, 1 }, -+ { "align32", s_align_ptwo, 4 }, -+ { "p2align", s_align_ptwo, 1 }, -+ { "p2alignw", s_align_ptwo, 2 }, -+ { "p2alignl", s_align_ptwo, 4 }, -+ { "balign", s_align_bytes, 1 }, -+ { "balignw", s_align_bytes, 2 }, -+ { "balignl", s_align_bytes, 4 }, - { "org", s_org, 0 }, - #endif - #ifndef M88K /* m88k has it's own abs that uses the s_abs() in here */ -@@ -500,23 +504,26 @@ - { "comm", s_comm, 0 }, - { "desc", s_desc, 0 }, - { "double", float_cons, 'd' }, -- { "file", s_file, 0 }, -+ { "file", s_app_file, 0 }, -+ { "appfile", s_app_file, 0 }, - { "fill", s_fill, 0 }, - { "globl", s_globl, 0 }, -- { "global", s_globl, 0 }, /* iPhone binutils extension */ - { "lcomm", s_lcomm, 0 }, - { "line", s_line, 0 }, - { "long", cons, 4 }, - { "quad", cons, 8 }, - { "lsym", s_lsym, 0 }, - { "section", s_section, 0 }, -- { "zerofill", s_zerofill, 0 }, -+ { "zerofill", s_zerofill, S_ZEROFILL }, -+ { "tbss", s_zerofill, S_THREAD_LOCAL_ZEROFILL }, - { "secure_log_unique",s_secure_log_unique, 0 }, - { "secure_log_reset",s_secure_log_reset, 0 }, - { "set", s_set, 0 }, - { "short", cons, 2 }, - { "single", float_cons, 'f' }, - { "space", s_space, 0 }, -+ { "sleb128", s_leb128, 1}, -+ { "uleb128", s_leb128, 0}, - { "stabd", stab, 'd' }, - { "stabn", stab, 'n' }, - { "stabs", stab, 's' }, -@@ -525,7 +532,9 @@ - { "lazy_reference",s_lazy_reference, 0 }, - { "weak_reference",s_weak_reference, 0 }, - { "weak_definition",s_weak_definition, 0 }, -+ { "weak_def_can_be_hidden",s_weak_def_can_be_hidden, 0 }, - { "no_dead_strip",s_no_dead_strip, 0 }, -+ { "symbol_resolver",s_symbol_resolver, 0 }, - { "include", s_include, 0 }, - { "macro", s_macro, 0 }, - { "endmacro", s_endmacro, 0 }, -@@ -540,12 +549,11 @@ - { "load", s_load, 0 }, - { "subsections_via_symbols", s_subsections_via_symbols, 0 }, - { "machine", s_machine, 0 }, -- { "rept", s_rept, 0 }, -- { "endr", s_endr, 0 }, -- { "ifc", s_ifc, 0 }, -- { "ifnc", s_ifnc, 0 }, -- { "ifdef", s_ifdef, 0 }, -- { "ifndef", s_ifdef, 1 }, -+ { "inlineasmstart", s_inlineasm, 1 }, -+ { "inlineasmend", s_inlineasm, 0 }, -+ { "incbin", s_incbin, 0 }, -+ { "data_region", s_data_region, 0 }, -+ { "end_data_region", s_end_data_region, 0 }, - { NULL } /* end sentinel */ - }; - -@@ -577,7 +585,7 @@ - obstack_begin(¬es, 5000); - - #ifdef M68K /* we allow big cons only on the 68k machines */ -- bignum_low = xmalloc((long)BIGNUM_BEGIN_SIZE); -+ bignum_low = xmalloc((int32_t)BIGNUM_BEGIN_SIZE); - bignum_limit = bignum_low + BIGNUM_BEGIN_SIZE; - #endif - } -@@ -614,11 +622,12 @@ - { - const char *errtxt; - const pseudo_typeS *pop; -- unsigned long i; -+ uint32_t i; - pseudo_typeS *sections_pseudo_table; - - po_hash = hash_new(); - errtxt = NULL; -+ - for(pop = pseudo_table; - pop->poc_name && (!errtxt || *errtxt == '\0'); - pop++) -@@ -635,8 +644,8 @@ - for(i = 0; builtin_sections[i].directive != NULL; i++){ - sections_pseudo_table[i].poc_name = builtin_sections[i].directive; - sections_pseudo_table[i].poc_handler = -- (void (*)(int))s_builtin_section; -- sections_pseudo_table[i].poc_val = (int)(builtin_sections + i); -+ (void (*)(uintptr_t))s_builtin_section; -+ sections_pseudo_table[i].poc_val = (uintptr_t)(builtin_sections +i); - } - sections_pseudo_table[i].poc_name = NULL; - for(pop = (const pseudo_typeS *)sections_pseudo_table; -@@ -662,7 +671,7 @@ - const char *errtxt; - char *uppercase; - const pseudo_typeS *pop; -- unsigned long len, i; -+ uint32_t len, i; - - ppcasm_po_hash = hash_new(); - errtxt = NULL; -@@ -897,9 +906,10 @@ - used only for macro expansion */ - pseudo_typeS *pop; /* pointer to a pseudo op stucture returned by - hash_find(po_hash, s+1) to determine if it is one */ -- struct macro_info *the_macro; /* pointer to a macro name returned by -+ char *the_macro; /* pointer to a macro name returned by - hash_find(ma_hash, s) to determine if it is one */ -- int digit_value; /* the value of a digit label as an integer, 1: == 1 */ -+ int temp; /* the value of a number label as an integer, 1: == 1 */ -+ char *backup; - - /* since this is a buffer of full lines it must end in a new line */ - know(buffer_limit[-1] == '\n'); -@@ -1079,7 +1089,7 @@ - * Look for a user defined label. - */ - else if(after_name == ':'){ -- colon(s); -+ colon(s, 0); - #ifdef I860 - /* - * Intel :: feature, which makes the label global if -@@ -1123,14 +1133,6 @@ - * one to a line. - */ - else{ -- char *s2 = s; -- -- while (*s2) -- { -- *s2 = tolower(*s2); -- s2++; -- } -- - *input_line_pointer = after_name; - while(is_end_of_line(*input_line_pointer) == 0) - input_line_pointer++; -@@ -1173,24 +1175,22 @@ - continue; - } - -- /* local label ("4:") -- * iPhone binutils local - allow more than 10 local labels */ -- char *ptr = input_line_pointer - 1; -- int local_label_no = 0; -- while (isdigit(*ptr)) { -- local_label_no = local_label_no * 10 + ((*ptr) - '0'); -- ptr++; -- } -- if (*ptr == ':') { -- input_line_pointer = ptr + 1; -- local_colon(local_label_no); -- continue; -- } -- -- as_bad("Spurious digit %d.", digit_value); -- input_line_pointer--; -- ignore_rest_of_line(); -- continue; -+ /* local label ("4:") */ -+ if(isdigit(c)){ -+ backup = input_line_pointer; -+ temp = c - '0'; -+ /* Read the whole number. */ -+ while(isdigit(*input_line_pointer)) -+ { -+ temp = (temp * 10) + *input_line_pointer - '0'; -+ ++input_line_pointer; -+ } -+ if(*input_line_pointer++ == ':'){ -+ local_colon(temp); -+ continue; -+ } -+ input_line_pointer = backup; -+ } - - /* - * The only full line comment that should make it here is the first -@@ -1313,7 +1313,7 @@ - after_name = c; - after_name_pointer = input_line_pointer; - *after_name_pointer = '\0'; -- colon(s); -+ colon(s, 0); - *after_name_pointer = after_name; - /* - * A colon after the name is optional and may have a spaces -@@ -1596,7 +1596,7 @@ - static - void - s_abort( --int value) -+uintptr_t value) - { - char *p; - -@@ -1610,6 +1610,30 @@ - - #if !defined(I860) /* i860 has it's own align and org */ - /* -+ * s_align_bytes() handles the .align pseudo-op where ".align 4" means align to -+ * a 4 byte boundary. -+ */ -+static -+void -+s_align_bytes( -+uintptr_t arg) -+{ -+ s_align(arg, 1); -+} -+ -+/* -+ * s_align_ptwo() handles the .align pseudo-op on where ".align 4" means align -+ * to a 2**4 boundary. -+ */ -+static -+void -+s_align_ptwo( -+uintptr_t arg) -+{ -+ s_align(arg, 0); -+} -+ -+/* - * s_align() implements the pseudo ops - * .align align_expression [ , 1byte_fill_expression [,max_bytes_to_fill]] - * .p2align align_expression [ , 1byte_fill_expression [,max_bytes_to_fill]] -@@ -1619,49 +1643,37 @@ - * Where align_expression is a power of 2 alignment. - * - * The parameter fill_size can only be 1, 2 or 4 which is the size of the -- * fill_expression. -+ * fill_expression. If the parameter bytes_p is non-zero the alignment value -+ * is interpreted as the byte boundary, rather than the power of 2. - */ --static inline int32_t ilog2(uint32_t value) { -- return value == 0 ? -1 : 1 + ilog2(value >> 1); --} -- --static --void --s_balign( --int fill_size) --{ -- int power_of_2_alignment; -- -- if(fill_size != 1 && fill_size != 2 && fill_size != 4) -- as_bad("Internal error, s_align() called with bad fill_size %d", -- fill_size); -- -- power_of_2_alignment = get_absolute_expression(); -- power_of_2_alignment = ilog2(power_of_2_alignment); --#define MAX_ALIGNMENT (15) -- if(power_of_2_alignment > MAX_ALIGNMENT) -- as_warn("Alignment too large: %d. assumed.", -- power_of_2_alignment = MAX_ALIGNMENT); -- else if(power_of_2_alignment < 0){ -- as_warn("Alignment negative. 0 assumed."); -- power_of_2_alignment = 0; -- } -- -- s_align_(fill_size, power_of_2_alignment); --} -- - static - void - s_align( --int fill_size) -+int fill_size, -+int bytes_p) - { -- int power_of_2_alignment; -+ int power_of_2_alignment, byte_alignment, i; -+ int32_t temp_fill, fill_specified, max_bytes_to_fill; -+ char fill[4]; - - if(fill_size != 1 && fill_size != 2 && fill_size != 4) - as_bad("Internal error, s_align() called with bad fill_size %d", - fill_size); - -- power_of_2_alignment = get_absolute_expression(); -+ power_of_2_alignment = 0; -+ if(bytes_p == 0){ -+ power_of_2_alignment = get_absolute_expression(); -+ } -+ else{ -+ byte_alignment = get_absolute_expression(); -+ if(byte_alignment != 0){ -+ for(i = 0; (byte_alignment & 1) == 0; i++) -+ byte_alignment >>= 1; -+ if(byte_alignment != 1) -+ as_bad("alignment not a power of 2"); -+ power_of_2_alignment = i; -+ } -+ } - #define MAX_ALIGNMENT (15) - if(power_of_2_alignment > MAX_ALIGNMENT) - as_warn("Alignment too large: %d. assumed.", -@@ -1670,19 +1682,6 @@ - as_warn("Alignment negative. 0 assumed."); - power_of_2_alignment = 0; - } -- -- s_align_(fill_size, power_of_2_alignment); --} -- --static --void --s_align_( --int fill_size, --int power_of_2_alignment) --{ -- long temp_fill, fill_specified, max_bytes_to_fill; -- char fill[4]; -- - temp_fill = 0; - fill_specified = 0; - max_bytes_to_fill = 0; -@@ -1741,6 +1740,27 @@ - fill_size = 4; /* 4 byte fill size */ - } - #endif /* PPC */ -+#ifdef ARM -+ if(power_of_2_alignment >= 1){ -+ extern int thumb_mode; /* from arm.c */ -+ if(thumb_mode){ -+ if(archflag_cpusubtype == CPU_SUBTYPE_ARM_V7 || -+ archflag_cpusubtype == CPU_SUBTYPE_ARM_V7F || -+ archflag_cpusubtype == CPU_SUBTYPE_ARM_V7K){ -+ temp_fill = 0xbf00; /* thumb2 nop */ -+ fill_size = 2; /* 2 byte fill size */ -+ } -+ else{ -+ temp_fill = 0x46c0; /* thumb1 nop */ -+ fill_size = 2; /* 2 byte fill size */ -+ } -+ } -+ else if(power_of_2_alignment >= 2){ -+ temp_fill = 0xe1a00000; /* arm nop */ -+ fill_size = 4; /* 4 byte fill size */ -+ } -+ } -+#endif /* ARM */ - ; /* empty statement for other architectures */ - } - -@@ -1759,7 +1779,7 @@ - */ - if(max_bytes_to_fill == 0 && - frchain_now->frch_section.align < -- (unsigned long)power_of_2_alignment) -+ (uint32_t)power_of_2_alignment) - frchain_now->frch_section.align = power_of_2_alignment; - - demand_empty_rest_of_line(); -@@ -1773,7 +1793,7 @@ - static - void - s_comm( --int value) -+uintptr_t value) - { - char *name; - char c; -@@ -1826,7 +1846,7 @@ - return; - } - if(symbolP->sy_value != 0){ -- if(symbolP->sy_value != (unsigned long)temp) -+ if(symbolP->sy_value != (uint32_t)temp) - as_bad("Length of .comm \"%s\" is already " TA_DFMT ". Not " - "changed to " TA_DFMT ".", symbolP->sy_name, - symbolP->sy_value, temp); -@@ -1848,7 +1868,7 @@ - static - void - s_desc( --int value) -+uintptr_t value) - { - char *name; - char c; -@@ -1883,14 +1903,13 @@ - } - - /* -- * s_file() implements the pseudo op: -+ * s_app_file() implements the pseudo op: - * .file name [ level_number ] - * the level number is generated by /lib/cpp and is just ignored. - */ --static - void --s_file( --int value) -+s_app_file( -+uintptr_t value) - { - char *s; - int length; -@@ -1931,11 +1950,11 @@ - static - void - s_fill( --int value) -+uintptr_t value) - { -- long temp_repeat; -- long temp_size; -- long temp_fill; -+ int32_t temp_repeat; -+ int32_t temp_size; -+ int32_t temp_fill; - char *p; - - if(get_absolute_expression_and_terminator(&temp_repeat) != ','){ -@@ -1971,8 +1990,9 @@ - else if(temp_size != 0 && - temp_size != 1 && - temp_size != 2 && -- temp_size != 4){ -- as_bad(".fill size must be 0,1,2 or 4, .fill ignored"); -+ temp_size != 4 && -+ temp_size != 8){ -+ as_bad(".fill size must be 0,1,2,4 or 8, .fill ignored"); - temp_size = 0; - } - else if(temp_repeat <= 0){ -@@ -2012,11 +2032,10 @@ - /* - * s_globl() implements the pseudo op: - * .globl name [ , name ] -- * As an iPhone binutils extension, '.global' is accepted too. - */ - void - s_globl( --int value) -+uintptr_t value) - { - char *name; - int c; -@@ -2049,7 +2068,7 @@ - static - void - s_private_extern( --int value) -+uintptr_t value) - { - char *name; - int c; -@@ -2084,11 +2103,11 @@ - static - void - s_indirect_symbol( --int value) -+uintptr_t value) - { - char *name; - int c; -- unsigned long section_type; -+ uint32_t section_type; - - if(!flagseen['k']) - as_fatal("incompatible feature used: .indirect_symbol (must " -@@ -2129,7 +2148,7 @@ - static - void - s_lcomm( --int value) -+uintptr_t value) - { - char *name; - char c; -@@ -2184,7 +2203,7 @@ - bss->frch_last = bss->frch_root; - } - bss->frch_root->fr_address = round(bss->frch_root->fr_address, -- 1 << align); -+ 1 << align); - symbolP->sy_value = bss->frch_root->fr_address; - symbolP->sy_type = N_SECT; - symbolP->sy_other = bss->frch_nsect; -@@ -2194,7 +2213,7 @@ - * If this alignment is larger than any previous alignment then this - * becomes the section's alignment. - */ -- if(bss->frch_section.align < (unsigned long)align) -+ if(bss->frch_section.align < (uint32_t)align) - bss->frch_section.align = align; - } - else -@@ -2208,7 +2227,7 @@ - */ - void - s_line( --int value) -+uintptr_t value) - { - /* - * Assume delimiter is part of expression. BSD4.2 as fails with -@@ -2232,7 +2251,7 @@ - static - void - s_lsym( --int value) -+uintptr_t value) - { - char *name; - char c; -@@ -2293,11 +2312,11 @@ - static - void - s_org( --int value) -+uintptr_t value) - { - segT segment; - expressionS exp; -- long temp_fill; -+ int32_t temp_fill; - char *p; - - /* -@@ -2343,7 +2362,7 @@ - static - void - s_set( --int value) -+uintptr_t value) - { - char *name; - char delim; -@@ -2404,7 +2423,7 @@ - */ - void - s_abs( --int value) -+uintptr_t value) - { - char *name; - char c; -@@ -2449,10 +2468,10 @@ - */ - void - s_space( --int value) -+uintptr_t value) - { -- long temp_repeat; -- long temp_fill; -+ int32_t temp_repeat; -+ int32_t temp_fill; - char *p; - - /* Just like .fill, but temp_size = 1 */ -@@ -2480,7 +2499,7 @@ - } - - static --unsigned long -+uint32_t - s_builtin_section( - const struct builtin_section *s) - { -@@ -2514,20 +2533,19 @@ - static - void - s_section( --int value) -+uintptr_t value) - { - char *segname, *sectname, *typename; - char c, d, e, *p, *q, *r; - struct type_name *type_name; -- unsigned long type, attribute; -+ uint32_t type, attribute; - section_t s; - frchainS *frcP; -- unsigned long sizeof_stub; -+ uint32_t sizeof_stub; - - struct attribute_name *attribute_name; - char *attributename, *sizeof_stub_name, f, g, *t, *u, *endp; - -- SKIP_WHITESPACE(); - segname = input_line_pointer; - do{ - c = *input_line_pointer++ ; -@@ -2576,11 +2594,6 @@ - attribute_name = attribute_names; - sizeof_stub = 0; - if(d == ','){ --#if 0 -- printf("YES optional section type\n"); --#endif -- -- SKIP_WHITESPACE(); - typename = input_line_pointer; - do{ - e = *input_line_pointer++ ; -@@ -2602,12 +2615,7 @@ - * Now see if the optional section attribute is present. - */ - if(e == ','){ --#if 0 -- printf("YES optional section attribute\n"); --#endif -- - do{ -- SKIP_WHITESPACE(); - attributename = input_line_pointer; - do{ - f = *input_line_pointer++ ; -@@ -2633,7 +2641,6 @@ - */ - if(type == S_SYMBOL_STUBS){ - if(f == ','){ -- SKIP_WHITESPACE(); - sizeof_stub_name = input_line_pointer; - do{ - g = *input_line_pointer++ ; -@@ -2690,77 +2697,87 @@ - static - void - s_zerofill( --int value) -+uintptr_t value) - { -- char *segname, *sectname, c, d, *p, *q, *name; -+ char *directive, *segname, *sectname, c, d, *p, *q, *name; - section_t s; - frchainS *frcP; - symbolS *symbolP; -- int size, align; -+ uint64_t size; -+ int align; - -- SKIP_WHITESPACE(); -- segname = input_line_pointer; -- do{ -- c = *input_line_pointer++ ; -- }while(c != ',' && c != '\0' && c != '\n' && c != ' ' && c != '\t'); -- if(c != ','){ -- as_bad("Expected comma after segment-name"); -- ignore_rest_of_line(); -- return; -+ if(value == S_THREAD_LOCAL_ZEROFILL){ -+ directive = "tbss"; -+ frcP = section_new("__DATA", "__thread_bss", value, 0, 0); -+ if(frcP->frch_root == NULL){ -+ frcP->frch_root = xmalloc(SIZEOF_STRUCT_FRAG); -+ frcP->frch_last = frcP->frch_root; -+ memset(frcP->frch_root, '\0', SIZEOF_STRUCT_FRAG); -+ } - } -- p = input_line_pointer - 1; -+ else{ -+ directive = "zerofill"; -+ segname = input_line_pointer; -+ do{ -+ c = *input_line_pointer++ ; -+ }while(c != ' ' && c != ',' && c != '\0' && c != '\n'); -+ p = input_line_pointer - 1; -+ while(c == ' '){ -+ c = *input_line_pointer++ ; -+ } -+ if(c != ','){ -+ as_bad("Expected comma after segment-name"); -+ ignore_rest_of_line(); -+ return; -+ } - -- SKIP_WHITESPACE(); -- sectname = input_line_pointer; -- do{ -- d = *input_line_pointer++ ; -- }while(d != ',' && d != '\0' && d != '\n' && c != ' ' && c != '\t'); -- if(p + 1 == input_line_pointer){ -- as_bad("Expected section-name after comma"); -- ignore_rest_of_line(); -- return; -- } -- q = input_line_pointer - 1; -+ SKIP_WHITESPACE(); -+ sectname = input_line_pointer; -+ do{ -+ d = *input_line_pointer++ ; -+ }while(d != ',' && d != '\0' && d != '\n'); -+ if(p + 1 == input_line_pointer){ -+ as_bad("Expected section-name after comma"); -+ ignore_rest_of_line(); -+ return; -+ } -+ q = input_line_pointer - 1; - -- *p = 0; -- if(strlen(segname) > sizeof(s.segname)){ -- as_bad("segment-name: %s too long (maximum %ld characters)", -- segname, sizeof(s.segname)); -- ignore_rest_of_line(); -- *p = c; -- return; -- } -+ *p = 0; -+ if(strlen(segname) > sizeof(s.segname)){ -+ as_bad("segment-name: %s too long (maximum %ld characters)", -+ segname, sizeof(s.segname)); -+ ignore_rest_of_line(); -+ *p = c; -+ return; -+ } - -- *q = 0; -- if(strlen(sectname) > sizeof(s.sectname)){ -- as_bad("section-name: %s too long (maximum %ld characters)", -- sectname, sizeof(s.sectname)); -- ignore_rest_of_line(); -+ *q = 0; -+ if(strlen(sectname) > sizeof(s.sectname)){ -+ as_bad("section-name: %s too long (maximum %ld characters)", -+ sectname, sizeof(s.sectname)); -+ ignore_rest_of_line(); -+ *p = c; -+ *q = d; -+ return; -+ } -+ -+ frcP = section_new(segname, sectname, value, 0, 0); -+ if(frcP->frch_root == NULL){ -+ frcP->frch_root = xmalloc(SIZEOF_STRUCT_FRAG); -+ frcP->frch_last = frcP->frch_root; -+ memset(frcP->frch_root, '\0', SIZEOF_STRUCT_FRAG); -+ } - *p = c; - *q = d; -- return; -- } -- -- frcP = section_new(segname, sectname, S_ZEROFILL, 0, 0); -- if(frcP->frch_root == NULL){ -- frcP->frch_root = xmalloc(SIZEOF_STRUCT_FRAG); -- frcP->frch_last = frcP->frch_root; -- memset(frcP->frch_root, '\0', SIZEOF_STRUCT_FRAG); -+ /* -+ * If this is the end of the line all that was wanted was to create -+ * the the section which is now done, so return. -+ */ -+ if(d != ',') -+ return; - } -- *p = c; -- *q = d; -- /* -- * If this is the end of the line all that was wanted was to create the -- * the section which is now done, so return. -- */ -- if(d != ',') -- return; -- --#if 0 -- printf("YES optional extra attribute\n"); --#endif - -- SKIP_WHITESPACE(); - if(*input_line_pointer == '"') - name = input_line_pointer + 1; - else -@@ -2774,20 +2791,14 @@ - ignore_rest_of_line(); - return; - } -- SKIP_WHITESPACE(); - input_line_pointer ++; -- if((size = get_absolute_expression()) < 0){ -- as_bad("zerofill size (%d.) <0! Ignored.", size); -+ if((int)(size = get_absolute_expression()) < 0){ -+ as_bad("%s size (%lld.) <0! Ignored.", directive, size); - ignore_rest_of_line(); - return; - } - align = 0; -- SKIP_WHITESPACE(); - if(*input_line_pointer == ','){ --#if 0 -- printf("YES optional align attribute\n"); --#endif -- - input_line_pointer++; - align = get_absolute_expression(); - if(align > MAX_ALIGNMENT){ -@@ -2802,7 +2813,7 @@ - * If this alignment is larger than any previous alignment then this - * becomes the section's alignment. - */ -- if(frcP->frch_section.align < (unsigned long)align) -+ if(frcP->frch_section.align < (uint32_t)align) - frcP->frch_section.align = align; - } - *p = 0; -@@ -2811,7 +2822,7 @@ - - if((symbolP->sy_type & N_TYPE) == N_UNDF && symbolP->sy_value == 0){ - frcP->frch_root->fr_address = round(frcP->frch_root->fr_address, -- 1 << align); -+ 1 << align); - symbolP->sy_value = frcP->frch_root->fr_address; - symbolP->sy_type = N_SECT | (symbolP->sy_type & (N_EXT | N_PEXT)); - symbolP->sy_other = frcP->frch_nsect; -@@ -2831,7 +2842,7 @@ - static - void - s_reference( --int value) -+uintptr_t value) - { - char *name; - char c; -@@ -2859,7 +2870,7 @@ - static - void - s_lazy_reference( --int value) -+uintptr_t value) - { - char *name; - char c; -@@ -2893,7 +2904,7 @@ - static - void - s_weak_reference( --int value) -+uintptr_t value) - { - char *name; - char c; -@@ -2926,7 +2937,7 @@ - static - void - s_weak_definition( --int value) -+uintptr_t value) - { - char *name; - char c; -@@ -2942,24 +2953,47 @@ - - *p = 0; - symbolP = symbol_find_or_make(name); -- if((symbolP->sy_type & N_TYPE) != N_UNDF && -- ((symbolP->sy_type & N_TYPE) != N_SECT || -- is_section_coalesced(symbolP->sy_other) == FALSE)) -- as_fatal("symbol: %s can't be a weak_definition (currently " -- "only supported in section of type coalesced)", name); - symbolP->sy_desc |= N_WEAK_DEF; - *p = c; - demand_empty_rest_of_line(); - } - - /* -+ * s_weak_def_can_be_hidden() implements the pseudo op: -+ * .weak_def_can_be_hidden name -+ */ -+static -+void -+s_weak_def_can_be_hidden( -+uintptr_t value) -+{ -+ char *name; -+ char c; -+ char *p; -+ symbolS *symbolP; -+ -+ if(* input_line_pointer == '"') -+ name = input_line_pointer + 1; -+ else -+ name = input_line_pointer; -+ c = get_symbol_end(); -+ p = input_line_pointer; -+ -+ *p = 0; -+ symbolP = symbol_find_or_make(name); -+ symbolP->sy_desc |= (N_WEAK_DEF | N_WEAK_REF); -+ *p = c; -+ demand_empty_rest_of_line(); -+} -+ -+/* - * s_no_dead_strip() implements the pseudo op: - * .no_dead_strip name - */ - static - void - s_no_dead_strip( --int value) -+uintptr_t value) - { - char *name; - char c; -@@ -2981,13 +3015,41 @@ - } - - /* -+ * s_symbol_resolver() implements the pseudo op: -+ * .symbol_resolver name -+ */ -+static -+void -+s_symbol_resolver( -+uintptr_t value) -+{ -+ char *name; -+ char c; -+ char *p; -+ symbolS *symbolP; -+ -+ if(* input_line_pointer == '"') -+ name = input_line_pointer + 1; -+ else -+ name = input_line_pointer; -+ c = get_symbol_end(); -+ p = input_line_pointer; -+ -+ *p = 0; -+ symbolP = symbol_find_or_make(name); -+ symbolP->sy_desc |= N_SYMBOL_RESOLVER; -+ *p = c; -+ demand_empty_rest_of_line(); -+} -+ -+/* - * s_include() implements the pseudo op: - * .include "filename" - */ - static - void - s_include( --int value) -+uintptr_t value) - { - char *filename; - int length; -@@ -3033,7 +3095,8 @@ - - /* we simply ignore the rest of this statement */ - void --s_ignore (int arg ATTRIBUTE_UNUSED) -+s_ignore( -+uintptr_t arg ATTRIBUTE_UNUSED) - { - totally_ignore_line (); - } -@@ -3080,14 +3143,14 @@ - static - void - stab( --int what) /* d == .stabd, n == .stabn, and s == .stabs */ -+uintptr_t what) /* d == .stabd, n == .stabn, and s == .stabs */ - { - symbolS *symbolP; - char *string; - int saved_type; - int length; - int goof; /* TRUE if we have aborted. */ -- long longint; -+ int32_t longint; - - saved_type = 0; - symbolP = NULL; -@@ -3128,7 +3191,7 @@ - break; - - default: -- BAD_CASE( what ); -+ BAD_CASE( (int)what ); - break; - } - if(get_absolute_expression_and_terminator(&longint) == ','){ -@@ -3190,7 +3253,6 @@ - *(old ->> May set need_pass_2 == TRUE. <<-- commented out by GNU below it - * uses symbolP->sy_forward = exp.X_add_symbol;) - */ --static - void - pseudo_set( - symbolS *symbolP) -@@ -3232,22 +3294,36 @@ - expression = xmalloc(sizeof(expressionS)); - *expression = exp; - symbolP->expression = expression; -- - } - else{ - exp.X_add_number += exp.X_add_symbol->sy_value - - exp.X_subtract_symbol->sy_value; - } - } -+ else if(exp.X_add_symbol && -+ exp.X_subtract_symbol == NULL && -+ exp.X_add_symbol->expression != NULL){ -+ expressionS *expression; -+ -+ expression = xmalloc(sizeof(expressionS)); -+ memcpy(expression, exp.X_add_symbol->expression, -+ sizeof(expressionS)); -+ symbolP->expression = expression; -+ } - else - as_bad("Complex expression. Absolute segment assumed." ); -- /* fall through */ -+ symbolP->sy_type = N_ABS | ext; -+ symbolP->sy_other = 0; /* NO_SECT */ -+ symbolP->sy_value = exp.X_add_number; -+ symbolP->sy_frag = &zero_address_frag; -+ break; - - case SEG_ABSOLUTE: - symbolP->sy_type = N_ABS | ext; - symbolP->sy_other = 0; /* NO_SECT */ - symbolP->sy_value = exp.X_add_number; - symbolP->sy_frag = &zero_address_frag; -+ symbolP->expression = NULL; - break; - - case SEG_SECT: -@@ -3288,7 +3364,7 @@ - */ - void - cons( --int nbytes) /* nbytes == 1 for .byte, 2 for .word, 4 for .long, 8 for .quad */ -+uintptr_t nbytes) /* nbytes == 1 for .byte, 2 for .word, 4 for .long, 8 for .quad */ - { - char c; - signed_expr_t -@@ -3299,7 +3375,11 @@ - char *p; /* points into the frag */ - segT segment; - expressionS exp; -+#ifndef TC_CONS_FIX_NEW -+ fixS *fixP; -+#endif - -+ memset(&exp, '\0', sizeof(exp)); - /* - * Input_line_pointer -> 1st char after pseudo-op-code and could legally - * be a end-of-line. (Or, less legally an eof - which we cope with.) -@@ -3349,9 +3429,9 @@ - */ - if(exp.X_add_number > 0 && - (((LITTLENUM_NUMBER_OF_BITS * exp.X_add_number) / 8) <= -- sizeof(long long))){ -+ sizeof(int64_t))){ - int i; -- long long sum; -+ int64_t sum; - - sum = 0; - for(i = 0; i < exp.X_add_number; ++i) -@@ -3363,7 +3443,7 @@ - { - as_bad("%s number illegal. Absolute 0 assumed.", - exp.X_add_number > 0 ? "Bignum" : "Floating-Point"); -- md_number_to_chars(p, (long)0, nbytes); -+ md_number_to_chars(p, (int32_t)0, nbytes); - } - break; - -@@ -3380,6 +3460,7 @@ - /* Leading bits contain both 0s & 1s. */ - as_bad("Value 0x%llx truncated to 0x%llx.", get, use); - } -+ dwarf2_emit_insn(nbytes); - /* put bytes in right order. */ - md_number_to_chars(p, use, nbytes); - break; -@@ -3393,7 +3474,7 @@ - nbytes, - &exp); - #else -- fix_new(frag_now, -+ fixP = fix_new(frag_now, - p - frag_now->fr_literal, - nbytes, - exp.X_add_symbol, -@@ -3402,6 +3483,12 @@ - 0, - 0, - 0); -+ /* -+ * If we have the special assembly time constant expression -+ * of the difference of two symbols defined in the same section -+ * then divided by exactly 2 mark the fix to indicate this. -+ */ -+ fixP->fx_sectdiff_divide_by_two = exp.X_sectdiff_divide_by_two; - #endif - break; - -@@ -3440,11 +3527,11 @@ - */ - void - big_cons( --int nbytes) /* 8 == .quad, 16 == .octa ... */ -+uintptr_t nbytes) /* 8 == .quad, 16 == .octa ... */ - { - char c; /* input_line_pointer -> c. */ - int radix; -- long length;/* Number of chars in an object. */ -+ int32_t length;/* Number of chars in an object. */ - int digit; /* Value of 1 digit. */ - int carry; /* For multi-precision arithmetic. */ - int work; /* For multi-precision arithmetic. */ -@@ -3512,7 +3599,7 @@ - as_bad("Most significant bits truncated in integer constant."); - } - else{ -- long leading_zeroes; -+ int32_t leading_zeroes; - - for(leading_zeroes = nbytes - length; - leading_zeroes; -@@ -3547,7 +3634,7 @@ - grow_bignum( - void) - { -- long length; -+ int32_t length; - - bignum_high++; - if(bignum_high >= bignum_limit) -@@ -3582,7 +3669,7 @@ - */ - void - float_cons( --int float_type) /* 'f':.ffloat ... 'F':.float ... */ -+uintptr_t float_type) /* 'f':.ffloat ... 'F':.float ... */ - { - char *p; - char c; -@@ -3637,6 +3724,129 @@ - demand_empty_rest_of_line(); - } - -+static void -+emit_leb128_expr (expressionS *exp, int sign) -+{ -+ segT op = exp->X_op; -+#ifdef notyet -+ unsigned int nbytes; -+#endif -+ -+ if (op == O_absent) -+ { -+ as_warn (_("zero assumed for missing expression")); -+ exp->X_add_number = 0; -+ op = O_constant; -+ } -+ else if (op == O_big && exp->X_add_number <= 0) -+ { -+ as_bad (_("floating point number invalid")); -+ exp->X_add_number = 0; -+ op = O_constant; -+ } -+#ifdef notyet -+ else if (op == O_register) -+ { -+ as_warn (_("register value used as expression")); -+ op = O_constant; -+ } -+ else if (op == O_constant -+ && sign -+ && (exp->X_add_number < 0) != !exp->X_unsigned) -+ { -+ /* We're outputting a signed leb128 and the sign of X_add_number -+ doesn't reflect the sign of the original value. Convert EXP -+ to a correctly-extended bignum instead. */ -+ convert_to_bignum (exp); -+ op = O_big; -+ } -+ -+ /* Let check_eh_frame know that data is being emitted. nbytes == -1 is -+ a signal that this is leb128 data. It shouldn't optimize this away. */ -+ nbytes = (unsigned int) -1; -+ if (check_eh_frame (exp, &nbytes)) -+ abort (); -+ -+ /* Let the backend know that subsequent data may be byte aligned. */ -+#ifdef md_cons_align -+ md_cons_align (1); -+#endif -+#endif /* notyet */ -+ -+ if (op == O_constant) -+ { -+ /* If we've got a constant, emit the thing directly right now. */ -+ -+ valueT value = exp->X_add_number; -+ int size; -+ char *p; -+ -+ size = sizeof_leb128 (value, sign); -+ p = frag_more (size); -+ output_leb128 (p, value, sign); -+ } -+#ifdef notyet -+ else if (op == O_big) -+ { -+ /* O_big is a different sort of constant. */ -+ -+ int size; -+ char *p; -+ -+ size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign); -+ p = frag_more (size); -+ output_big_leb128 (p, generic_bignum, exp->X_add_number, sign); -+ } -+#endif /* notyet */ -+ else -+ { -+ /* Otherwise, we have to create a variable sized fragment and -+ resolve things later. */ -+ -+#ifdef OLD -+ frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign, -+ make_expr_symbol (exp), 0, (char *) NULL); -+#else -+ symbolS *sym; -+ expressionS *expression; -+ -+ sym = symbol_temp_new(exp->X_add_symbol->sy_other /* GUESS */, 0, NULL); -+ expression = xmalloc(sizeof(expressionS)); -+ *expression = *exp; -+ sym->expression = expression; -+ sym->sy_frag = &zero_address_frag; -+ frag_var (rs_leb128, sizeof_leb128 ( ((valueT) (~(valueT) 0) >> 1), 0), 0, sign, -+ sym, 0, (char *) NULL); -+ frchain_now->has_rs_leb128s = TRUE; -+#endif -+ -+ } -+} -+ -+/* Parse the .sleb128 and .uleb128 pseudos. */ -+ -+static -+void -+s_leb128( -+uintptr_t sign) -+{ -+ expressionS exp; -+ -+#ifdef md_flush_pending_output -+ md_flush_pending_output (); -+#endif -+ -+ do -+ { -+ expression (&exp); -+ emit_leb128_expr (&exp, sign); -+ } -+ while (*input_line_pointer++ == ','); -+ -+ input_line_pointer--; -+ demand_empty_rest_of_line (); -+} -+ - /* - * stringer() - * -@@ -3647,7 +3857,7 @@ - */ - void - stringer( --int append_zero) /* 0: don't append '\0', else 1 */ -+uintptr_t append_zero) /* 0: don't append '\0', else 1 */ - { - int c; - -@@ -3699,7 +3909,7 @@ - void) - { - int c; -- long number, i; -+ int32_t number, i; - - c = *input_line_pointer++; - /* make sure the 0xff char is not returned as -1 */ -@@ -3866,7 +4076,7 @@ - static - char /* return terminator */ - get_absolute_expression_and_terminator( --long *val_pointer) /* return value of expression */ -+int32_t *val_pointer) /* return value of expression */ - { - *val_pointer = get_absolute_expression(); - return(*input_line_pointer++); -@@ -3878,7 +4088,6 @@ - * Like demand_copy_string, but return NULL if the string contains any '\0's. - * Give a warning if that happens. - */ --static - char * - demand_copy_C_string( - int *len_pointer) -@@ -3899,16 +4108,6 @@ - return(s); - } - --static int is_identifier_char(char c) { -- return -- (c >= 'a' && c <= 'z') || -- (c >= 'A' && c <= 'Z') || -- (c >= '0' && c <= '9') || -- (c == '_' || c == '.') || -- (c == '=' || c == '$') || -- (c == '#'); --} -- - /* - * demand_copy_string() - * -@@ -3935,23 +4134,22 @@ - { - input_line_pointer++; /* Skip opening quote. */ - while((c = next_char_of_string()) >= 0){ -- obstack_1grow(¬es, c); -+ (void)(obstack_1grow(¬es, c)); - len++; - } -+ /* -+ * This next line is so demand_copy_C_string will return a null -+ * termanated string. -+ */ -+ (void)(obstack_1grow(¬es, '\0')); -+ retval = obstack_finish(¬es); - } - else{ -- while (is_identifier_char(*input_line_pointer)) { -- obstack_1grow(¬es, *input_line_pointer++); -- len++; -- } -+ as_bad("Missing string"); -+ retval = NULL; -+ ignore_rest_of_line(); - } -- /* -- * This next line is so demand_copy_C_string will return a null -- * termanated string. -- */ -- obstack_1grow(¬es, '\0'); - *lenP = len; -- retval = obstack_finish(¬es); - return(retval); - } - -@@ -4031,7 +4229,7 @@ - static - void - s_if( --int value) -+uintptr_t value) - { - if(if_depth >= MAX_IF_DEPTH) - as_fatal("You can't nest if's more than %d levels deep", -@@ -4047,105 +4245,6 @@ - } - } - --/* iPhone binutils extension: .ifc assembles if the two strings are the same */ --void s_ifnc(int value) --{ -- char *ptr1, *ptr2; -- int len1, len2; -- -- if (if_depth >= MAX_IF_DEPTH) -- as_fatal("Maximum if nesting level reached"); -- last_states[if_depth++] = the_cond_state; -- the_cond_state.the_cond = if_cond; -- -- if (the_cond_state.ignore) -- totally_ignore_line(); -- else { -- ptr1 = demand_copy_string(&len1); -- -- SKIP_WHITESPACE(); -- if (*input_line_pointer != ',') -- as_bad(".ifnc needs two strings separated by a comma (',')"); -- else -- input_line_pointer++; -- -- ptr2 = demand_copy_string(&len2); -- -- the_cond_state.cond_met = (len1 != len2 || strncmp(ptr1, ptr2, len1)); -- the_cond_state.ignore = !the_cond_state.cond_met; -- demand_empty_rest_of_line(); -- } --} -- --/* iPhone binutils extension: .ifc assembles if the two strings are the same */ --void s_ifc(int value) --{ -- char *ptr1, *ptr2; -- int len1, len2; -- -- if (if_depth >= MAX_IF_DEPTH) -- as_fatal("Maximum if nesting level reached"); -- last_states[if_depth++] = the_cond_state; -- the_cond_state.the_cond = if_cond; -- -- if (the_cond_state.ignore) -- totally_ignore_line(); -- else { -- ptr1 = demand_copy_string(&len1); -- -- SKIP_WHITESPACE(); -- if (*input_line_pointer != ',') -- as_bad(".ifc needs two strings separated by a comma (',')"); -- else -- input_line_pointer++; -- -- ptr2 = demand_copy_string(&len2); -- -- the_cond_state.cond_met = (len1 == len2 && !strncmp(ptr1, ptr2, len1)); -- the_cond_state.ignore = !the_cond_state.cond_met; -- demand_empty_rest_of_line(); -- } --} -- --/* iPhone binutils extension: .ifdef assembles if the given symbol is defined. */ --void s_ifdef(int value) --{ -- /* Points to name of symbol. */ -- char *name; -- /* Points to symbol. */ -- symbolS *symbolP; -- char c; -- -- if (if_depth >= MAX_IF_DEPTH) -- as_fatal("Maximum if nesting level reached"); -- last_states[if_depth++] = the_cond_state; -- the_cond_state.the_cond = if_cond; -- -- if (the_cond_state.ignore) -- totally_ignore_line(); -- else { -- /* Leading whitespace is part of operand. */ -- SKIP_WHITESPACE (); -- name = input_line_pointer; -- -- if (!is_name_beginner (*name)) -- { -- as_bad (_("invalid identifier for \".ifdef\"")); -- ignore_rest_of_line (); -- return; -- } -- -- c = get_symbol_end (); -- symbolP = symbol_find (name); -- *input_line_pointer = c; -- -- the_cond_state.cond_met = (value == 0) == (symbolP != NULL && S_IS_DEFINED (symbolP)); -- the_cond_state.ignore = !the_cond_state.cond_met; -- -- demand_empty_rest_of_line (); -- } --} -- - /* - * s_elseif() implements the pseudo op: - * .elseif expression -@@ -4154,7 +4253,7 @@ - static - void - s_elseif( --int value) -+uintptr_t value) - { - int last_ignore_state; - -@@ -4186,7 +4285,7 @@ - static - void - s_else( --int value) -+uintptr_t value) - { - int last_ignore_state; - -@@ -4213,7 +4312,7 @@ - static - void - s_endif( --int value) -+uintptr_t value) - { - if((the_cond_state.the_cond == no_cond) || (if_depth == 0)) - as_fatal("Encountered a .endif that doesn't follow a .if or .else"); -@@ -4245,7 +4344,7 @@ - static - void - s_macros_on( --int value) -+uintptr_t value) - { - macros_on = TRUE; - demand_empty_rest_of_line(); -@@ -4257,106 +4356,34 @@ - */ - void - s_macros_off( --int value) -+uintptr_t value) - { - macros_on = FALSE; - demand_empty_rest_of_line(); - } - --int is_eol(char c) --{ -- return (c == '\r' || c == '\n' || c == '\0'); --} -- --int is_ignorable_ws(char c) --{ -- return (c == ' ' || c == '\t'); --} -- - /* - * s_macro() implements the pseudo op: - * .macro macro_name - * that defines a macro. -- * -- * iPhone binutils local: support the GAS 2.17-style macro definitions - */ - void - s_macro( --int value) -+uintptr_t value) - { -- char *ptr; -- int len; -- struct macro_arg *arg; -+ int c; -+ pseudo_typeS *pop; - - if(macro_name) - as_bad("Can't define a macro inside another macro definition"); - else{ -- while (is_ignorable_ws(*input_line_pointer)) -- input_line_pointer++; -- ptr = input_line_pointer; -- while (is_part_of_name(*input_line_pointer)) -- input_line_pointer++; -- len = input_line_pointer - ptr; -- macro_name = malloc(len + 1); -- strncpy(macro_name, ptr, len); -- macro_name[len] = '\0'; -- -- macro_info = (struct macro_info *)malloc(sizeof(struct macro_info)); -- macro_info->name = macro_name; -- macro_info->contents = NULL; -- macro_info->arg_count = 0; -- macro_info->args = (struct macro_arg **)malloc(sizeof(struct macro_arg -- *) * 32); /* TODO: don't have a hard arg limit */ -- -- /* Grab the arguments. */ -- while (1) { -- while (is_ignorable_ws(*input_line_pointer) || *input_line_pointer -- == ',') -- input_line_pointer++; -- ptr = input_line_pointer; -- while (is_part_of_name(*input_line_pointer) || *input_line_pointer -- == '=') -- input_line_pointer++; -- len = input_line_pointer - ptr; -- -- if (len <= 0) -- break; -- -- arg = (struct macro_arg *)malloc(sizeof(struct macro_arg)); -- arg->name = malloc(len + 1); -- strncpy(arg->name, ptr, len); -- arg->name[len] = '\0'; -- arg->default_value = arg->name; -- strsep(&(arg->default_value), "="); -- -- if (!(arg->default_value)) -- arg->default_value = ""; -- -- macro_info->args[(macro_info->arg_count)++] = arg; -- } -- -- macro_info->new_style = macro_info->arg_count > 0; -- --#if 0 -- printf("macro %s:\n", macro_info->name); -- int i; -- for (i = 0; i < macro_info->arg_count; i++) -- printf("arg %d: name %s, default %s\n", i, -- macro_info->args[i]->name, macro_info->args[i]->default_value); --#endif -- --#if 0 -- int c; -- pseudo_typeS *pop; -- -- *input_line_pointer++; -- -+ SKIP_WHITESPACE(); - while(is_part_of_name(c = *input_line_pointer ++)) -- obstack_1grow (¯os, c); -- obstack_1grow(¯os, '\0'); -+ (void)(obstack_1grow (¯os, c)); -+ (void)(obstack_1grow(¯os, '\0')); - --input_line_pointer; - macro_name = obstack_finish(¯os); -- if(macro_name == "") -+ if(macro_name == NULL) - as_bad("Missing name of macro"); - if(*macro_name == '.'){ - pop = (pseudo_typeS *)hash_find(po_hash, macro_name + 1); -@@ -4364,9 +4391,7 @@ - as_bad("Pseudo-op name: %s can't be a macro name", - macro_name); - } --#endif - } -- - totally_ignore_line(); - } - -@@ -4377,7 +4402,7 @@ - */ - void - s_endmacro( --int value) -+uintptr_t value) - { - const char *errorString; - -@@ -4386,83 +4411,16 @@ - ignore_rest_of_line(); - } - else{ -- obstack_1grow(¯os, '\0'); -- -- macro_info->contents = obstack_finish(¯os); -- -- errorString = hash_insert(ma_hash, macro_name, macro_info); -+ (void)(obstack_1grow(¯os, '\0')); -+ errorString = hash_insert(ma_hash, macro_name, -+ obstack_finish(¯os)); - if(errorString != NULL && *errorString) -- as_bad("The macro named \"%s\" is already defined", -+ as_warn("The macro named \"%s\" is already defined", - macro_name); - macro_name = NULL; - } - } - --void s_rept(int value) --{ -- if (rept_recording) -- as_bad("Nested repetition ('.rept') isn't allowed"); -- else { -- rept_times = strtol(input_line_pointer, &input_line_pointer, 10); -- -- rept_recording = 1; -- rept_record_start = input_line_pointer; -- } -- -- totally_ignore_line(); --} -- --void s_endr(int value) --{ -- char *buffer, *last_buffer_limit, *last_input_line_pointer, *new_buf, *ptr; -- int i, last_count_lines, len; -- -- if (!rept_recording) { -- as_bad("'.endr' found, but I wasn't instructed to repeat anything"); -- return; -- } -- -- ptr = input_line_pointer; -- while (*ptr != '.') -- ptr--; /* back up to before this op so it isn't parsed */ -- ptr--; -- -- len = ptr - rept_record_start; -- new_buf = malloc(len + 2); -- strncpy(new_buf, rept_record_start, len); -- new_buf[len] = '\n'; -- new_buf[len+1] = '\0'; -- --#if 0 -- printf("new buf is: %s\n", new_buf); --#endif -- -- last_buffer_limit = buffer_limit; -- last_count_lines = count_lines; -- last_input_line_pointer = input_line_pointer; -- -- /* Note: we start at 1 because one instance will have already been -- * assembled at this point. */ -- for (i = 1; i < rept_times; i++) { -- buffer_limit = new_buf + len + 1; -- buffer = new_buf; -- count_lines = FALSE; -- -- #ifdef PPC -- if(flagseen[(int)'p'] == TRUE) -- ppcasm_parse_a_buffer(buffer); -- else -- #endif /* PPC */ -- parse_a_buffer(buffer); -- } -- -- buffer_limit = last_buffer_limit; -- count_lines = last_count_lines; -- input_line_pointer = last_input_line_pointer; -- -- rept_recording = 0; --} -- - /* - * macro_begin() initializes macros. - */ -@@ -4488,7 +4446,7 @@ - do{ - c = *char_pointer ++; - know(c != '\0'); -- obstack_1grow(¯os, c); -+ (void)(obstack_1grow(¯os, c)); - }while((c != ':') && !(is_end_of_line(c))); - if(char_pointer > input_line_pointer) - input_line_pointer = char_pointer; -@@ -4496,27 +4454,20 @@ - - /* - * expand_macro() is called to expand macros. -- * -- * iPhone binutils local: lots of additions to deal with GAS 2.17-style macros. - */ - static - void - expand_macro( --struct macro_info *info) -+char *macro_contents) - { -- char *macro_contents; - char *buffer; -- char *ptr, *arg_buf, *arg_val_ptr; - char c; - int index, nargs; - char *last_buffer_limit; - int last_count_lines; -- int named_invocation, len, i, which_arg; - char *last_input_line_pointer; - char *arguments [10]; /* at most 10 arguments, each is substituted */ - -- macro_contents = info->contents; -- - if(macro_depth >= MAX_MACRO_DEPTH) - as_fatal("You can't nest macros more than %d levels deep", - MAX_MACRO_DEPTH); -@@ -4524,198 +4475,80 @@ - - /* copy each argument to a object in the macro obstack */ - nargs = 0; -- -- memset(arguments, '\0', sizeof(char *) * 10); -- -- /* iPhone binutils new: parse new-style arguments */ -- if (info->new_style) { -- /* First, determine if it's a named-argument style invocation or a -- * normal invocation. The presence of '=' should be good enough to -- * determine which it is. */ -- named_invocation = 0; -- ptr = input_line_pointer; -- while (is_identifier_char(*ptr)) { -- if (*ptr == '=') { -- named_invocation = 1; -- break; -- } -- ptr++; -- } -- -- index = 0; -- -- SKIP_WHITESPACE(); -- -- /* Ok, now parse each argument. */ -- while (1) { -- int length; -- char *value = demand_copy_string(&length); -- -- if (named_invocation) { -- if (*input_line_pointer++ != '=') { -- as_bad("In a named-argument-style macro invocation, " -- "all of the arguments must be specified in the " -- "named-argument style, but one or more weren't"); -- break; -- } -- -- /* We've parsed it fine, now just find which argument the -- * user meant. */ -- which_arg = -1; -- for (i = 0; i < info->arg_count; i++) { -- if (!strcmp(value, info->args[i]->name)) { -- which_arg = i; -- break; -- } -- } -- -- if (which_arg == -1) { -- as_bad("'%s' doesn't name an argument of the macro " -- "'%s'", arg_buf, info->name); -- break; -- } -- -- arguments[which_arg] = demand_copy_string(&length); -- } else { -- /* If not a named invocation, it's simple. */ -- arguments[index++] = value; -- } -- -- if (*input_line_pointer == ',') { -- ++input_line_pointer; -- SKIP_WHITESPACE(); -- continue; -- } else if ( -- !is_end_of_line(*input_line_pointer) && -- !is_ignorable_ws(*input_line_pointer) -- ) { -- as_bad("invalid macro expansion argument character (%c)", *input_line_pointer); -- } -- -- SKIP_WHITESPACE(); -- -- if (is_end_of_line(*input_line_pointer)) -- break; -- } -- -- nargs = info->arg_count; -- -- /* Fill in blank args with default values. */ -- for (i = 0; i < nargs; i++) -- if (arguments[i] == NULL || arguments[i][0] == '\0') -- arguments[i] = info->args[i]->default_value; -- } else { -- /* Fall back to the old-style arguments - note that it doesn't matter -- * which we use for a zero-argument macro. */ -- for(index = 0; index < 10; index ++){ -- if(*input_line_pointer == ' ') -- ++input_line_pointer; -- know(*input_line_pointer != ' '); -- c = *input_line_pointer; -- if(is_end_of_line(c)) -- arguments[index] = NULL; -- else{ -- int parenthesis_depth = 0; -- do{ -- c = *input_line_pointer++; -- if(parenthesis_depth){ -- if(c == ')') -- parenthesis_depth --; -- } -- else{ -- if(c == '(') -- parenthesis_depth ++; -- else -- if(is_end_of_line(c) || -- (c == ' ') || (c == ',')) -- break; -- } -- know(c != '\0'); -- if(is_end_of_line(c)) -- as_bad("mismatched parenthesis"); -- obstack_1grow(¯os, c); -- }while(1); -- obstack_1grow(¯os, '\0'); -- arguments[index] = obstack_finish(¯os); -- nargs++; -- if(is_end_of_line(c)) -- --input_line_pointer; -- else if(c == ' ') -- if(*input_line_pointer == ',') -- input_line_pointer++; -- } -- } -- if(!is_end_of_line(c)){ -- as_bad("More than 10 arguments not allowed for macros"); -- ignore_rest_of_line(); -- } -- } -+ for(index = 0; index < 10; index ++){ -+ if(*input_line_pointer == ' ') -+ ++input_line_pointer; -+ know(*input_line_pointer != ' '); -+ c = *input_line_pointer; -+ if(is_end_of_line(c)) -+ arguments[index] = NULL; -+ else{ -+ int parenthesis_depth = 0; -+ do{ -+ SKIP_WHITESPACE(); -+ c = *input_line_pointer++; -+ if(parenthesis_depth){ -+ if(c == ')') -+ parenthesis_depth --; -+ } -+ else{ -+ if(c == '(') -+ parenthesis_depth ++; -+ else -+ if(is_end_of_line(c) || -+ (c == ' ') || (c == ',')) -+ break; -+ } -+ know(c != '\0'); -+ if(is_end_of_line(c)) -+ as_bad("mismatched parenthesis"); -+ (void)(obstack_1grow(¯os, c)); -+ }while(1); -+ (void)(obstack_1grow(¯os, '\0')); -+ arguments[index] = obstack_finish(¯os); -+ nargs++; -+ if(is_end_of_line(c)) -+ --input_line_pointer; -+ else if(c == ' ') -+ if(*input_line_pointer == ',') -+ input_line_pointer++; -+ } -+ } -+ if(!is_end_of_line(c)){ -+ as_bad("More than 10 arguments not allowed for macros"); -+ ignore_rest_of_line(); -+ } - /* - * Build a buffer containing the macro contents with arguments - * substituted - */ -- obstack_1grow(¯os, '\n'); -- -- while((c = *macro_contents++)){ -- if (c == '\\') { -- if (*macro_contents == '\\') -- macro_contents++; -- else { -- ptr = macro_contents; -- while (is_part_of_name(*ptr)) -- ptr++; -- -- index = -1; -- for (i = 0; i < info->arg_count; i++) { -- if (!strncmp(macro_contents, info->args[i]->name, -- ptr - macro_contents)) { -- index = i; -- break; -- } -- } -- -- macro_contents = ptr; -- -- if (index == -1) -- as_bad("Undeclared macro argument"); -- else { -- last_input_line_pointer = macro_contents; -- macro_contents = arguments[index]; -- if (macro_contents) { -- while ((c = *(macro_contents++))) -- obstack_1grow(¯os, c); -- } -- macro_contents = last_input_line_pointer; -- continue; -- } -- } -- } -- else if(c == '$'){ -- if(*macro_contents == '$'){ -- macro_contents++; -- } -- else if((*macro_contents >= '0') && (*macro_contents <= '9')){ -- index = *macro_contents++ - '0'; -- last_input_line_pointer = macro_contents; -- macro_contents = arguments[index]; -- if(macro_contents){ -- while ((c = * macro_contents ++)) -- obstack_1grow (¯os, c); -- } -- macro_contents = last_input_line_pointer; -- continue; -- } -- else if (*macro_contents == 'n'){ -- macro_contents++ ; -- obstack_1grow(¯os, nargs + '0'); -- continue; -- } -- } -- obstack_1grow (¯os, c); -- } -- -- obstack_1grow (¯os, '\n'); -- obstack_1grow (¯os, '\0'); -+ (void)(obstack_1grow(¯os, '\n')); -+ while((c = *macro_contents++)){ -+ if(c == '$'){ -+ if(*macro_contents == '$'){ -+ macro_contents++; -+ } -+ else if((*macro_contents >= '0') && (*macro_contents <= '9')){ -+ index = *macro_contents++ - '0'; -+ last_input_line_pointer = macro_contents; -+ macro_contents = arguments[index]; -+ if(macro_contents){ -+ while ((c = * macro_contents ++)) -+ (void)(obstack_1grow (¯os, c)); -+ } -+ macro_contents = last_input_line_pointer; -+ continue; -+ } -+ else if (*macro_contents == 'n'){ -+ macro_contents++ ; -+ (void)(obstack_1grow(¯os, nargs + '0')); -+ continue; -+ } -+ } -+ (void)(obstack_1grow (¯os, c)); -+ } -+ (void)(obstack_1grow (¯os, '\n')); -+ (void)(obstack_1grow (¯os, '\0')); - last_buffer_limit = buffer_limit; - last_count_lines = count_lines; - last_input_line_pointer = input_line_pointer; -@@ -4732,13 +4565,9 @@ - #endif /* PPC */ - parse_a_buffer(buffer + 1); - obstack_free (¯os, buffer); -- -- if (!(info->new_style)) { -- for(index = 9; index >= 0; index --) -- if(arguments[index]) -- obstack_free(¯os, arguments[index]); -- } -- -+ for(index = 9; index >= 0; index --) -+ if(arguments[index]) -+ obstack_free(¯os, arguments[index]); - buffer_limit = last_buffer_limit; - count_lines = last_count_lines; - input_line_pointer = last_input_line_pointer; -@@ -4753,7 +4582,7 @@ - static - void - s_dump( --int value) -+uintptr_t value) - { - char *filename; - int length; -@@ -4821,7 +4650,7 @@ - static - void - s_load( --int value) -+uintptr_t value) - { - char *char_pointer; - char *filename; -@@ -4837,14 +4666,14 @@ - do{ - do{ - the_char = getc_unlocked(dump_fp); -- obstack_1grow(¯os, the_char); -+ (void)(obstack_1grow(¯os, the_char)); - }while(the_char); - char_pointer = obstack_finish (¯os); - if(!(*char_pointer)) - break; - do{ - the_char = getc_unlocked(dump_fp); -- obstack_1grow(¯os, the_char); -+ (void)(obstack_1grow(¯os, the_char)); - }while(the_char); - if(hash_insert(ma_hash, char_pointer, - obstack_finish(¯os))) -@@ -4861,7 +4690,7 @@ - do{ - do{ - the_char = getc_unlocked(dump_fp); -- obstack_1grow(¯os, the_char); -+ (void)(obstack_1grow(¯os, the_char)); - }while(the_char); - char_pointer = obstack_base(¯os); - obstack_next_free(¯os) = char_pointer; -@@ -4895,7 +4724,7 @@ - static - void - s_subsections_via_symbols( --int value) -+uintptr_t value) - { - demand_empty_rest_of_line(); - subsections_via_symbols = TRUE; -@@ -4910,11 +4739,12 @@ - static - void - s_machine( --int value) -+uintptr_t value) - { - char *arch_name, c; - struct arch_flag arch_flag; - cpu_subtype_t new_cpusubtype; -+ const struct arch_flag *family_arch_flag; - - arch_name = input_line_pointer; - /* -@@ -4926,26 +4756,32 @@ - *--input_line_pointer = 0; - - if(force_cpusubtype_ALL == FALSE){ -- if(get_arch_from_flag(arch_name, &arch_flag) == 0){ -+ family_arch_flag = NULL; -+ if(strcmp(arch_name, "all") == 0){ -+ family_arch_flag = get_arch_family_from_cputype(md_cputype); -+ if(family_arch_flag != NULL) -+ arch_flag = *family_arch_flag; -+ } -+ if(family_arch_flag == NULL && -+ get_arch_from_flag(arch_name, &arch_flag) == 0){ - as_bad("unknown .machine argument: %s", arch_name); -+ return; -+ } -+ if(arch_flag.cputype != md_cputype){ -+ as_bad("invalid .machine argument: %s", arch_name); - } - else{ -- if(arch_flag.cputype != md_cputype){ -- as_bad("invalid .machine argument: %s", arch_name); -+ new_cpusubtype = cpusubtype_combine(md_cputype, -+ md_cpusubtype, -+ arch_flag.cpusubtype); -+ if(new_cpusubtype == -1){ -+ as_bad(".machine argument: %s can not be combined " -+ "with previous .machine directives, -arch " -+ "arguments or machine specific instructions", -+ arch_name); - } - else{ -- new_cpusubtype = cpusubtype_combine(md_cputype, -- md_cpusubtype, -- arch_flag.cpusubtype); -- if(new_cpusubtype == -1){ -- as_bad(".machine argument: %s can not be combined " -- "with previous .machine directives, -arch " -- "arguments or machine specific instructions", -- arch_name); -- } -- else{ -- archflag_cpusubtype = new_cpusubtype; -- } -+ archflag_cpusubtype = new_cpusubtype; - } - } - } -@@ -4964,7 +4800,7 @@ - static - void - s_secure_log_reset( --int value) -+uintptr_t value) - { - s_secure_log_used = FALSE; - demand_empty_rest_of_line(); -@@ -4982,7 +4818,7 @@ - static - void - s_secure_log_unique( --int value) -+uintptr_t value) - { - FILE *secure_log_fp; - char *log_msg, c; -@@ -5021,6 +4857,127 @@ - demand_empty_rest_of_line(); - } - -+/* -+ * When inlineasm_checks is non-zero, then these variable are set and used -+ * when reporting errors for the properties of GCC function-scope inline asms. -+ */ -+int inlineasm_checks = 0; -+char *inlineasm_file_name = NULL; -+int inlineasm_line_number = 0; -+int inlineasm_column_number = 0; -+ -+/* -+ * s_inlineasm() handles the pseudo ops: -+ * .inlineasmstart [[["file_name"] [,<line_number>]] [,<column_number>]] -+ * .inlineasmend -+ * The parameter value is 1 for start and 0 for end. The arguments to the -+ * start directive are optional. -+ * -+ * This causes the assembler enforces properties required of GCC function-scope -+ * inline asms. -+ * -+ * The requirement that does not allow non-numeric labels to be defined in an -+ * inline asm is checked for in colon(). -+ */ -+static -+void -+s_inlineasm( -+uintptr_t value) -+{ -+ int length; -+ -+ inlineasm_checks = value; -+ inlineasm_file_name = NULL; -+ inlineasm_line_number = 0; -+ inlineasm_column_number = 0; -+ -+ SKIP_WHITESPACE(); -+ if(value == 1 && *input_line_pointer == '"'){ -+ if((inlineasm_file_name = demand_copy_string(&length))){ -+ SKIP_WHITESPACE(); -+ if(*input_line_pointer == ','){ -+ input_line_pointer++; -+ inlineasm_line_number = get_absolute_expression(); -+ SKIP_WHITESPACE(); -+ if(*input_line_pointer == ','){ -+ input_line_pointer++; -+ inlineasm_column_number = get_absolute_expression(); -+ } -+ } -+ } -+ } -+ demand_empty_rest_of_line(); -+} -+ -+/* -+ * s_incbin() implements the pseudo op: -+ * .incbin "filename" -+ */ -+static -+void -+s_incbin( -+uintptr_t value) -+{ -+ char *filename, *whole_file_name, *p; -+ int length; -+ FILE *fp; -+ int the_char; -+ -+ /* Some assemblers tolerate immediately following '"' */ -+ if((filename = demand_copy_string( & length ) )) { -+ demand_empty_rest_of_line(); -+ whole_file_name = find_an_include_file(filename); -+ if(whole_file_name != NULL && -+ (fp = fopen(whole_file_name, "r"))){ -+ do{ -+ the_char = getc_unlocked(fp); -+ if (the_char != -1){ -+ p = frag_more(1); -+ *p = the_char; -+ } -+ }while(the_char != -1); -+ fclose(fp); -+ return; -+ } -+ as_fatal("Couldn't find the .incbin file: \"%s\"", filename); -+ } -+} -+ -+/* -+ * s_data_region() parses and ignores the pseudo op: -+ * .data_region { region_type } -+ * region_type := "jt8" | "jt16" | "jt32" | "jta32" -+ */ -+static -+void -+s_data_region( -+uintptr_t value) -+{ -+ char *region_type, c; -+ -+ c = *input_line_pointer; -+ if(c != '\n'){ -+ region_type = input_line_pointer; -+ do{ -+ c = *input_line_pointer++; -+ }while(c != '\n'); -+ input_line_pointer--; -+ } -+ demand_empty_rest_of_line(); -+} -+ -+/* -+ * s_end_data_region() parses and ignores the pseudo op: -+ * .end_data_region -+ */ -+static -+void -+s_end_data_region( -+uintptr_t value) -+{ -+ demand_empty_rest_of_line(); -+} -+ - #ifdef SPARC - - /* Special stuff to allow assembly of Sun assembler sources -@@ -5061,7 +5018,7 @@ - if (ps_t == 0) - as_bad ("invalid .seg argument"); - -- printf("INDEX %s, %d\n", s, ps_t->poc_val); -+ printf("INDEX %s, %p\n", s, (void *)ps_t->poc_val); - - s_builtin_section ((const struct builtin_section *)ps_t->poc_val); - demand_empty_rest_of_line(); -@@ -5085,8 +5042,164 @@ - static - void - s_ppcasm_end( --int value) -+uintptr_t value) - { - demand_empty_rest_of_line(); - } - #endif /* PPC */ -+ -+/* Return the size of a LEB128 value. */ -+ -+static inline int -+sizeof_sleb128_32 (int32_t value) -+{ -+ register int size = 0; -+ register unsigned byte; -+ -+ do -+ { -+ byte = (value & 0x7f); -+ /* Sadly, we cannot rely on typical arithmetic right shift behaviour. -+ Fortunately, we can structure things so that the extra work reduces -+ to a noop on systems that do things "properly". */ -+ value = (value >> 7) | ~(-(offsetT)1 >> 7); -+ size += 1; -+ } -+ while (!(((value == 0) && ((byte & 0x40) == 0)) -+ || ((value == -1) && ((byte & 0x40) != 0)))); -+ -+ return size; -+} -+ -+static inline int -+sizeof_sleb128_64 (int64_t value) -+{ -+ register int size = 0; -+ register unsigned byte; -+ -+ do -+ { -+ byte = (value & 0x7f); -+ /* Sadly, we cannot rely on typical arithmetic right shift behaviour. -+ Fortunately, we can structure things so that the extra work reduces -+ to a noop on systems that do things "properly". */ -+ value = (value >> 7) | ~(-(offsetT)1 >> 7); -+ size += 1; -+ } -+ while (!(((value == 0) && ((byte & 0x40) == 0)) -+ || ((value == -1) && ((byte & 0x40) != 0)))); -+ -+ return size; -+} -+ -+static inline int -+sizeof_uleb128_32 (uint32_t value) -+{ -+ register int size = 0; -+ register unsigned byte; -+ -+ do -+ { -+ byte = (value & 0x7f); -+ value >>= 7; -+ size += 1; -+ } -+ while (value != 0); -+ -+ return size; -+} -+ -+static inline int -+sizeof_uleb128_64 (uint64_t value) -+{ -+ register int size = 0; -+ register unsigned byte; -+ -+ do -+ { -+ byte = (value & 0x7f); -+ value >>= 7; -+ size += 1; -+ } -+ while (value != 0); -+ -+ return size; -+} -+ -+#ifdef ARCH64 -+int -+sizeof_leb128 (valueT value, int sign) -+{ -+ if (sign) -+ return sizeof_sleb128_64 ((offsetT) value); -+ else -+ return sizeof_uleb128_64 (value); -+} -+#else -+int -+sizeof_leb128 (valueT value, int sign) -+{ -+ if (sign) -+ return sizeof_sleb128_32 ((offsetT) value); -+ else -+ return sizeof_uleb128_32 (value); -+} -+#endif -+ -+/* Output a LEB128 value. */ -+ -+static inline int -+output_sleb128 (char *p, offsetT value) -+{ -+ register char *orig = p; -+ register int more; -+ -+ do -+ { -+ unsigned byte = (value & 0x7f); -+ -+ /* Sadly, we cannot rely on typical arithmetic right shift behaviour. -+ Fortunately, we can structure things so that the extra work reduces -+ to a noop on systems that do things "properly". */ -+ value = (value >> 7) | ~(-(offsetT)1 >> 7); -+ -+ more = !((((value == 0) && ((byte & 0x40) == 0)) -+ || ((value == -1) && ((byte & 0x40) != 0)))); -+ if (more) -+ byte |= 0x80; -+ -+ *p++ = byte; -+ } -+ while (more); -+ -+ return p - orig; -+} -+ -+static inline int -+output_uleb128 (char *p, valueT value) -+{ -+ char *orig = p; -+ -+ do -+ { -+ unsigned byte = (value & 0x7f); -+ value >>= 7; -+ if (value != 0) -+ /* More bytes to follow. */ -+ byte |= 0x80; -+ -+ *p++ = byte; -+ } -+ while (value != 0); -+ -+ return p - orig; -+} -+ -+int -+output_leb128 (char *p, valueT value, int sign) -+{ -+ if (sign) -+ return output_sleb128 (p, (offsetT) value); -+ else -+ return output_uleb128 (p, value); -+} -Index: odcctools-9.2-ld/as/read.h -=================================================================== ---- odcctools-9.2-ld.orig/as/read.h 2013-09-03 21:08:01.405209526 +0000 -+++ odcctools-9.2-ld/as/read.h 2013-09-03 21:08:01.893209515 +0000 -@@ -29,7 +29,7 @@ - - #ifdef PERMIT_WHITESPACE - #define SKIP_WHITESPACE() \ -- ((*input_line_pointer == ' ') ? ++input_line_pointer : 0) -+ (void)((*input_line_pointer == ' ') ? ++input_line_pointer : 0) - #else - #define SKIP_WHITESPACE() know(*input_line_pointer != ' ' ) - #endif -@@ -46,8 +46,8 @@ - */ - typedef struct { - char *poc_name; /* assembler mnemonic, lower case, no '.' */ -- void (*poc_handler)(int poc_val); /* Do the work */ -- int poc_val; /* Value to pass to handler */ -+ void (*poc_handler)(uintptr_t poc_val); /* Do the work */ -+ uintptr_t poc_val; /* Value to pass to handler */ - } pseudo_typeS; - - extern char *input_line_pointer; /* -> char we are parsing now. */ -@@ -63,7 +63,16 @@ - char lex_type[]; - extern char is_end_of_line( - int c); --extern unsigned long text_nsect; -+extern uint32_t text_nsect; -+ -+/* -+ * These variable are set with .inlineasmstart and used when reporting errors -+ * for the properties of GCC function-scope inline asms. -+ */ -+extern int inlineasm_checks; -+extern char *inlineasm_file_name; -+extern int inlineasm_line_number; -+extern int inlineasm_column_number; - - extern void read_begin( - void); -@@ -75,6 +84,8 @@ - char *buffer); - extern signed_target_addr_t get_absolute_expression( - void); -+extern char *demand_copy_C_string( -+ int *len_pointer); - extern void demand_empty_rest_of_line( - void); - extern void ignore_rest_of_line( -@@ -88,35 +99,36 @@ - - /* globally known pseudo-op functions (used by some assemblers in MACHINE.c) */ - extern void stringer( -- int append_zero); -+ uintptr_t append_zero); - extern void s_space( -- int value); -+ uintptr_t value); - extern void s_abs( -- int value); -+ uintptr_t value); - extern void float_cons( -- int float_type); -+ uintptr_t float_type); - extern void cons( -- int nbytes); -+ uintptr_t nbytes); - extern void s_globl( -- int value); -+ uintptr_t value); -+void s_app_file( -+ uintptr_t value); - extern void s_ignore( -- int arg); -+ uintptr_t arg); - extern void s_line( -- int value); -+ uintptr_t value); - extern void s_macro( -- int value); -+ uintptr_t value); - extern void s_endmacro( -- int value); --extern void s_rept( -- int value); --extern void s_endr( -- int value); --extern void s_ifnc( -- int value); --extern void s_ifc( -- int value); --extern void s_ifdef( -- int value); -+ uintptr_t value); - extern void big_cons( -- int nbytes); -+ uintptr_t nbytes); -+extern void pseudo_set( -+ symbolS *symbolP); -+extern int output_leb128( -+ char *p, -+ valueT value, -+ int sign); -+extern int sizeof_leb128( -+ valueT value, -+ int sign); - #endif /* _READ_H_ */ -Index: odcctools-9.2-ld/as/relax.h -=================================================================== ---- odcctools-9.2-ld.orig/as/relax.h 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/relax.h 2013-09-03 21:08:01.893209515 +0000 -@@ -1,5 +1,9 @@ - /* The type used for a target address */ --typedef unsigned long relax_addressT; -+#ifdef ARCH64 -+typedef uint64_t relax_addressT; -+#else -+typedef uint32_t relax_addressT; -+#endif - - /* - * relax_stateT is a fragment's type and stored in a struct frag's fr_type -@@ -15,6 +19,8 @@ - rs_org, /* Org: Fr_offset, fr_symbol: address. */ - /* 1 variable char: fill character. */ - rs_machine_dependent, -+ rs_dwarf2dbg, -+ rs_leb128 /* leb128 value, subtype is 0 for 1 for signed. */ - } relax_stateT; - - /* -@@ -25,7 +31,7 @@ - * The substate is a machine dependent indication of what type of branch - * instruction this fragment is. - */ --typedef unsigned long relax_substateT; -+typedef uint32_t relax_substateT; - - /* - * relax_typeS is the structure that is the entry in the md_relax_table array. -Index: odcctools-9.2-ld/as/sections.h -=================================================================== ---- odcctools-9.2-ld.orig/as/sections.h 2013-09-03 21:08:01.409209526 +0000 -+++ odcctools-9.2-ld/as/sections.h 2013-09-03 21:08:01.893209515 +0000 -@@ -17,6 +17,7 @@ - along with GAS; see the file COPYING. If not, write to - the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ - -+#include <stdint.h> - #include <mach-o/loader.h> - #include "struc-symbol.h" - -@@ -37,10 +38,13 @@ - struct frchain *frch_next; /* next in chain of struct frchain-s */ - - section_t frch_section; /* section info, name, type, etc. */ -- unsigned long frch_nsect; /* section number (1,2,3,...) */ -+ uint32_t frch_nsect; /* section number (1,2,3,...) */ - struct fix *frch_fix_root; /* section fixups */ - isymbolS *frch_isym_root; /* 1st indirect symbol in chain */ - isymbolS *frch_isym_last; /* last indirect symbol in chain */ -+ symbolS *section_symbol; /* section symbol for dwarf if set */ -+ uint32_t has_rs_leb128s; /* section has some rs_leb128 frags */ -+ uint32_t layout_pass; /* pass order for layout_addresses() */ - }; - - typedef struct frchain frchainS; -@@ -57,6 +61,14 @@ - extern frchainS *frchain_now; - - /* -+ * These are used to inteface to the code in dwarf2dbg.c . The first is the -+ * frch_nsect value from the current frchain or current section. The second -+ * is always zero. -+ */ -+extern int now_seg; -+extern int now_subseg; -+ -+/* - * The global routines defined in sections.c - */ - extern void sections_begin( -@@ -65,25 +77,41 @@ - extern frchainS *section_new( - char *segname, - char *sectname, -- unsigned long type, -- unsigned long attributes, -- unsigned long sizeof_stub); -+ uint32_t type, -+ uint32_t attributes, -+ uint32_t sizeof_stub); -+ -+extern void section_set( -+ frchainS *frcP); -+ -+extern symbolS *section_symbol( -+ frchainS *frcP); -+ -+extern int seg_not_empty_p( -+ frchainS *frcP); -+ -+extern struct frchain *get_section_by_nsect( -+ uint32_t nsect); -+ -+extern struct frchain *get_section_by_name( -+ char *segname, -+ char *sectname); - --extern unsigned long is_section_coalesced( -- unsigned long n_sect); -+extern uint32_t is_section_coalesced( -+ uint32_t n_sect); - --extern unsigned long is_section_non_lazy_symbol_pointers( -- unsigned long n_sect); -+extern uint32_t is_section_non_lazy_symbol_pointers( -+ uint32_t n_sect); - --extern unsigned long is_section_debug( -- unsigned long n_sect); -+extern uint32_t is_section_debug( -+ uint32_t n_sect); - --extern unsigned long is_section_cstring_literals( -- unsigned long n_sect); -+extern uint32_t is_section_cstring_literals( -+ uint32_t n_sect); - --extern unsigned long is_end_section_address( -- unsigned long n_sect, -- unsigned long addr); -+extern uint32_t is_end_section_address( -+ uint32_t n_sect, -+ addressT addr); - --extern unsigned long section_has_fixed_size_data( -- unsigned long n_sect); -+extern uint32_t section_has_fixed_size_data( -+ uint32_t n_sect); -Index: odcctools-9.2-ld/include/mach-o/loader.h -=================================================================== ---- odcctools-9.2-ld.orig/include/mach-o/loader.h 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/include/mach-o/loader.h 2013-09-03 21:08:01.893209515 +0000 -@@ -1,5 +1,5 @@ - /* -- * Copyright (c) 1999-2008 Apple Inc. All Rights Reserved. -+ * Copyright (c) 1999-2010 Apple Inc. All Rights Reserved. - * - * @APPLE_LICENSE_HEADER_START@ - * -@@ -119,6 +119,7 @@ - /* linking only, no section contents */ - #define MH_DSYM 0xa /* companion file with only debug */ - /* sections */ -+#define MH_KEXT_BUNDLE 0xb /* x86_64 kexts */ - - /* Constants for the flags field of the mach_header */ - #define MH_NOUNDEFS 0x1 /* the object file has no undefined -@@ -189,6 +190,22 @@ - load the main executable at a - random address. Only used in - MH_EXECUTE filetypes. */ -+#define MH_DEAD_STRIPPABLE_DYLIB 0x400000 /* Only for use on dylibs. When -+ linking against a dylib that -+ has this bit set, the static linker -+ will automatically not create a -+ LC_LOAD_DYLIB load command to the -+ dylib if no symbols are being -+ referenced from the dylib. */ -+#define MH_HAS_TLV_DESCRIPTORS 0x800000 /* Contains a section of type -+ S_THREAD_LOCAL_VARIABLES */ -+ -+#define MH_NO_HEAP_EXECUTION 0x1000000 /* When this bit is set, the OS will -+ run the main executable with -+ a non-executable heap even on -+ platforms (e.g. i386) that don't -+ require it. Only used in MH_EXECUTE -+ filetypes. */ - - /* - * The load commands directly follow the mach_header. The total size of all -@@ -248,7 +265,6 @@ - #define LC_SUB_LIBRARY 0x15 /* sub library */ - #define LC_TWOLEVEL_HINTS 0x16 /* two-level namespace lookup hints */ - #define LC_PREBIND_CKSUM 0x17 /* prebind checksum */ --#define LC_ENCRYPTION_INFO 0x21 /* encrypted segment information */ - - /* - * load a dynamically linked shared library that is allowed to be missing -@@ -264,6 +280,22 @@ - #define LC_CODE_SIGNATURE 0x1d /* local of code signature */ - #define LC_SEGMENT_SPLIT_INFO 0x1e /* local of info to split segments */ - #define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD) /* load and re-export dylib */ -+#define LC_LAZY_LOAD_DYLIB 0x20 /* delay load of dylib until first use */ -+#define LC_ENCRYPTION_INFO 0x21 /* encrypted segment information */ -+#define LC_DYLD_INFO 0x22 /* compressed dyld information */ -+#define LC_DYLD_INFO_ONLY (0x22|LC_REQ_DYLD) /* compressed dyld information only */ -+#define LC_LOAD_UPWARD_DYLIB (0x23 | LC_REQ_DYLD) /* load upward dylib */ -+#define LC_VERSION_MIN_MACOSX 0x24 /* build for MacOSX min OS version */ -+#define LC_VERSION_MIN_IPHONEOS 0x25 /* build for iPhoneOS min OS version */ -+#define LC_FUNCTION_STARTS 0x26 /* compressed table of function start addresses */ -+#define LC_DYLD_ENVIRONMENT 0x27 /* string for dyld to treat -+ like environment variable */ -+#define LC_MAIN (0x28|LC_REQ_DYLD) /* replacement for LC_UNIXTHREAD */ -+#define LC_DATA_IN_CODE 0x29 /* table of non-instructions in __text */ -+#define LC_SOURCE_VERSION 0x2A /* source version used to build binary */ -+#define LC_DYLIB_CODE_SIGN_DRS 0x2B /* Code signing DRs copied from linked dylibs */ -+#define LC_ENCRYPTION_INFO_64 0x2C /* 64-bit encrypted segment information */ -+ - - /* - * A variable length string in a load command is represented by an lc_str -@@ -450,6 +482,23 @@ - literals */ - #define S_DTRACE_DOF 0xf /* section contains - DTrace Object Format */ -+#define S_LAZY_DYLIB_SYMBOL_POINTERS 0x10 /* section with only lazy -+ symbol pointers to lazy -+ loaded dylibs */ -+/* -+ * Section types to support thread local variables -+ */ -+#define S_THREAD_LOCAL_REGULAR 0x11 /* template of initial -+ values for TLVs */ -+#define S_THREAD_LOCAL_ZEROFILL 0x12 /* template of initial -+ values for TLVs */ -+#define S_THREAD_LOCAL_VARIABLES 0x13 /* TLV descriptors */ -+#define S_THREAD_LOCAL_VARIABLE_POINTERS 0x14 /* pointers to TLV -+ descriptors */ -+#define S_THREAD_LOCAL_INIT_FUNCTION_POINTERS 0x15 /* functions to call -+ to initialize TLV -+ values */ -+ - /* - * Constants for the section attributes part of the flags field of a section - * structure. -@@ -696,9 +745,12 @@ - * the name of the dynamic linker (LC_LOAD_DYLINKER). And a dynamic linker - * contains a dylinker_command to identify the dynamic linker (LC_ID_DYLINKER). - * A file can have at most one of these. -+ * This struct is also used for the LC_DYLD_ENVIRONMENT load command and -+ * contains string for dyld to treat like environment variable. - */ - struct dylinker_command { -- uint32_t cmd; /* LC_ID_DYLINKER or LC_LOAD_DYLINKER */ -+ uint32_t cmd; /* LC_ID_DYLINKER, LC_LOAD_DYLINKER or -+ LC_DYLD_ENVIRONMENT */ - uint32_t cmdsize; /* includes pathname string */ - union lc_str name; /* dynamic linker's path name */ - }; -@@ -1102,26 +1154,226 @@ - * of data in the __LINKEDIT segment. - */ - struct linkedit_data_command { -- uint32_t cmd; /* LC_CODE_SIGNATURE or LC_SEGMENT_SPLIT_INFO */ -+ uint32_t cmd; /* LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO, -+ LC_FUNCTION_STARTS, LC_DATA_IN_CODE, -+ or LC_DYLIB_CODE_SIGN_DRS */ - uint32_t cmdsize; /* sizeof(struct linkedit_data_command) */ - uint32_t dataoff; /* file offset of data in __LINKEDIT segment */ - uint32_t datasize; /* file size of data in __LINKEDIT segment */ - }; - -- - /* - * The encryption_info_command contains the file offset and size of an -- * of an encrypted segment. -+ * of an encrypted segment. - */ - struct encryption_info_command { -- uint32_t cmd; /* LC_ENCRYPTION_INFO */ -- uint32_t cmdsize; /* sizeof(struct encryption_info_command) */ -- uint32_t cryptoff; /* file offset of encrypted range */ -- uint32_t cryptsize; /* file size of encrypted range */ -- uint32_t cryptid; /* which enryption system, -- 0 means not-encrypted yet */ -+ uint32_t cmd; /* LC_ENCRYPTION_INFO */ -+ uint32_t cmdsize; /* sizeof(struct encryption_info_command) */ -+ uint32_t cryptoff; /* file offset of encrypted range */ -+ uint32_t cryptsize; /* file size of encrypted range */ -+ uint32_t cryptid; /* which enryption system, -+ 0 means not-encrypted yet */ -+}; -+ -+/* -+ * The encryption_info_command_64 contains the file offset and size of an -+ * of an encrypted segment (for use in 64-bit targets). -+ */ -+struct encryption_info_command_64 { -+ uint32_t cmd; /* LC_ENCRYPTION_INFO_64 */ -+ uint32_t cmdsize; /* sizeof(struct encryption_info_command_64) */ -+ uint32_t cryptoff; /* file offset of encrypted range */ -+ uint32_t cryptsize; /* file size of encrypted range */ -+ uint32_t cryptid; /* which enryption system, -+ 0 means not-encrypted yet */ -+ uint32_t pad; /* padding to make this struct's size a multiple -+ of 8 bytes */ - }; - -+/* -+ * The version_min_command contains the min OS version on which this -+ * binary was built to run. -+ */ -+struct version_min_command { -+ uint32_t cmd; /* LC_VERSION_MIN_MACOSX or -+ LC_VERSION_MIN_IPHONEOS */ -+ uint32_t cmdsize; /* sizeof(struct min_version_command) */ -+ uint32_t version; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ -+ uint32_t sdk; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ -+}; -+ -+/* -+ * The dyld_info_command contains the file offsets and sizes of -+ * the new compressed form of the information dyld needs to -+ * load the image. This information is used by dyld on Mac OS X -+ * 10.6 and later. All information pointed to by this command -+ * is encoded using byte streams, so no endian swapping is needed -+ * to interpret it. -+ */ -+struct dyld_info_command { -+ uint32_t cmd; /* LC_DYLD_INFO or LC_DYLD_INFO_ONLY */ -+ uint32_t cmdsize; /* sizeof(struct dyld_info_command) */ -+ -+ /* -+ * Dyld rebases an image whenever dyld loads it at an address different -+ * from its preferred address. The rebase information is a stream -+ * of byte sized opcodes whose symbolic names start with REBASE_OPCODE_. -+ * Conceptually the rebase information is a table of tuples: -+ * <seg-index, seg-offset, type> -+ * The opcodes are a compressed way to encode the table by only -+ * encoding when a column changes. In addition simple patterns -+ * like "every n'th offset for m times" can be encoded in a few -+ * bytes. -+ */ -+ uint32_t rebase_off; /* file offset to rebase info */ -+ uint32_t rebase_size; /* size of rebase info */ -+ -+ /* -+ * Dyld binds an image during the loading process, if the image -+ * requires any pointers to be initialized to symbols in other images. -+ * The bind information is a stream of byte sized -+ * opcodes whose symbolic names start with BIND_OPCODE_. -+ * Conceptually the bind information is a table of tuples: -+ * <seg-index, seg-offset, type, symbol-library-ordinal, symbol-name, addend> -+ * The opcodes are a compressed way to encode the table by only -+ * encoding when a column changes. In addition simple patterns -+ * like for runs of pointers initialzed to the same value can be -+ * encoded in a few bytes. -+ */ -+ uint32_t bind_off; /* file offset to binding info */ -+ uint32_t bind_size; /* size of binding info */ -+ -+ /* -+ * Some C++ programs require dyld to unique symbols so that all -+ * images in the process use the same copy of some code/data. -+ * This step is done after binding. The content of the weak_bind -+ * info is an opcode stream like the bind_info. But it is sorted -+ * alphabetically by symbol name. This enable dyld to walk -+ * all images with weak binding information in order and look -+ * for collisions. If there are no collisions, dyld does -+ * no updating. That means that some fixups are also encoded -+ * in the bind_info. For instance, all calls to "operator new" -+ * are first bound to libstdc++.dylib using the information -+ * in bind_info. Then if some image overrides operator new -+ * that is detected when the weak_bind information is processed -+ * and the call to operator new is then rebound. -+ */ -+ uint32_t weak_bind_off; /* file offset to weak binding info */ -+ uint32_t weak_bind_size; /* size of weak binding info */ -+ -+ /* -+ * Some uses of external symbols do not need to be bound immediately. -+ * Instead they can be lazily bound on first use. The lazy_bind -+ * are contains a stream of BIND opcodes to bind all lazy symbols. -+ * Normal use is that dyld ignores the lazy_bind section when -+ * loading an image. Instead the static linker arranged for the -+ * lazy pointer to initially point to a helper function which -+ * pushes the offset into the lazy_bind area for the symbol -+ * needing to be bound, then jumps to dyld which simply adds -+ * the offset to lazy_bind_off to get the information on what -+ * to bind. -+ */ -+ uint32_t lazy_bind_off; /* file offset to lazy binding info */ -+ uint32_t lazy_bind_size; /* size of lazy binding infs */ -+ -+ /* -+ * The symbols exported by a dylib are encoded in a trie. This -+ * is a compact representation that factors out common prefixes. -+ * It also reduces LINKEDIT pages in RAM because it encodes all -+ * information (name, address, flags) in one small, contiguous range. -+ * The export area is a stream of nodes. The first node sequentially -+ * is the start node for the trie. -+ * -+ * Nodes for a symbol start with a uleb128 that is the length of -+ * the exported symbol information for the string so far. -+ * If there is no exported symbol, the node starts with a zero byte. -+ * If there is exported info, it follows the length. -+ * -+ * First is a uleb128 containing flags. Normally, it is followed by -+ * a uleb128 encoded offset which is location of the content named -+ * by the symbol from the mach_header for the image. If the flags -+ * is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is -+ * a uleb128 encoded library ordinal, then a zero terminated -+ * UTF8 string. If the string is zero length, then the symbol -+ * is re-export from the specified dylib with the same name. -+ * If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following -+ * the flags is two uleb128s: the stub offset and the resolver offset. -+ * The stub is used by non-lazy pointers. The resolver is used -+ * by lazy pointers and must be called to get the actual address to use. -+ * -+ * After the optional exported symbol information is a byte of -+ * how many edges (0-255) that this node has leaving it, -+ * followed by each edge. -+ * Each edge is a zero terminated UTF8 of the addition chars -+ * in the symbol, followed by a uleb128 offset for the node that -+ * edge points to. -+ * -+ */ -+ uint32_t export_off; /* file offset to lazy binding info */ -+ uint32_t export_size; /* size of lazy binding infs */ -+}; -+ -+/* -+ * The following are used to encode rebasing information -+ */ -+#define REBASE_TYPE_POINTER 1 -+#define REBASE_TYPE_TEXT_ABSOLUTE32 2 -+#define REBASE_TYPE_TEXT_PCREL32 3 -+ -+#define REBASE_OPCODE_MASK 0xF0 -+#define REBASE_IMMEDIATE_MASK 0x0F -+#define REBASE_OPCODE_DONE 0x00 -+#define REBASE_OPCODE_SET_TYPE_IMM 0x10 -+#define REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB 0x20 -+#define REBASE_OPCODE_ADD_ADDR_ULEB 0x30 -+#define REBASE_OPCODE_ADD_ADDR_IMM_SCALED 0x40 -+#define REBASE_OPCODE_DO_REBASE_IMM_TIMES 0x50 -+#define REBASE_OPCODE_DO_REBASE_ULEB_TIMES 0x60 -+#define REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB 0x70 -+#define REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB 0x80 -+ -+ -+/* -+ * The following are used to encode binding information -+ */ -+#define BIND_TYPE_POINTER 1 -+#define BIND_TYPE_TEXT_ABSOLUTE32 2 -+#define BIND_TYPE_TEXT_PCREL32 3 -+ -+#define BIND_SPECIAL_DYLIB_SELF 0 -+#define BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE -1 -+#define BIND_SPECIAL_DYLIB_FLAT_LOOKUP -2 -+ -+#define BIND_SYMBOL_FLAGS_WEAK_IMPORT 0x1 -+#define BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION 0x8 -+ -+#define BIND_OPCODE_MASK 0xF0 -+#define BIND_IMMEDIATE_MASK 0x0F -+#define BIND_OPCODE_DONE 0x00 -+#define BIND_OPCODE_SET_DYLIB_ORDINAL_IMM 0x10 -+#define BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB 0x20 -+#define BIND_OPCODE_SET_DYLIB_SPECIAL_IMM 0x30 -+#define BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM 0x40 -+#define BIND_OPCODE_SET_TYPE_IMM 0x50 -+#define BIND_OPCODE_SET_ADDEND_SLEB 0x60 -+#define BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB 0x70 -+#define BIND_OPCODE_ADD_ADDR_ULEB 0x80 -+#define BIND_OPCODE_DO_BIND 0x90 -+#define BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB 0xA0 -+#define BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED 0xB0 -+#define BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB 0xC0 -+ -+ -+/* -+ * The following are used on the flags byte of a terminal node -+ * in the export information. -+ */ -+#define EXPORT_SYMBOL_FLAGS_KIND_MASK 0x03 -+#define EXPORT_SYMBOL_FLAGS_KIND_REGULAR 0x00 -+#define EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL 0x01 -+#define EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION 0x04 -+#define EXPORT_SYMBOL_FLAGS_REEXPORT 0x08 -+#define EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER 0x10 - - /* - * The symseg_command contains the offset and size of the GNU style -@@ -1163,4 +1415,59 @@ - uint32_t header_addr; /* files virtual address */ - }; - -+ -+/* -+ * The entry_point_command is a replacement for thread_command. -+ * It is used for main executables to specify the location (file offset) -+ * of main(). If -stack_size was used at link time, the stacksize -+ * field will contain the stack size need for the main thread. -+ */ -+struct entry_point_command { -+ uint32_t cmd; /* LC_MAIN only used in MH_EXECUTE filetypes */ -+ uint32_t cmdsize; /* 24 */ -+ uint64_t entryoff; /* file (__TEXT) offset of main() */ -+ uint64_t stacksize;/* if not zero, initial stack size */ -+}; -+ -+ -+/* -+ * The source_version_command is an optional load command containing -+ * the version of the sources used to build the binary. -+ */ -+struct source_version_command { -+ uint32_t cmd; /* LC_SOURCE_VERSION */ -+ uint32_t cmdsize; /* 16 */ -+ uint64_t version; /* A.B.C.D.E packed as a24.b10.c10.d10.e10 */ -+}; -+ -+ -+/* -+ * The LC_DATA_IN_CODE load commands uses a linkedit_data_command -+ * to point to an array of data_in_code_entry entries. Each entry -+ * describes a range of data in a code section. -+ */ -+struct data_in_code_entry { -+ uint32_t offset; /* from mach_header to start of data range*/ -+ uint16_t length; /* number of bytes in data range */ -+ uint16_t kind; /* a DICE_KIND_* value */ -+}; -+#define DICE_KIND_DATA 0x0001 -+#define DICE_KIND_JUMP_TABLE8 0x0002 -+#define DICE_KIND_JUMP_TABLE16 0x0003 -+#define DICE_KIND_JUMP_TABLE32 0x0004 -+#define DICE_KIND_ABS_JUMP_TABLE32 0x0005 -+ -+ -+ -+/* -+ * Sections of type S_THREAD_LOCAL_VARIABLES contain an array -+ * of tlv_descriptor structures. -+ */ -+struct tlv_descriptor -+{ -+ void* (*thunk)(struct tlv_descriptor*); -+ unsigned long key; -+ unsigned long offset; -+}; -+ - #endif /* _MACHO_LOADER_H_ */ -Index: odcctools-9.2-ld/include/mach-o/nlist.h -=================================================================== ---- odcctools-9.2-ld.orig/include/mach-o/nlist.h 2013-09-03 21:08:01.481209525 +0000 -+++ odcctools-9.2-ld/include/mach-o/nlist.h 2013-09-03 21:08:01.893209515 +0000 -@@ -76,7 +76,7 @@ - struct nlist { - union { - char *n_name; /* for use when in-core */ -- int32_t n_strx; /* index into the string table */ -+ uint32_t n_strx; /* index into the string table */ - } n_un; - uint8_t n_type; /* type flag, see below */ - uint8_t n_sect; /* section number or NO_SECT */ -@@ -284,11 +284,25 @@ - */ - #define N_ARM_THUMB_DEF 0x0008 /* symbol is a Thumb function (ARM) */ - -+/* -+ * The N_SYMBOL_RESOLVER bit of the n_desc field indicates that the -+ * that the function is actually a resolver function and should -+ * be called to get the address of the real function to use. -+ * This bit is only available in .o files (MH_OBJECT filetype) -+ */ -+#define N_SYMBOL_RESOLVER 0x0100 -+ - #ifndef __STRICT_BSD__ -+#if __cplusplus -+extern "C" { -+#endif /* __cplusplus */ - /* - * The function nlist(3) from the C library. - */ - extern int nlist (const char *filename, struct nlist *list); -+#if __cplusplus -+} -+#endif /* __cplusplus */ - #endif /* __STRICT_BSD__ */ - - #endif /* _MACHO_LIST_H_ */ -Index: odcctools-9.2-ld/as/arm.c -=================================================================== ---- odcctools-9.2-ld.orig/as/arm.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/arm.c 2013-09-03 21:08:01.897209515 +0000 -@@ -113,7 +113,7 @@ - /* STUFF FROM gas/as.h */ - #define COMMON - COMMON subsegT now_subseg; --COMMON segT now_seg; -+/*COMMON segT now_seg;*/ - - /* STUFF FROM gas/config/tc-arm.h */ - /* FROM line 109 */ -@@ -139,6 +139,7 @@ - #define ISALPHA(c) isalpha(c) - #define ISDIGIT(c) isdigit(c) - #define TOUPPER(c) toupper(c) -+#define TOLOWER(c) tolower(c) - - /* FROM line 137 */ - #define streq(a, b) (strcmp (a, b) == 0) -@@ -9807,7 +9808,7 @@ - /* The knowledge of the PC's pipeline offset is built into the insns - themselves. */ - --long -+int32_t - md_pcrel_from (const fixS * fixP) - { - #ifdef NOTYET -Index: odcctools-9.2-ld/as/filenames.h -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ odcctools-9.2-ld/as/filenames.h 2013-09-03 21:08:01.897209515 +0000 -@@ -0,0 +1,52 @@ -+/* Macros for taking apart, interpreting and processing file names. -+ -+ These are here because some non-Posix (a.k.a. DOSish) systems have -+ drive letter brain-damage at the beginning of an absolute file name, -+ use forward- and back-slash in path names interchangeably, and -+ some of them have case-insensitive file names. -+ -+ Copyright 2000, 2001, 2007 Free Software Foundation, Inc. -+ -+This file is part of BFD, the Binary File Descriptor library. -+ -+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 2 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, write to the Free Software -+Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ -+ -+#ifndef FILENAMES_H -+#define FILENAMES_H -+ -+#if defined(__MSDOS__) || defined(_WIN32) || defined(__OS2__) || defined (__CYGWIN__) -+ -+#ifndef HAVE_DOS_BASED_FILE_SYSTEM -+#define HAVE_DOS_BASED_FILE_SYSTEM 1 -+#endif -+ -+#define IS_DIR_SEPARATOR(c) ((c) == '/' || (c) == '\\') -+/* Note that IS_ABSOLUTE_PATH accepts d:foo as well, although it is -+ only semi-absolute. This is because the users of IS_ABSOLUTE_PATH -+ want to know whether to prepend the current working directory to -+ a file name, which should not be done with a name like d:foo. */ -+#define IS_ABSOLUTE_PATH(f) (IS_DIR_SEPARATOR((f)[0]) || (((f)[0]) && ((f)[1] == ':'))) -+ -+#else /* not DOSish */ -+ -+#define IS_DIR_SEPARATOR(c) ((c) == '/') -+#define IS_ABSOLUTE_PATH(f) (IS_DIR_SEPARATOR((f)[0])) -+ -+#endif /* not DOSish */ -+ -+extern int filename_cmp (const char *s1, const char *s2); -+#define FILENAME_CMP(s1, s2) filename_cmp(s1, s2) -+ -+#endif /* FILENAMES_H */ -Index: odcctools-9.2-ld/as/sections.c -=================================================================== ---- odcctools-9.2-ld.orig/as/sections.c 2013-09-03 21:08:01.409209526 +0000 -+++ odcctools-9.2-ld/as/sections.c 2013-09-03 21:08:01.897209515 +0000 -@@ -32,6 +32,7 @@ - #include "xmalloc.h" - #include "frags.h" - #include "messages.h" -+#include "symbols.h" - - /* - * All sections' chains hang off here. NULL means no frchains yet. -@@ -45,6 +46,21 @@ - frchainS *frchain_now = NULL; - - /* -+ * The variables now_seg and now_subseg are defined here and used slightly -+ * differently than in GAS so it works with Mach-O files and the code generating -+ * dwarf debug info. -+ * -+ * The variable now_seg contains the current section number that is what is -+ * stored in the struct frchain's field frch_nsect. And is set by section_new() -+ * in here and also used in layout.c. The variable now_subseg always remains -+ * zero. And is defined to minimize changes to dwarf2dbg.c that uses it. -+ * Note, now_seg is never set to a section number of a section with a type of -+ * S_ZEROFILL or S_THREAD_LOCAL_ZEROFILL. -+ */ -+int now_seg = 0; -+int now_subseg = 0; -+ -+/* - * sections_begin() sets up to allow sections to be created. - */ - void -@@ -77,18 +93,20 @@ - * frchain_now points to the (possibly new) struct frchain for this section. - * frchain_root updated if needed (for the first section created). - * frag_now is set to the last (possibly new) frag in the section. -+ * now_seg is set to the Mach-O section number (frch_nsect field) except -+ * it is not set for section types of S_ZEROFILL or S_THREAD_LOCAL_ZEROFILL. - */ - frchainS * - section_new( - char *segname, - char *sectname, --unsigned long type, --unsigned long attributes, --unsigned long sizeof_stub) -+uint32_t type, -+uint32_t attributes, -+uint32_t sizeof_stub) - { - frchainS *frcP; - frchainS **lastPP; -- unsigned long last_nsect; -+ uint32_t last_nsect; - - if(frags.chunk_size == 0) - /* -@@ -142,7 +160,10 @@ - * If the current section is the same as for this call there is nothing - * more to do. - */ -- if(frcP != NULL && (frchain_now == frcP || type == S_ZEROFILL)){ -+ if(frcP != NULL && (frchain_now == frcP || type == S_ZEROFILL || -+ type == S_THREAD_LOCAL_ZEROFILL)){ -+ if(type != S_ZEROFILL && type != S_THREAD_LOCAL_ZEROFILL) -+ now_seg = frcP->frch_nsect; - return(frcP); - } - -@@ -150,7 +171,7 @@ - * For non-zerofill sections it will be made the current section so deal - * with the current frag. - */ -- if(type != S_ZEROFILL){ -+ if(type != S_ZEROFILL && type != S_THREAD_LOCAL_ZEROFILL){ - /* - * If there is any current frag in the old section close it off. - */ -@@ -167,7 +188,7 @@ - * on a address that is aligned correctly for the engine that runs - * the assembler. - */ -- obstack_finish(&frags); -+ (void)obstack_finish(&frags); - } - - /* -@@ -175,11 +196,15 @@ - * it by making it the current chain and create a new frag in it. - */ - if(frcP != NULL){ -+ if(type != S_ZEROFILL && type != S_THREAD_LOCAL_ZEROFILL) -+ now_seg = frcP->frch_nsect; - /* - * For a zerofill section no frags are created here and since it -- * exist just return a pointer to the section. -+ * exists just return a pointer to the section. - */ -- if((frcP->frch_section.flags & SECTION_TYPE) == S_ZEROFILL){ -+ if((frcP->frch_section.flags & SECTION_TYPE) == S_ZEROFILL || -+ (frcP->frch_section.flags & SECTION_TYPE) == -+ S_THREAD_LOCAL_ZEROFILL){ - return(frcP); - } - else{ -@@ -187,6 +212,8 @@ - * Make this section the current section. - */ - frchain_now = frcP; -+ if(type != S_ZEROFILL && type != S_THREAD_LOCAL_ZEROFILL) -+ now_seg = frchain_now->frch_nsect; - - /* - * Make a fresh frag for the section. -@@ -216,7 +243,11 @@ - frcP->frch_section.flags = attributes | type; - frcP->frch_section.reserved2 = sizeof_stub; - -+ if(last_nsect + 1 > MAX_SECT) -+ as_fatal("too many sections (maximum %d)\n", MAX_SECT); - frcP->frch_nsect = last_nsect + 1; -+ if(type != S_ZEROFILL && type != S_THREAD_LOCAL_ZEROFILL) -+ now_seg = frcP->frch_nsect; - - *lastPP = frcP; - -@@ -225,7 +256,7 @@ - * For non-zerofill section create the sections new frag and - * make the section the current chain. - */ -- if(type == S_ZEROFILL){ -+ if(type == S_ZEROFILL || type == S_THREAD_LOCAL_ZEROFILL){ - return(frcP); - } - else{ -@@ -251,9 +282,91 @@ - return(frchain_now); - } - --unsigned long -+/* -+ * section_set() sets the current section to passed section pointer struct. -+ * This is used by dwarf2dbg.c before emiting the debug sections. -+ */ -+void -+section_set( -+frchainS *frcP) -+{ -+ section_new(frcP->frch_section.segname, frcP->frch_section.sectname, -+ frcP->frch_section.flags & SECTION_TYPE, -+ frcP->frch_section.flags & SECTION_ATTRIBUTES, -+ frcP->frch_section.reserved2); -+} -+ -+/* -+ * section_symbol() creates and stores (if needed) a symbol for the start of -+ * the section. This is used by code in dwarf2dbg.c . -+ */ -+symbolS * -+section_symbol( -+frchainS *frcP) -+{ -+ if(frcP->section_symbol == NULL){ -+ frcP->section_symbol = symbol_temp_new(frcP->frch_nsect, -+ 0, -+ frcP->frch_root); -+ } -+ return(frcP->section_symbol); -+} -+ -+/* Return non zero if the section has at least one byte of data. It is -+ possible that we'll return zero even on a non-empty section because -+ we don't know all the fragment types, and it is possible that an -+ fr_fix == 0 one still contributes data. Think of this as -+ seg_definitely_not_empty_p. */ -+int -+seg_not_empty_p( -+frchainS *frcP) -+{ -+ fragS *frag; -+ -+ if(frcP == NULL) -+ return(0); -+ -+ for(frag = frcP->frch_root; frag; frag = frag->fr_next){ -+ if(frag->fr_fix != 0) -+ return 1; -+ } -+ return 0; -+} -+ -+ -+struct frchain * -+get_section_by_nsect( -+uint32_t nsect) -+{ -+ struct frchain *frchainP; -+ -+ for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){ -+ if(frchainP->frch_nsect == nsect) -+ return(frchainP); -+ } -+ return(NULL); -+} -+ -+struct frchain * -+get_section_by_name( -+char *segname, -+char *sectname) -+{ -+ struct frchain *frchainP; -+ -+ for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){ -+ if(strncmp(frchainP->frch_section.segname, segname, -+ sizeof(frchainP->frch_section.segname)) == 0 && -+ strncmp(frchainP->frch_section.sectname, sectname, -+ sizeof(frchainP->frch_section.sectname)) == 0) -+ return(frchainP); -+ } -+ return(NULL); -+} -+ -+uint32_t - is_section_coalesced( --unsigned long n_sect) -+uint32_t n_sect) - { - struct frchain *frchainP; - -@@ -265,9 +378,9 @@ - return(0); /* FALSE */ - } - --unsigned long -+uint32_t - is_section_non_lazy_symbol_pointers( --unsigned long n_sect) -+uint32_t n_sect) - { - struct frchain *frchainP; - -@@ -280,9 +393,9 @@ - return(0); /* FALSE */ - } - --unsigned long -+uint32_t - is_section_debug( --unsigned long n_sect) -+uint32_t n_sect) - { - struct frchain *frchainP; - -@@ -295,9 +408,9 @@ - return(0); /* FALSE */ - } - --unsigned long -+uint32_t - is_section_cstring_literals( --unsigned long n_sect) -+uint32_t n_sect) - { - struct frchain *frchainP; - -@@ -310,16 +423,19 @@ - return(0); /* FALSE */ - } - --unsigned long -+uint32_t - is_end_section_address( --unsigned long n_sect, --unsigned long addr) -+uint32_t n_sect, -+addressT addr) - { - struct frchain *frchainP; -+ uint32_t section_type; - - for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){ - if(frchainP->frch_nsect == n_sect){ -- if((frchainP->frch_section.flags & SECTION_TYPE) == S_ZEROFILL) -+ section_type = frchainP->frch_section.flags & SECTION_TYPE; -+ if(section_type == S_ZEROFILL || -+ section_type == S_THREAD_LOCAL_ZEROFILL) - return(0); /* FALSE */ - if(frchainP->frch_last->fr_address == addr) - return(1); /* TRUE */ -@@ -330,9 +446,9 @@ - return(0); /* FALSE */ - } - --unsigned long -+uint32_t - section_has_fixed_size_data( --unsigned long n_sect) -+uint32_t n_sect) - { - struct frchain *frchainP; - -Index: odcctools-9.2-ld/include/elf/dwarf2.h -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ odcctools-9.2-ld/include/elf/dwarf2.h 2013-09-03 21:08:01.897209515 +0000 -@@ -0,0 +1,839 @@ -+/* Declarations and definitions of codes relating to the DWARF2 and -+ DWARF3 symbolic debugging information formats. -+ Copyright (C) 1992, 1993, 1995, 1996, 1997, 1999, 2000, 2001, 2002, -+ 2003, 2004, 2005, 2006 Free Software Foundation, Inc. -+ -+ Written by Gary Funck (gary@intrepid.com) The Ada Joint Program -+ Office (AJPO), Florida State University and Silicon Graphics Inc. -+ provided support for this effort -- June 21, 1995. -+ -+ Derived from the DWARF 1 implementation written by Ron Guilmette -+ (rfg@netcom.com), November 1990. -+ -+ This file is part of GCC. -+ -+ GCC is free software; you can redistribute it and/or modify it under -+ the terms of the GNU General Public License as published by the Free -+ Software Foundation; either version 2, or (at your option) any later -+ version. -+ -+ GCC 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 GCC; see the file COPYING. If not, write to the Free -+ Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA -+ 02110-1301, USA. */ -+ -+/* This file is derived from the DWARF specification (a public document) -+ Revision 2.0.0 (July 27, 1993) developed by the UNIX International -+ Programming Languages Special Interest Group (UI/PLSIG) and distributed -+ by UNIX International. Copies of this specification are available from -+ UNIX International, 20 Waterview Boulevard, Parsippany, NJ, 07054. -+ -+ This file also now contains definitions from the DWARF 3 specification. */ -+ -+/* This file is shared between GCC and GDB, and should not contain -+ prototypes. */ -+ -+#ifndef _ELF_DWARF2_H -+#define _ELF_DWARF2_H -+ -+/* Structure found in the .debug_line section. */ -+typedef struct -+{ -+ unsigned char li_length [4]; -+ unsigned char li_version [2]; -+ unsigned char li_prologue_length [4]; -+ unsigned char li_min_insn_length [1]; -+ unsigned char li_default_is_stmt [1]; -+ unsigned char li_line_base [1]; -+ unsigned char li_line_range [1]; -+ unsigned char li_opcode_base [1]; -+} -+DWARF2_External_LineInfo; -+ -+typedef struct -+{ -+ unsigned long li_length; -+ unsigned short li_version; -+ unsigned int li_prologue_length; -+ unsigned char li_min_insn_length; -+ unsigned char li_default_is_stmt; -+ int li_line_base; -+ unsigned char li_line_range; -+ unsigned char li_opcode_base; -+} -+DWARF2_Internal_LineInfo; -+ -+/* Structure found in .debug_pubnames section. */ -+typedef struct -+{ -+ unsigned char pn_length [4]; -+ unsigned char pn_version [2]; -+ unsigned char pn_offset [4]; -+ unsigned char pn_size [4]; -+} -+DWARF2_External_PubNames; -+ -+typedef struct -+{ -+ unsigned long pn_length; -+ unsigned short pn_version; -+ unsigned long pn_offset; -+ unsigned long pn_size; -+} -+DWARF2_Internal_PubNames; -+ -+/* Structure found in .debug_info section. */ -+typedef struct -+{ -+ unsigned char cu_length [4]; -+ unsigned char cu_version [2]; -+ unsigned char cu_abbrev_offset [4]; -+ unsigned char cu_pointer_size [1]; -+} -+DWARF2_External_CompUnit; -+ -+typedef struct -+{ -+ unsigned long cu_length; -+ unsigned short cu_version; -+ unsigned long cu_abbrev_offset; -+ unsigned char cu_pointer_size; -+} -+DWARF2_Internal_CompUnit; -+ -+typedef struct -+{ -+ unsigned char ar_length [4]; -+ unsigned char ar_version [2]; -+ unsigned char ar_info_offset [4]; -+ unsigned char ar_pointer_size [1]; -+ unsigned char ar_segment_size [1]; -+} -+DWARF2_External_ARange; -+ -+typedef struct -+{ -+ unsigned long ar_length; -+ unsigned short ar_version; -+ unsigned long ar_info_offset; -+ unsigned char ar_pointer_size; -+ unsigned char ar_segment_size; -+} -+DWARF2_Internal_ARange; -+ -+ -+/* Tag names and codes. */ -+enum dwarf_tag -+ { -+ DW_TAG_padding = 0x00, -+ DW_TAG_array_type = 0x01, -+ DW_TAG_class_type = 0x02, -+ DW_TAG_entry_point = 0x03, -+ DW_TAG_enumeration_type = 0x04, -+ DW_TAG_formal_parameter = 0x05, -+ DW_TAG_imported_declaration = 0x08, -+ DW_TAG_label = 0x0a, -+ DW_TAG_lexical_block = 0x0b, -+ DW_TAG_member = 0x0d, -+ DW_TAG_pointer_type = 0x0f, -+ DW_TAG_reference_type = 0x10, -+ DW_TAG_compile_unit = 0x11, -+ DW_TAG_string_type = 0x12, -+ DW_TAG_structure_type = 0x13, -+ DW_TAG_subroutine_type = 0x15, -+ DW_TAG_typedef = 0x16, -+ DW_TAG_union_type = 0x17, -+ DW_TAG_unspecified_parameters = 0x18, -+ DW_TAG_variant = 0x19, -+ DW_TAG_common_block = 0x1a, -+ DW_TAG_common_inclusion = 0x1b, -+ DW_TAG_inheritance = 0x1c, -+ DW_TAG_inlined_subroutine = 0x1d, -+ DW_TAG_module = 0x1e, -+ DW_TAG_ptr_to_member_type = 0x1f, -+ DW_TAG_set_type = 0x20, -+ DW_TAG_subrange_type = 0x21, -+ DW_TAG_with_stmt = 0x22, -+ DW_TAG_access_declaration = 0x23, -+ DW_TAG_base_type = 0x24, -+ DW_TAG_catch_block = 0x25, -+ DW_TAG_const_type = 0x26, -+ DW_TAG_constant = 0x27, -+ DW_TAG_enumerator = 0x28, -+ DW_TAG_file_type = 0x29, -+ DW_TAG_friend = 0x2a, -+ DW_TAG_namelist = 0x2b, -+ DW_TAG_namelist_item = 0x2c, -+ DW_TAG_packed_type = 0x2d, -+ DW_TAG_subprogram = 0x2e, -+ DW_TAG_template_type_param = 0x2f, -+ DW_TAG_template_value_param = 0x30, -+ DW_TAG_thrown_type = 0x31, -+ DW_TAG_try_block = 0x32, -+ DW_TAG_variant_part = 0x33, -+ DW_TAG_variable = 0x34, -+ DW_TAG_volatile_type = 0x35, -+ /* DWARF 3. */ -+ DW_TAG_dwarf_procedure = 0x36, -+ DW_TAG_restrict_type = 0x37, -+ DW_TAG_interface_type = 0x38, -+ DW_TAG_namespace = 0x39, -+ DW_TAG_imported_module = 0x3a, -+ DW_TAG_unspecified_type = 0x3b, -+ DW_TAG_partial_unit = 0x3c, -+ DW_TAG_imported_unit = 0x3d, -+ DW_TAG_condition = 0x3f, -+ DW_TAG_shared_type = 0x40, -+ /* SGI/MIPS Extensions. */ -+ DW_TAG_MIPS_loop = 0x4081, -+ /* HP extensions. See: ftp://ftp.hp.com/pub/lang/tools/WDB/wdb-4.0.tar.gz . */ -+ DW_TAG_HP_array_descriptor = 0x4090, -+ /* GNU extensions. */ -+ DW_TAG_format_label = 0x4101, /* For FORTRAN 77 and Fortran 90. */ -+ DW_TAG_function_template = 0x4102, /* For C++. */ -+ DW_TAG_class_template = 0x4103, /* For C++. */ -+ DW_TAG_GNU_BINCL = 0x4104, -+ DW_TAG_GNU_EINCL = 0x4105, -+ /* Extensions for UPC. See: http://upc.gwu.edu/~upc. */ -+ DW_TAG_upc_shared_type = 0x8765, -+ DW_TAG_upc_strict_type = 0x8766, -+ DW_TAG_upc_relaxed_type = 0x8767, -+ /* PGI (STMicroelectronics) extensions. No documentation available. */ -+ DW_TAG_PGI_kanji_type = 0xA000, -+ DW_TAG_PGI_interface_block = 0xA020 -+ }; -+ -+#define DW_TAG_lo_user 0x4080 -+#define DW_TAG_hi_user 0xffff -+ -+/* Flag that tells whether entry has a child or not. */ -+#define DW_children_no 0 -+#define DW_children_yes 1 -+ -+/* Form names and codes. */ -+enum dwarf_form -+ { -+ DW_FORM_addr = 0x01, -+ DW_FORM_block2 = 0x03, -+ DW_FORM_block4 = 0x04, -+ DW_FORM_data2 = 0x05, -+ DW_FORM_data4 = 0x06, -+ DW_FORM_data8 = 0x07, -+ DW_FORM_string = 0x08, -+ DW_FORM_block = 0x09, -+ DW_FORM_block1 = 0x0a, -+ DW_FORM_data1 = 0x0b, -+ DW_FORM_flag = 0x0c, -+ DW_FORM_sdata = 0x0d, -+ DW_FORM_strp = 0x0e, -+ DW_FORM_udata = 0x0f, -+ DW_FORM_ref_addr = 0x10, -+ DW_FORM_ref1 = 0x11, -+ DW_FORM_ref2 = 0x12, -+ DW_FORM_ref4 = 0x13, -+ DW_FORM_ref8 = 0x14, -+ DW_FORM_ref_udata = 0x15, -+ DW_FORM_indirect = 0x16 -+ }; -+ -+/* Attribute names and codes. */ -+enum dwarf_attribute -+ { -+ DW_AT_sibling = 0x01, -+ DW_AT_location = 0x02, -+ DW_AT_name = 0x03, -+ DW_AT_ordering = 0x09, -+ DW_AT_subscr_data = 0x0a, -+ DW_AT_byte_size = 0x0b, -+ DW_AT_bit_offset = 0x0c, -+ DW_AT_bit_size = 0x0d, -+ DW_AT_element_list = 0x0f, -+ DW_AT_stmt_list = 0x10, -+ DW_AT_low_pc = 0x11, -+ DW_AT_high_pc = 0x12, -+ DW_AT_language = 0x13, -+ DW_AT_member = 0x14, -+ DW_AT_discr = 0x15, -+ DW_AT_discr_value = 0x16, -+ DW_AT_visibility = 0x17, -+ DW_AT_import = 0x18, -+ DW_AT_string_length = 0x19, -+ DW_AT_common_reference = 0x1a, -+ DW_AT_comp_dir = 0x1b, -+ DW_AT_const_value = 0x1c, -+ DW_AT_containing_type = 0x1d, -+ DW_AT_default_value = 0x1e, -+ DW_AT_inline = 0x20, -+ DW_AT_is_optional = 0x21, -+ DW_AT_lower_bound = 0x22, -+ DW_AT_producer = 0x25, -+ DW_AT_prototyped = 0x27, -+ DW_AT_return_addr = 0x2a, -+ DW_AT_start_scope = 0x2c, -+ DW_AT_stride_size = 0x2e, -+ DW_AT_upper_bound = 0x2f, -+ DW_AT_abstract_origin = 0x31, -+ DW_AT_accessibility = 0x32, -+ DW_AT_address_class = 0x33, -+ DW_AT_artificial = 0x34, -+ DW_AT_base_types = 0x35, -+ DW_AT_calling_convention = 0x36, -+ DW_AT_count = 0x37, -+ DW_AT_data_member_location = 0x38, -+ DW_AT_decl_column = 0x39, -+ DW_AT_decl_file = 0x3a, -+ DW_AT_decl_line = 0x3b, -+ DW_AT_declaration = 0x3c, -+ DW_AT_discr_list = 0x3d, -+ DW_AT_encoding = 0x3e, -+ DW_AT_external = 0x3f, -+ DW_AT_frame_base = 0x40, -+ DW_AT_friend = 0x41, -+ DW_AT_identifier_case = 0x42, -+ DW_AT_macro_info = 0x43, -+ DW_AT_namelist_items = 0x44, -+ DW_AT_priority = 0x45, -+ DW_AT_segment = 0x46, -+ DW_AT_specification = 0x47, -+ DW_AT_static_link = 0x48, -+ DW_AT_type = 0x49, -+ DW_AT_use_location = 0x4a, -+ DW_AT_variable_parameter = 0x4b, -+ DW_AT_virtuality = 0x4c, -+ DW_AT_vtable_elem_location = 0x4d, -+ /* DWARF 3 values. */ -+ DW_AT_allocated = 0x4e, -+ DW_AT_associated = 0x4f, -+ DW_AT_data_location = 0x50, -+ DW_AT_stride = 0x51, -+ DW_AT_entry_pc = 0x52, -+ DW_AT_use_UTF8 = 0x53, -+ DW_AT_extension = 0x54, -+ DW_AT_ranges = 0x55, -+ DW_AT_trampoline = 0x56, -+ DW_AT_call_column = 0x57, -+ DW_AT_call_file = 0x58, -+ DW_AT_call_line = 0x59, -+ DW_AT_description = 0x5a, -+ DW_AT_binary_scale = 0x5b, -+ DW_AT_decimal_scale = 0x5c, -+ DW_AT_small = 0x5d, -+ DW_AT_decimal_sign = 0x5e, -+ DW_AT_digit_count = 0x5f, -+ DW_AT_picture_string = 0x60, -+ DW_AT_mutable = 0x61, -+ DW_AT_threads_scaled = 0x62, -+ DW_AT_explicit = 0x63, -+ DW_AT_object_pointer = 0x64, -+ DW_AT_endianity = 0x65, -+ DW_AT_elemental = 0x66, -+ DW_AT_pure = 0x67, -+ DW_AT_recursive = 0x68, -+ /* SGI/MIPS extensions. */ -+ DW_AT_MIPS_fde = 0x2001, -+ DW_AT_MIPS_loop_begin = 0x2002, -+ DW_AT_MIPS_tail_loop_begin = 0x2003, -+ DW_AT_MIPS_epilog_begin = 0x2004, -+ DW_AT_MIPS_loop_unroll_factor = 0x2005, -+ DW_AT_MIPS_software_pipeline_depth = 0x2006, -+ DW_AT_MIPS_linkage_name = 0x2007, -+ DW_AT_MIPS_stride = 0x2008, -+ DW_AT_MIPS_abstract_name = 0x2009, -+ DW_AT_MIPS_clone_origin = 0x200a, -+ DW_AT_MIPS_has_inlines = 0x200b, -+ /* HP extensions. */ -+ DW_AT_HP_block_index = 0x2000, -+ DW_AT_HP_unmodifiable = 0x2001, /* Same as DW_AT_MIPS_fde. */ -+ DW_AT_HP_actuals_stmt_list = 0x2010, -+ DW_AT_HP_proc_per_section = 0x2011, -+ DW_AT_HP_raw_data_ptr = 0x2012, -+ DW_AT_HP_pass_by_reference = 0x2013, -+ DW_AT_HP_opt_level = 0x2014, -+ DW_AT_HP_prof_version_id = 0x2015, -+ DW_AT_HP_opt_flags = 0x2016, -+ DW_AT_HP_cold_region_low_pc = 0x2017, -+ DW_AT_HP_cold_region_high_pc = 0x2018, -+ DW_AT_HP_all_variables_modifiable = 0x2019, -+ DW_AT_HP_linkage_name = 0x201a, -+ DW_AT_HP_prof_flags = 0x201b, /* In comp unit of procs_info for -g. */ -+ /* GNU extensions. */ -+ DW_AT_sf_names = 0x2101, -+ DW_AT_src_info = 0x2102, -+ DW_AT_mac_info = 0x2103, -+ DW_AT_src_coords = 0x2104, -+ DW_AT_body_begin = 0x2105, -+ DW_AT_body_end = 0x2106, -+ DW_AT_GNU_vector = 0x2107, -+ /* VMS extensions. */ -+ DW_AT_VMS_rtnbeg_pd_address = 0x2201, -+ /* UPC extension. */ -+ DW_AT_upc_threads_scaled = 0x3210, -+ /* PGI (STMicroelectronics) extensions. */ -+ DW_AT_PGI_lbase = 0x3a00, -+ DW_AT_PGI_soffset = 0x3a01, -+ DW_AT_PGI_lstride = 0x3a02, -+ /* Apple extension. */ -+ DW_AT_APPLE_flags = 0x3fe2 -+ }; -+ -+#define DW_AT_lo_user 0x2000 /* Implementation-defined range start. */ -+#define DW_AT_hi_user 0x3ff0 /* Implementation-defined range end. */ -+ -+/* Location atom names and codes. */ -+enum dwarf_location_atom -+ { -+ DW_OP_addr = 0x03, -+ DW_OP_deref = 0x06, -+ DW_OP_const1u = 0x08, -+ DW_OP_const1s = 0x09, -+ DW_OP_const2u = 0x0a, -+ DW_OP_const2s = 0x0b, -+ DW_OP_const4u = 0x0c, -+ DW_OP_const4s = 0x0d, -+ DW_OP_const8u = 0x0e, -+ DW_OP_const8s = 0x0f, -+ DW_OP_constu = 0x10, -+ DW_OP_consts = 0x11, -+ DW_OP_dup = 0x12, -+ DW_OP_drop = 0x13, -+ DW_OP_over = 0x14, -+ DW_OP_pick = 0x15, -+ DW_OP_swap = 0x16, -+ DW_OP_rot = 0x17, -+ DW_OP_xderef = 0x18, -+ DW_OP_abs = 0x19, -+ DW_OP_and = 0x1a, -+ DW_OP_div = 0x1b, -+ DW_OP_minus = 0x1c, -+ DW_OP_mod = 0x1d, -+ DW_OP_mul = 0x1e, -+ DW_OP_neg = 0x1f, -+ DW_OP_not = 0x20, -+ DW_OP_or = 0x21, -+ DW_OP_plus = 0x22, -+ DW_OP_plus_uconst = 0x23, -+ DW_OP_shl = 0x24, -+ DW_OP_shr = 0x25, -+ DW_OP_shra = 0x26, -+ DW_OP_xor = 0x27, -+ DW_OP_bra = 0x28, -+ DW_OP_eq = 0x29, -+ DW_OP_ge = 0x2a, -+ DW_OP_gt = 0x2b, -+ DW_OP_le = 0x2c, -+ DW_OP_lt = 0x2d, -+ DW_OP_ne = 0x2e, -+ DW_OP_skip = 0x2f, -+ DW_OP_lit0 = 0x30, -+ DW_OP_lit1 = 0x31, -+ DW_OP_lit2 = 0x32, -+ DW_OP_lit3 = 0x33, -+ DW_OP_lit4 = 0x34, -+ DW_OP_lit5 = 0x35, -+ DW_OP_lit6 = 0x36, -+ DW_OP_lit7 = 0x37, -+ DW_OP_lit8 = 0x38, -+ DW_OP_lit9 = 0x39, -+ DW_OP_lit10 = 0x3a, -+ DW_OP_lit11 = 0x3b, -+ DW_OP_lit12 = 0x3c, -+ DW_OP_lit13 = 0x3d, -+ DW_OP_lit14 = 0x3e, -+ DW_OP_lit15 = 0x3f, -+ DW_OP_lit16 = 0x40, -+ DW_OP_lit17 = 0x41, -+ DW_OP_lit18 = 0x42, -+ DW_OP_lit19 = 0x43, -+ DW_OP_lit20 = 0x44, -+ DW_OP_lit21 = 0x45, -+ DW_OP_lit22 = 0x46, -+ DW_OP_lit23 = 0x47, -+ DW_OP_lit24 = 0x48, -+ DW_OP_lit25 = 0x49, -+ DW_OP_lit26 = 0x4a, -+ DW_OP_lit27 = 0x4b, -+ DW_OP_lit28 = 0x4c, -+ DW_OP_lit29 = 0x4d, -+ DW_OP_lit30 = 0x4e, -+ DW_OP_lit31 = 0x4f, -+ DW_OP_reg0 = 0x50, -+ DW_OP_reg1 = 0x51, -+ DW_OP_reg2 = 0x52, -+ DW_OP_reg3 = 0x53, -+ DW_OP_reg4 = 0x54, -+ DW_OP_reg5 = 0x55, -+ DW_OP_reg6 = 0x56, -+ DW_OP_reg7 = 0x57, -+ DW_OP_reg8 = 0x58, -+ DW_OP_reg9 = 0x59, -+ DW_OP_reg10 = 0x5a, -+ DW_OP_reg11 = 0x5b, -+ DW_OP_reg12 = 0x5c, -+ DW_OP_reg13 = 0x5d, -+ DW_OP_reg14 = 0x5e, -+ DW_OP_reg15 = 0x5f, -+ DW_OP_reg16 = 0x60, -+ DW_OP_reg17 = 0x61, -+ DW_OP_reg18 = 0x62, -+ DW_OP_reg19 = 0x63, -+ DW_OP_reg20 = 0x64, -+ DW_OP_reg21 = 0x65, -+ DW_OP_reg22 = 0x66, -+ DW_OP_reg23 = 0x67, -+ DW_OP_reg24 = 0x68, -+ DW_OP_reg25 = 0x69, -+ DW_OP_reg26 = 0x6a, -+ DW_OP_reg27 = 0x6b, -+ DW_OP_reg28 = 0x6c, -+ DW_OP_reg29 = 0x6d, -+ DW_OP_reg30 = 0x6e, -+ DW_OP_reg31 = 0x6f, -+ DW_OP_breg0 = 0x70, -+ DW_OP_breg1 = 0x71, -+ DW_OP_breg2 = 0x72, -+ DW_OP_breg3 = 0x73, -+ DW_OP_breg4 = 0x74, -+ DW_OP_breg5 = 0x75, -+ DW_OP_breg6 = 0x76, -+ DW_OP_breg7 = 0x77, -+ DW_OP_breg8 = 0x78, -+ DW_OP_breg9 = 0x79, -+ DW_OP_breg10 = 0x7a, -+ DW_OP_breg11 = 0x7b, -+ DW_OP_breg12 = 0x7c, -+ DW_OP_breg13 = 0x7d, -+ DW_OP_breg14 = 0x7e, -+ DW_OP_breg15 = 0x7f, -+ DW_OP_breg16 = 0x80, -+ DW_OP_breg17 = 0x81, -+ DW_OP_breg18 = 0x82, -+ DW_OP_breg19 = 0x83, -+ DW_OP_breg20 = 0x84, -+ DW_OP_breg21 = 0x85, -+ DW_OP_breg22 = 0x86, -+ DW_OP_breg23 = 0x87, -+ DW_OP_breg24 = 0x88, -+ DW_OP_breg25 = 0x89, -+ DW_OP_breg26 = 0x8a, -+ DW_OP_breg27 = 0x8b, -+ DW_OP_breg28 = 0x8c, -+ DW_OP_breg29 = 0x8d, -+ DW_OP_breg30 = 0x8e, -+ DW_OP_breg31 = 0x8f, -+ DW_OP_regx = 0x90, -+ DW_OP_fbreg = 0x91, -+ DW_OP_bregx = 0x92, -+ DW_OP_piece = 0x93, -+ DW_OP_deref_size = 0x94, -+ DW_OP_xderef_size = 0x95, -+ DW_OP_nop = 0x96, -+ /* DWARF 3 extensions. */ -+ DW_OP_push_object_address = 0x97, -+ DW_OP_call2 = 0x98, -+ DW_OP_call4 = 0x99, -+ DW_OP_call_ref = 0x9a, -+ DW_OP_form_tls_address = 0x9b, -+ DW_OP_call_frame_cfa = 0x9c, -+ DW_OP_bit_piece = 0x9d, -+ /* GNU extensions. */ -+ DW_OP_GNU_push_tls_address = 0xe0, -+ DW_OP_GNU_uninit = 0xf0, -+ /* HP extensions. */ -+ DW_OP_HP_unknown = 0xe0, /* Ouch, the same as GNU_push_tls_address. */ -+ DW_OP_HP_is_value = 0xe1, -+ DW_OP_HP_fltconst4 = 0xe2, -+ DW_OP_HP_fltconst8 = 0xe3, -+ DW_OP_HP_mod_range = 0xe4, -+ DW_OP_HP_unmod_range = 0xe5, -+ DW_OP_HP_tls = 0xe6 -+ }; -+ -+#define DW_OP_lo_user 0xe0 /* Implementation-defined range start. */ -+#define DW_OP_hi_user 0xff /* Implementation-defined range end. */ -+ -+/* Type encodings. */ -+enum dwarf_type -+ { -+ DW_ATE_void = 0x0, -+ DW_ATE_address = 0x1, -+ DW_ATE_boolean = 0x2, -+ DW_ATE_complex_float = 0x3, -+ DW_ATE_float = 0x4, -+ DW_ATE_signed = 0x5, -+ DW_ATE_signed_char = 0x6, -+ DW_ATE_unsigned = 0x7, -+ DW_ATE_unsigned_char = 0x8, -+ /* DWARF 3. */ -+ DW_ATE_imaginary_float = 0x9, -+ DW_ATE_packed_decimal = 0xa, -+ DW_ATE_numeric_string = 0xb, -+ DW_ATE_edited = 0xc, -+ DW_ATE_signed_fixed = 0xd, -+ DW_ATE_unsigned_fixed = 0xe, -+ DW_ATE_decimal_float = 0xf, -+ /* HP extensions. */ -+ DW_ATE_HP_float80 = 0x80, /* Floating-point (80 bit). */ -+ DW_ATE_HP_complex_float80 = 0x81, /* Complex floating-point (80 bit). */ -+ DW_ATE_HP_float128 = 0x82, /* Floating-point (128 bit). */ -+ DW_ATE_HP_complex_float128 = 0x83, /* Complex floating-point (128 bit). */ -+ DW_ATE_HP_floathpintel = 0x84, /* Floating-point (82 bit IA64). */ -+ DW_ATE_HP_imaginary_float80 = 0x85, -+ DW_ATE_HP_imaginary_float128 = 0x86 -+ }; -+ -+#define DW_ATE_lo_user 0x80 -+#define DW_ATE_hi_user 0xff -+ -+/* Decimal sign encodings. */ -+enum dwarf_decimal_sign_encoding -+ { -+ /* DWARF 3. */ -+ DW_DS_unsigned = 0x01, -+ DW_DS_leading_overpunch = 0x02, -+ DW_DS_trailing_overpunch = 0x03, -+ DW_DS_leading_separate = 0x04, -+ DW_DS_trailing_separate = 0x05 -+ }; -+ -+/* Endianity encodings. */ -+enum dwarf_endianity_encoding -+ { -+ /* DWARF 3. */ -+ DW_END_default = 0x00, -+ DW_END_big = 0x01, -+ DW_END_little = 0x02 -+ }; -+ -+#define DW_END_lo_user 0x40 -+#define DW_END_hi_user 0xff -+ -+/* Array ordering names and codes. */ -+enum dwarf_array_dim_ordering -+ { -+ DW_ORD_row_major = 0, -+ DW_ORD_col_major = 1 -+ }; -+ -+/* Access attribute. */ -+enum dwarf_access_attribute -+ { -+ DW_ACCESS_public = 1, -+ DW_ACCESS_protected = 2, -+ DW_ACCESS_private = 3 -+ }; -+ -+/* Visibility. */ -+enum dwarf_visibility_attribute -+ { -+ DW_VIS_local = 1, -+ DW_VIS_exported = 2, -+ DW_VIS_qualified = 3 -+ }; -+ -+/* Virtuality. */ -+enum dwarf_virtuality_attribute -+ { -+ DW_VIRTUALITY_none = 0, -+ DW_VIRTUALITY_virtual = 1, -+ DW_VIRTUALITY_pure_virtual = 2 -+ }; -+ -+/* Case sensitivity. */ -+enum dwarf_id_case -+ { -+ DW_ID_case_sensitive = 0, -+ DW_ID_up_case = 1, -+ DW_ID_down_case = 2, -+ DW_ID_case_insensitive = 3 -+ }; -+ -+/* Calling convention. */ -+enum dwarf_calling_convention -+ { -+ DW_CC_normal = 0x1, -+ DW_CC_program = 0x2, -+ DW_CC_nocall = 0x3, -+ DW_CC_GNU_renesas_sh = 0x40 -+ }; -+ -+#define DW_CC_lo_user 0x40 -+#define DW_CC_hi_user 0xff -+ -+/* Inline attribute. */ -+enum dwarf_inline_attribute -+ { -+ DW_INL_not_inlined = 0, -+ DW_INL_inlined = 1, -+ DW_INL_declared_not_inlined = 2, -+ DW_INL_declared_inlined = 3 -+ }; -+ -+/* Discriminant lists. */ -+enum dwarf_discrim_list -+ { -+ DW_DSC_label = 0, -+ DW_DSC_range = 1 -+ }; -+ -+/* Line number opcodes. */ -+enum dwarf_line_number_ops -+ { -+ DW_LNS_extended_op = 0, -+ DW_LNS_copy = 1, -+ DW_LNS_advance_pc = 2, -+ DW_LNS_advance_line = 3, -+ DW_LNS_set_file = 4, -+ DW_LNS_set_column = 5, -+ DW_LNS_negate_stmt = 6, -+ DW_LNS_set_basic_block = 7, -+ DW_LNS_const_add_pc = 8, -+ DW_LNS_fixed_advance_pc = 9, -+ /* DWARF 3. */ -+ DW_LNS_set_prologue_end = 10, -+ DW_LNS_set_epilogue_begin = 11, -+ DW_LNS_set_isa = 12 -+ }; -+ -+/* Line number extended opcodes. */ -+enum dwarf_line_number_x_ops -+ { -+ DW_LNE_end_sequence = 1, -+ DW_LNE_set_address = 2, -+ DW_LNE_define_file = 3, -+ /* HP extensions. */ -+ DW_LNE_HP_negate_is_UV_update = 0x11, -+ DW_LNE_HP_push_context = 0x12, -+ DW_LNE_HP_pop_context = 0x13, -+ DW_LNE_HP_set_file_line_column = 0x14, -+ DW_LNE_HP_set_routine_name = 0x15, -+ DW_LNE_HP_set_sequence = 0x16, -+ DW_LNE_HP_negate_post_semantics = 0x17, -+ DW_LNE_HP_negate_function_exit = 0x18, -+ DW_LNE_HP_negate_front_end_logical = 0x19, -+ DW_LNE_HP_define_proc = 0x20 -+ }; -+ -+#define DW_LNE_lo_user 0x80 -+#define DW_LNE_hi_user 0xff -+ -+/* Call frame information. */ -+enum dwarf_call_frame_info -+ { -+ DW_CFA_advance_loc = 0x40, -+ DW_CFA_offset = 0x80, -+ DW_CFA_restore = 0xc0, -+ DW_CFA_nop = 0x00, -+ DW_CFA_set_loc = 0x01, -+ DW_CFA_advance_loc1 = 0x02, -+ DW_CFA_advance_loc2 = 0x03, -+ DW_CFA_advance_loc4 = 0x04, -+ DW_CFA_offset_extended = 0x05, -+ DW_CFA_restore_extended = 0x06, -+ DW_CFA_undefined = 0x07, -+ DW_CFA_same_value = 0x08, -+ DW_CFA_register = 0x09, -+ DW_CFA_remember_state = 0x0a, -+ DW_CFA_restore_state = 0x0b, -+ DW_CFA_def_cfa = 0x0c, -+ DW_CFA_def_cfa_register = 0x0d, -+ DW_CFA_def_cfa_offset = 0x0e, -+ /* DWARF 3. */ -+ DW_CFA_def_cfa_expression = 0x0f, -+ DW_CFA_expression = 0x10, -+ DW_CFA_offset_extended_sf = 0x11, -+ DW_CFA_def_cfa_sf = 0x12, -+ DW_CFA_def_cfa_offset_sf = 0x13, -+ DW_CFA_val_offset = 0x14, -+ DW_CFA_val_offset_sf = 0x15, -+ DW_CFA_val_expression = 0x16, -+ /* SGI/MIPS specific. */ -+ DW_CFA_MIPS_advance_loc8 = 0x1d, -+ /* GNU extensions. */ -+ DW_CFA_GNU_window_save = 0x2d, -+ DW_CFA_GNU_args_size = 0x2e, -+ DW_CFA_GNU_negative_offset_extended = 0x2f -+ }; -+ -+#define DW_CIE_ID 0xffffffff -+#define DW_CIE_VERSION 1 -+ -+#define DW_CFA_extended 0 -+#define DW_CFA_lo_user 0x1c -+#define DW_CFA_hi_user 0x3f -+ -+#define DW_CHILDREN_no 0x00 -+#define DW_CHILDREN_yes 0x01 -+ -+#define DW_ADDR_none 0 -+ -+/* Source language names and codes. */ -+enum dwarf_source_language -+ { -+ DW_LANG_C89 = 0x0001, -+ DW_LANG_C = 0x0002, -+ DW_LANG_Ada83 = 0x0003, -+ DW_LANG_C_plus_plus = 0x0004, -+ DW_LANG_Cobol74 = 0x0005, -+ DW_LANG_Cobol85 = 0x0006, -+ DW_LANG_Fortran77 = 0x0007, -+ DW_LANG_Fortran90 = 0x0008, -+ DW_LANG_Pascal83 = 0x0009, -+ DW_LANG_Modula2 = 0x000a, -+ /* DWARF 3. */ -+ DW_LANG_Java = 0x000b, -+ DW_LANG_C99 = 0x000c, -+ DW_LANG_Ada95 = 0x000d, -+ DW_LANG_Fortran95 = 0x000e, -+ DW_LANG_PLI = 0x000f, -+ DW_LANG_ObjC = 0x0010, -+ DW_LANG_ObjC_plus_plus = 0x0011, -+ DW_LANG_UPC = 0x0012, -+ DW_LANG_D = 0x0013, -+ /* MIPS. */ -+ DW_LANG_Mips_Assembler = 0x8001, -+ /* UPC. */ -+ DW_LANG_Upc = 0x8765 -+ }; -+ -+#define DW_LANG_lo_user 0x8000 /* Implementation-defined range start. */ -+#define DW_LANG_hi_user 0xffff /* Implementation-defined range start. */ -+ -+/* Names and codes for macro information. */ -+enum dwarf_macinfo_record_type -+ { -+ DW_MACINFO_define = 1, -+ DW_MACINFO_undef = 2, -+ DW_MACINFO_start_file = 3, -+ DW_MACINFO_end_file = 4, -+ DW_MACINFO_vendor_ext = 255 -+ }; -+ -+/* @@@ For use with GNU frame unwind information. */ -+ -+#define DW_EH_PE_absptr 0x00 -+#define DW_EH_PE_omit 0xff -+ -+#define DW_EH_PE_uleb128 0x01 -+#define DW_EH_PE_udata2 0x02 -+#define DW_EH_PE_udata4 0x03 -+#define DW_EH_PE_udata8 0x04 -+#define DW_EH_PE_sleb128 0x09 -+#define DW_EH_PE_sdata2 0x0A -+#define DW_EH_PE_sdata4 0x0B -+#define DW_EH_PE_sdata8 0x0C -+#define DW_EH_PE_signed 0x08 -+ -+#define DW_EH_PE_pcrel 0x10 -+#define DW_EH_PE_textrel 0x20 -+#define DW_EH_PE_datarel 0x30 -+#define DW_EH_PE_funcrel 0x40 -+#define DW_EH_PE_aligned 0x50 -+ -+#define DW_EH_PE_indirect 0x80 -+ -+#endif /* _ELF_DWARF2_H */ -Index: odcctools-9.2-ld/as/as.h -=================================================================== ---- odcctools-9.2-ld.orig/as/as.h 2013-09-03 21:08:01.409209526 +0000 -+++ odcctools-9.2-ld/as/as.h 2013-09-03 21:08:01.897209515 +0000 -@@ -20,6 +20,13 @@ - #ifndef AS_H_ - #define AS_H_ - -+extern char *apple_flags; -+#define APPLE_INC_VERSION "Apple Inc version" -+/* apple_version is in apple_version.c which is created by the Makefile */ -+extern char apple_version[]; -+/* the GNU version is set in as.c */ -+extern char version_string[]; -+ - #define _(String) (String) - #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) - -@@ -135,6 +142,26 @@ - /* What subseg we are accessing now? */ - extern subsegT now_subseg; - -+/* Type of debugging information we should generate. We currently support -+ stabs, ECOFF, and DWARF2. -+ -+ NOTE! This means debug information about the assembly source code itself -+ and _not_ about possible debug information from a high-level language. -+ This is especially relevant to DWARF2, since the compiler may emit line -+ number directives that the assembler resolves. */ -+ -+enum debug_info_type -+{ -+ DEBUG_UNSPECIFIED, -+ DEBUG_NONE, -+ DEBUG_STABS, -+ DEBUG_ECOFF, -+ DEBUG_DWARF, -+ DEBUG_DWARF2 -+}; -+ -+extern enum debug_info_type debug_type; -+ - /* - * main program "as.c" (command arguments etc) - */ -@@ -155,7 +182,7 @@ - extern char *specific_archflag; - - /* TRUE if the .subsections_via_symbols directive was seen */ --int subsections_via_symbols; -+extern int subsections_via_symbols; - - /* -I path options for .includes */ - struct directory_stack { -Index: odcctools-9.2-ld/as/frags.c -=================================================================== ---- odcctools-9.2-ld.orig/as/frags.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/frags.c 2013-09-03 21:08:01.897209515 +0000 -@@ -23,6 +23,7 @@ - #include "obstack.h" - #include "frags.h" - #include "messages.h" -+#include "input-scrub.h" - - struct obstack frags = { 0 }; /* All, and only, frags live here. */ - -@@ -30,6 +31,7 @@ - - fragS zero_address_frag = { - 0, /* fr_address */ -+ 0, /* last_fr_address */ - NULL, /* fr_next */ - 0, /* fr_fix */ - 0, /* fr_var */ -@@ -38,7 +40,11 @@ - NULL, /* fr_opcode */ - rs_fill, /* fr_type */ - 0, /* fr_subtype */ -+#ifdef ARM -+ 0 /* fr_literal [0] */ -+#else - {0} /* fr_literal [0] */ -+#endif - }; - - -@@ -61,13 +67,14 @@ - } - if ((int)(obstack_room(&frags)) < nchars) { - unsigned int n,oldn; -- long oldc; -+ int32_t oldc; - - frag_wane (frag_now); - frag_new (0); - oldn=(unsigned)-1; - oldc=frags.chunk_size; -- frags.chunk_size=2*nchars; -+ if(2*nchars > oldc) -+ frags.chunk_size=2*nchars; - while((int)(n=obstack_room(&frags)) < nchars && n < oldn) { - frag_wane(frag_now); - frag_new(0); -@@ -104,7 +111,7 @@ - register fragS * former_last_fragP; - /* char *throw_away_pointer; JF unused */ - register frchainS * frchP; -- long tmp; /* JF */ -+ int32_t tmp; /* JF */ - - if(frags.chunk_size == 0){ - know(flagseen['n']); -@@ -116,7 +123,7 @@ - (frag_now->fr_literal) - old_frags_var_max_size; - /* Fix up old frag's fr_fix. */ - -- obstack_finish (&frags); -+ (void)obstack_finish (&frags); - /* This will align the obstack so the */ - /* next struct we allocate on it will */ - /* begin at a correct boundary. */ -@@ -190,11 +197,14 @@ - int var, - relax_substateT subtype, - symbolS *symbol, --long offset, -+int32_t offset, - char *opcode) - { - register char *retval; - -+#ifdef ARM -+ as_file_and_line (&frag_now->fr_file, &frag_now->fr_line); -+#endif /* ARM */ - frag_grow (max_chars); - retval = obstack_next_free (&frags); - obstack_blank_fast (&frags, max_chars); -@@ -205,6 +215,9 @@ - frag_now->fr_offset = offset; - frag_now->fr_opcode = opcode; - frag_new (max_chars); -+#ifdef ARM -+ as_file_and_line (&frag_now->fr_file, &frag_now->fr_line); -+#endif /* ARM */ - return (retval); - } /* frag_var() */ - -@@ -272,7 +285,7 @@ - fill_size, /* var */ - (relax_substateT)max_bytes_to_fill,/* subtype */ - (symbolS *)0, /* symbol */ -- (long)power_of_2_alignment, /* offset */ -+ (int32_t)power_of_2_alignment, /* offset */ - (char *)0); /* opcode */ - if(fill_size == 1 || fill_size == 2 || fill_size == 4) - memcpy(fr_literal, fill, fill_size); -Index: odcctools-9.2-ld/as/frags.h -=================================================================== ---- odcctools-9.2-ld.orig/as/frags.h 2013-09-03 21:08:01.405209526 +0000 -+++ odcctools-9.2-ld/as/frags.h 2013-09-03 21:08:01.901209515 +0000 -@@ -41,27 +41,38 @@ - */ - struct frag /* a code fragment */ - { -- unsigned long fr_address; /* Object file address. */ -+ uint64_t fr_address; /* Object file address. */ -+ uint64_t last_fr_address; /* When relaxing multiple times, remember the */ -+ /* address the frag had in the last relax pass*/ - struct frag *fr_next; /* Chain forward; ascending address order. */ - /* Rooted in frch_root. */ - -- long fr_fix; /* (Fixed) number of chars we know we have. */ -+ int32_t fr_fix; /* (Fixed) number of chars we know we have. */ - /* May be 0. */ -- long fr_var; /* (Variable) number of chars after above. */ -+ int32_t fr_var; /* (Variable) number of chars after above. */ - /* May be 0. */ - struct symbol *fr_symbol; /* For variable-length tail. */ -- long fr_offset; /* For variable-length tail. */ -+ int32_t fr_offset; /* For variable-length tail. */ - char *fr_opcode; /* ->opcode low addr byte,for relax()ation*/ - relax_stateT fr_type; /* What state is my tail in? */ - relax_substateT fr_subtype; /* Used to index in to md_relax_table for */ - /* fr_type == rs_machine_dependent frags. */ -+#ifdef ARM -+ /* Where the frag was created, or where it became a variant frag. */ -+ char *fr_file; -+ unsigned int fr_line; -+ /* Flipped each relax pass so we can easily determine whether -+ fr_address has been adjusted. */ -+ unsigned int relax_marker:1, -+ pad:31; -+#endif /* ARM */ - char fr_literal[1]; /* Chars begin here. */ - /* One day we will compile fr_literal[0]. */ - }; - - /* We want to say fr_literal[0] below */ - #define SIZEOF_STRUCT_FRAG \ -- ((int)zero_address_frag.fr_literal - (int)&zero_address_frag) -+ ((uintptr_t)zero_address_frag.fr_literal - (uintptr_t)&zero_address_frag) - - /* - * frag_now points at the current frag we are building. This frag is incomplete. -@@ -93,7 +104,7 @@ - int var, - relax_substateT subtype, - symbolS *symbol, -- long offset, -+ int32_t offset, - char *opcode); - extern void frag_wane( - fragS *fragP); -@@ -114,6 +125,6 @@ - frag_wane (frag_now); \ - frag_new (0); \ - } \ -- obstack_1grow( &frags, datum ); \ -+ (void)obstack_1grow( &frags, datum ); \ - } - #endif /* _FRAGS_H_ */ -Index: odcctools-9.2-ld/as/input-file.c -=================================================================== ---- odcctools-9.2-ld.orig/as/input-file.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/input-file.c 2013-09-03 21:08:01.901209515 +0000 -@@ -147,11 +147,13 @@ - - char * - input_file_give_next_buffer( --char *where) /* Where to place 1st character of new buffer. */ -+char *where, /* Where to place 1st character of new buffer. */ -+int *give_next_size) - { - char * return_value; /* -> Last char of what we read, + 1. */ - register int size; - -+ *give_next_size = BUFFER_SIZE; - if (f_in == (FILE *)0) - return 0; - /* -Index: odcctools-9.2-ld/as/input-file.h -=================================================================== ---- odcctools-9.2-ld.orig/as/input-file.h 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/input-file.h 2013-09-03 21:08:01.901209515 +0000 -@@ -34,14 +34,16 @@ - * - * input_file_open(name) Call once for each input file. - * -- * input_file_give_next_buffer(where) Call once to get each new buffer. -- * Return 0: no more chars left in file, -+ * input_file_give_next_buffer(where, Call once to get each new buffer. -+ * give_next_size) Return 0: no more chars left in file, - * the file has already been closed. - * Otherwise: return a pointer to just - * after the last character we read - * into the buffer. - * If we can only read 0 characters, then - * end-of-file is faked. -+ * give_next_size is the BUFFER_SIZE it -+ * will use next. - * - * All errors are reported (using as_perror) so caller doesn't have to think - * about I/O errors. No I/O errors are fatal: an end-of-file may be faked. -@@ -65,4 +67,5 @@ - char *filename, - int pre); - extern char *input_file_give_next_buffer( -- char *where); -+ char *where, -+ int *give_next_size); -Index: odcctools-9.2-ld/as/input-scrub.c -=================================================================== ---- odcctools-9.2-ld.orig/as/input-scrub.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/input-scrub.c 2013-09-03 21:08:01.901209515 +0000 -@@ -113,7 +113,7 @@ - - buffer_length = input_file_buffer_size (); - -- buffer_start = xmalloc ((long)(BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE)); -+ buffer_start = xmalloc ((size_t)(BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE)); - memcpy(buffer_start, BEFORE_STRING, (int)BEFORE_SIZE); - - /* Line number things. */ -@@ -177,6 +177,7 @@ - char **bufp) - { - register char * limit; /* -> just after last char of buffer. */ -+ int give_next_size; - - if (partial_size) - { -@@ -184,11 +185,12 @@ - memcpy(buffer_start + BEFORE_SIZE, save_source, (int)AFTER_SIZE); - } - get_more: -- limit = input_file_give_next_buffer (buffer_start + BEFORE_SIZE + partial_size); -+ limit = input_file_give_next_buffer( -+ buffer_start + BEFORE_SIZE + partial_size, -+ &give_next_size); - if (limit) - { - register char * p; /* Find last newline. */ -- - for (p = limit; * -- p != '\n'; ) - { - } -@@ -199,9 +201,19 @@ - - new = limit - (buffer_start + BEFORE_SIZE + partial_size); - partial_size += new; -+ -+ /* -+ * If there is enough room left in this buffer for what -+ * input_file_give_next_buffer() will need don't reallocate as we -+ * could run out of memory needlessly. -+ */ -+ if((BEFORE_SIZE + buffer_length * 2) - (limit - buffer_start) > -+ give_next_size) -+ goto get_more; -+ - buffer_length = buffer_length * 2; - buffer_start = xrealloc (buffer_start, -- (long)(BEFORE_SIZE + buffer_length + -+ (size_t)(BEFORE_SIZE + buffer_length + - buffer_length + AFTER_SIZE)); - *bufp = buffer_start + BEFORE_SIZE; - goto get_more; -@@ -392,30 +404,11 @@ - - #ifdef NeXT_MOD /* .include feature */ - /* DJA -- added for .include pseudo op support */ --void --read_an_include_file( -+char * -+find_an_include_file( - char *no_path_name) - { -- char * buffer; -- char * last_buffer_limit; -- char * last_buffer_start; -- int last_doing_include; -- FILE * last_f_in; -- char * last_file_name; -- char * last_input_line_pointer; -- char * last_logical_input_file; -- line_numberT last_logical_input_line; -- int last_partial_size; -- char * last_partial_where; -- char * last_physical_input_file; -- line_numberT last_physical_input_line; -- char last_save_source [AFTER_SIZE]; -- int last_buffer_length; --#if 0 -- char * last_save_buffer; --#endif - char name_buffer [MAXPATHLEN]; -- scrub_context_data scrub_context; - register struct directory_stack * the_path_pointer; - register char * whole_file_name; - -@@ -471,9 +464,42 @@ - the_path_pointer++; - } - as_fatal ("Couldn't find the include file: \"%s\"", no_path_name); -- return; -+ return (NULL); - } - found: -+ return (whole_file_name); -+} -+ -+void -+read_an_include_file( -+char *no_path_name) -+{ -+ char * buffer; -+ char * last_buffer_limit; -+ char * last_buffer_start; -+ int last_doing_include; -+ FILE * last_f_in; -+ char * last_file_name; -+ char * last_input_line_pointer; -+ char * last_logical_input_file; -+ line_numberT last_logical_input_line; -+ int last_partial_size; -+ char * last_partial_where; -+ char * last_physical_input_file; -+ line_numberT last_physical_input_line; -+ char last_save_source [AFTER_SIZE]; -+ int last_buffer_length; -+#if 0 -+ char * last_save_buffer; -+#endif -+ scrub_context_data scrub_context; -+ register char * whole_file_name; -+ -+ /* -+ * figure out what directory the file name is in. -+ */ -+ whole_file_name = find_an_include_file (no_path_name); -+ - /* - * save a copy of the file state for a recursive call to read a file - */ -Index: odcctools-9.2-ld/as/input-scrub.h -=================================================================== ---- odcctools-9.2-ld.orig/as/input-scrub.h 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/input-scrub.h 2013-09-03 21:08:01.901209515 +0000 -@@ -45,5 +45,7 @@ - char *filename); - extern char *input_scrub_next_buffer( - char **bufp); -+extern char *find_an_include_file( -+ char *no_path_name); - extern void read_an_include_file( - char *no_path_name); -Index: odcctools-9.2-ld/as/layout.c -=================================================================== ---- odcctools-9.2-ld.orig/as/layout.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/layout.c 2013-09-03 21:08:01.901209515 +0000 -@@ -30,6 +30,7 @@ - #include "md.h" - #include "obstack.h" - #include "input-scrub.h" -+#include "dwarf2dbg.h" - #if I386 - #include "i386.h" - #endif -@@ -67,6 +68,8 @@ - (0) - #endif - -+extern int arm_relax_frag (int nsect, fragS *fragp, int32_t stretch); -+ - #endif /* ARM */ - - /* FROM write.c line 96 */ -@@ -77,15 +80,79 @@ - static void fixup_section( - fixS *fixP, - int nsect); --static void relax_section( -+#ifndef SPARC -+static int is_assembly_time_constant_subtraction_expression( -+ symbolS *add_symbolP, -+ int add_symbol_nsect, -+ symbolS *sub_symbolP, -+ int sub_symbol_nsect); -+#endif /* !defined(SPARC) */ -+static int relax_section( - struct frag *section_frag_root, - int nsect); - static relax_addressT relax_align( - relax_addressT address, -- long alignment); -+ uint32_t alignment); -+#ifndef ARM - static int is_down_range( - struct frag *f1, - struct frag *f2); -+#endif /* !defined(ARM) */ -+ -+/* -+ * add_last_frags_to_sections() does what layout_addresses() does below about -+ * adding a last ".fill 0" frag to each section. This is called by -+ * dwarf2_finish() allow get_frag_fix() in dwarf2dbg.c to work for the last -+ * fragment in a section. -+ */ -+void -+add_last_frags_to_sections( -+void) -+{ -+ struct frchain *frchainP; -+ -+ if(frchain_root == NULL) -+ return; -+ -+ /* -+ * If there is any current frag close it off. -+ */ -+ if(frag_now != NULL && frag_now->fr_fix == 0){ -+ frag_now->fr_fix = obstack_next_free(&frags) - -+ frag_now->fr_literal; -+ frag_wane(frag_now); -+ } -+ -+ /* -+ * For every section, add a last ".fill 0" frag that will later be used -+ * as the ending address of that section. -+ */ -+ for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){ -+ /* -+ * We must do the obstack_finish(), so the next object we put on -+ * obstack frags will not appear to start at the fr_literal of the -+ * current frag. Also, it ensures that the next object will begin -+ * on a address that is aligned correctly for the engine that runs -+ * the assembler. -+ */ -+ (void)obstack_finish(&frags); -+ -+ /* -+ * Make a fresh frag for the last frag. -+ */ -+ frag_now = (fragS *)obstack_alloc(&frags, SIZEOF_STRUCT_FRAG); -+ memset(frag_now, '\0', SIZEOF_STRUCT_FRAG); -+ frag_now->fr_next = NULL; -+ (void)obstack_finish(&frags); -+ -+ /* -+ * Append the new frag to current frchain. -+ */ -+ frchainP->frch_last->fr_next = frag_now; -+ frchainP->frch_last = frag_now; -+ frag_wane(frag_now); -+ } -+} - - /* - * layout_addresses() is called after all the assembly code has been read and -@@ -101,8 +168,10 @@ - fragS *fragP; - relax_addressT slide, tmp; - symbolS *symbolP; -- unsigned long nbytes, fill_size, repeat_expression, partial_bytes; -+ uint32_t nbytes, fill_size, repeat_expression, partial_bytes, layout_pass; -+ uint32_t section_type; - relax_stateT old_fr_type; -+ int changed; - - if(frchain_root == NULL) - return; -@@ -128,7 +197,7 @@ - * on a address that is aligned correctly for the engine that runs - * the assembler. - */ -- obstack_finish(&frags); -+ (void)obstack_finish(&frags); - - /* - * Make a fresh frag for the last frag. -@@ -136,7 +205,7 @@ - frag_now = (fragS *)obstack_alloc(&frags, SIZEOF_STRUCT_FRAG); - memset(frag_now, '\0', SIZEOF_STRUCT_FRAG); - frag_now->fr_next = NULL; -- obstack_finish(&frags); -+ (void)obstack_finish(&frags); - - /* - * Append the new frag to current frchain. -@@ -152,18 +221,47 @@ - * relaxing each section. That is all sections will start at address - * zero and addresses of the frags in that section will increase from - * there. -+ * -+ * The debug sections are done last as other section are needed to be -+ * done first becase debug sections may have line numbers with .loc -+ * directives in them and their sizes need to be set before processing -+ * the line number sections. We also do sections that have rs_leb128s -+ * in them before debug sections but after other sections since they -+ * are used for things like exception tables and they may be refering to -+ * sections such that their sizes too must be known first. - */ - for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){ -- if((frchainP->frch_section.flags & SECTION_TYPE) == S_ZEROFILL) -- continue; -- /* -- * This is done so in case md_estimate_size_before_relax() (called -- * by relax_section) wants to make fixSs they are for this -- * section. -- */ -- frchain_now = frchainP; -+ if((frchainP->frch_section.flags & S_ATTR_DEBUG) == S_ATTR_DEBUG) -+ frchainP->layout_pass = 2; -+ else if(frchainP->has_rs_leb128s == TRUE) -+ frchainP->layout_pass = 1; -+ else -+ frchainP->layout_pass = 0; -+ } -+ for(layout_pass = 0; layout_pass < 3; layout_pass++){ -+ do{ -+ changed = 0; -+ for(frchainP = frchain_root; -+ frchainP; -+ frchainP = frchainP->frch_next){ -+ if(frchainP->layout_pass != layout_pass) -+ continue; -+ section_type = frchainP->frch_section.flags & SECTION_TYPE; -+ if(section_type == S_ZEROFILL || -+ section_type == S_THREAD_LOCAL_ZEROFILL) -+ continue; -+ /* -+ * This is done so in case md_estimate_size_before_relax() -+ * (called by relax_section) wants to make fixSs they are -+ * for this section. -+ */ -+ frchain_now = frchainP; - -- relax_section(frchainP->frch_root, frchainP->frch_nsect); -+ changed += relax_section(frchainP->frch_root, -+ frchainP->frch_nsect); -+ } -+ } -+ while(changed != 0); - } - - /* -@@ -173,7 +271,9 @@ - */ - slide = 0; - for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){ -- if((frchainP->frch_section.flags & SECTION_TYPE) == S_ZEROFILL) -+ section_type = frchainP->frch_section.flags & SECTION_TYPE; -+ if(section_type == S_ZEROFILL || -+ section_type == S_THREAD_LOCAL_ZEROFILL) - continue; - slide = round(slide, 1 << frchainP->frch_section.align); - tmp = frchainP->frch_last->fr_address; -@@ -192,7 +292,9 @@ - * is that section numbers do not end up in address order. - */ - for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){ -- if((frchainP->frch_section.flags & SECTION_TYPE) != S_ZEROFILL) -+ section_type = frchainP->frch_section.flags & SECTION_TYPE; -+ if(section_type != S_ZEROFILL && -+ section_type != S_THREAD_LOCAL_ZEROFILL) - continue; - slide = round(slide, 1 << frchainP->frch_section.align); - -@@ -248,8 +350,8 @@ - nbytes = fragP->fr_next->fr_address - - fragP->fr_address - - fragP->fr_fix; -- if(nbytes < 0){ -- as_warn("rs_org invalid, dot past value by %ld bytes", -+ if((int)nbytes < 0){ -+ as_warn("rs_org invalid, dot past value by %d bytes", - nbytes); - nbytes = 0; - } -@@ -322,6 +424,49 @@ - frag_wane(fragP); - break; - -+ case rs_dwarf2dbg: -+ dwarf2dbg_convert_frag(fragP); -+ break; -+ -+ case rs_leb128: -+ { -+ int size; -+#ifdef OLD -+ valueT value = S_GET_VALUE (fragP->fr_symbol); -+#else -+ valueT value; -+ expressionS *expression; -+ -+ if(fragP->fr_symbol->expression != NULL){ -+ expression = -+ (expressionS *)fragP->fr_symbol->expression; -+ value = 0; -+ if(expression->X_add_symbol != NULL) -+ value += expression->X_add_symbol->sy_nlist.n_value; -+ if(expression->X_subtract_symbol != NULL) -+ value -= -+ expression->X_subtract_symbol->sy_nlist.n_value; -+ value += expression->X_add_number; -+ } -+ else{ -+ value = fragP->fr_symbol->sy_nlist.n_value + -+ fragP->fr_address; -+ } -+#endif -+ -+ size = output_leb128 (fragP->fr_literal + fragP->fr_fix, -+ value, -+ fragP->fr_subtype); -+ -+ fragP->fr_fix += size; -+ fragP->fr_type = rs_fill; -+ fragP->fr_var = 0; -+ fragP->fr_offset = 0; -+ fragP->fr_symbol = NULL; -+ } -+ break; -+ -+ - default: - BAD_CASE(fragP->fr_type); - break; -@@ -352,10 +497,10 @@ - { - symbolS *add_symbolP; - symbolS *sub_symbolP; -- long value; -+ signed_expr_t value; - int size; - char *place; -- long where; -+ int32_t where; - char pcrel; - fragS *fragP; - int add_symbol_N_TYPE; -@@ -399,7 +544,6 @@ - /* If the symbol is defined in this file, the linker won't set the - low-order bit for a Thumb symbol, so we have to do it here. */ - if(add_symbolP != NULL && add_symbolP->sy_desc & N_ARM_THUMB_DEF && -- !(add_symbolP->sy_desc & N_WEAK_DEF) && - !(sub_symbolP != NULL && sub_symbolP->sy_desc & N_ARM_THUMB_DEF) && - !pcrel){ - value |= 1; -@@ -452,6 +596,20 @@ - */ - else if((sub_symbolP->sy_type & N_TYPE) == N_SECT && - (add_symbolP->sy_type & N_TYPE) == N_SECT){ -+#if defined(I386) && !defined(ARCH64) -+ /* -+ * For 'symbol@TLVP - subtract_symbol' type relocations the -+ * subtract_symbol value is stored in the contents of the -+ * item to be relocated. -+ */ -+ if(fixP->fx_r_type == GENERIC_RELOC_TLV){ -+ value += fixP->fx_frag->fr_address + where + -+ fixP->fx_size - sub_symbolP->sy_value; -+ fixP->fx_subsy = NULL; /* no SECTDIFF reloc entry */ -+ fixP->fx_pcrel = TRUE; /* force pcrel */ -+ goto down; -+ } -+#endif - /* - * We are use the new features that are incompatible with - * 3.2 then just calculate the value and let this create a -@@ -474,7 +632,7 @@ - } - else{ - as_warn("Can't emit reloc type %u {-symbol \"%s\"} " -- "@ file address %ld (mode?).", -+ "@ file address %llu (mode?).", - fixP->fx_r_type, sub_symbolP->sy_name, - fragP->fr_address + where); - } -@@ -488,13 +646,60 @@ - * the difference between the two symbols because - * that's handled by the subtractor/vanilla reloc pair. - */ -- value += add_symbolP->sy_value - sub_symbolP->sy_value; -+ value += add_symbolP->sy_value; -+ value -= sub_symbolP->sy_value; -+#else -+ /* -+ * But for x86_64 expressions in the debug section must -+ * be the actual value of the expression. -+ */ -+ if(is_section_debug(nsect)){ -+ value += add_symbolP->sy_value; -+ value -= sub_symbolP->sy_value; -+ } - #endif - sub_symbol_nsect = sub_symbolP->sy_other; -+ /* -+ * If we have the special assembly time constant expression -+ * of the difference of two symbols defined in the same -+ * section then divided by exactly 2 adjust the value and -+ * make sure these symbols will produce an assembly time -+ * constant. -+ */ -+ if(fixP->fx_sectdiff_divide_by_two == 1){ -+ value = value / 2; -+ if(is_assembly_time_constant_subtraction_expression( -+ add_symbolP, add_symbol_nsect, -+ sub_symbolP, sub_symbol_nsect) == TRUE){ -+ fixP->fx_addsy = NULL; /* no relocation entry */ -+ goto down; -+ } -+ else{ -+ layout_line = fixP->line; -+ layout_file = fixP->file; -+ as_warn("section difference divide by two " -+ "expression, \"%s\" minus \"%s\" divide by " -+ "2 will not produce an assembly time " -+ "constant", add_symbolP->sy_name, -+ sub_symbolP->sy_name); -+ } -+ } - if(is_end_section_address(add_symbol_nsect, - add_symbolP->sy_value) || - is_end_section_address(sub_symbol_nsect, - sub_symbolP->sy_value)){ -+ if(is_assembly_time_constant_subtraction_expression( -+ add_symbolP, add_symbol_nsect, -+ sub_symbolP, sub_symbol_nsect) == TRUE){ -+ fixP->fx_addsy = NULL; /* no relocation entry */ -+ goto down; -+ } -+ if(is_section_debug(nsect) && -+ strcmp(add_symbolP->sy_name, FAKE_LABEL_NAME) == 0 && -+ strcmp(sub_symbolP->sy_name, FAKE_LABEL_NAME) == 0){ -+ fixP->fx_addsy = NULL; /* no relocation entry */ -+ goto down; -+ } - layout_line = fixP->line; - layout_file = fixP->file; - as_warn("section difference relocatable subtraction " -@@ -521,6 +726,19 @@ - value -= sub_symbolP->sy_value; - fixP->fx_subsy = NULL; /* no SECTDIFF relocation entry */ - } -+#if defined(I386) && !defined(ARCH64) -+ /* -+ * For 'symbol@TLVP - subtract_symbol' type relocations the -+ * subtract_symbol value is stored in the contents of the item -+ * to be relocated. -+ */ -+ else if(fixP->fx_r_type == GENERIC_RELOC_TLV){ -+ value += fixP->fx_frag->fr_address + where + fixP->fx_size - -+ sub_symbolP->sy_value; -+ fixP->fx_subsy = NULL; /* no SECTDIFF relocation entry */ -+ fixP->fx_pcrel = TRUE; /* force pcrel */ -+ } -+#endif - /* - * At this point we have something we can't generate a - * relocation entry for (two undefined symbols, etc.). -@@ -568,7 +786,7 @@ - value += add_symbolP->sy_value; - #ifdef ARM - /* FROM write.c line 2667 */ -- value -= where + fragP->fr_address; -+ value -= MD_PCREL_FROM_SECTION (fixP, nsect); - #else - value -= size + where + fragP->fr_address; - #endif -@@ -623,9 +841,15 @@ - is_local_symbol(add_symbolP) && - !is_section_cstring_literals(add_symbol_nsect)) ) - #else -- if((add_symbolP->sy_type & N_EXT) != N_EXT || -- add_symbol_N_TYPE != N_SECT || -- !is_section_coalesced(add_symbol_nsect)) -+ if(((add_symbolP->sy_type & N_EXT) != N_EXT || -+ add_symbol_N_TYPE != N_SECT || -+ !is_section_coalesced(add_symbol_nsect)) && -+ (add_symbolP->sy_desc & N_WEAK_DEF) != N_WEAK_DEF -+#if defined(I386) && !defined(ARCH64) -+ && -+ fixP->fx_r_type != GENERIC_RELOC_TLV -+#endif -+ ) - #endif - value += add_symbolP->sy_value; - break; -@@ -662,10 +886,15 @@ - - if((size == 1 && (value & 0xffffff00) && - ((value & 0xffffff80) != 0xffffff80)) || -- (size == 2 && (value & 0xffff8000) && -- ((value & 0xffff8000) != 0xffff8000))) -- as_bad("Fixup of %ld too large for field width of %d", -+ (size == 2 && (value & 0xffff0000) && -+ ((value & 0xffff8000) != 0xffff8000))){ -+ layout_line = fixP->line; -+ layout_file = fixP->file; -+ as_bad("Fixup of %lld too large for field width of %d", - value, size); -+ layout_line = 0; -+ layout_file = NULL; -+ } - - /* - * Now place the fix expression's value in the place for the size. -@@ -702,6 +931,134 @@ - } - } - -+#ifndef SPARC -+/* -+ * is_assembly_time_constant_subtraction_expression() is passed the symbols and -+ * section numbers of a subtraction expression invloving symbols both defined in -+ * some section. If the subtraction expression is an assembly time constant -+ * value then this returns 1 (TRUE) else this returns 0 (FALSE). -+ * -+ * Since the static link editor can break apart a section this routine can only -+ * return TRUE when it is known for sure these symbols will not be moved apart -+ * from each other. So this is an assembly time constant subtraction expression -+ * if the following are all true: -+ * - the expression's symbols are assembly temporary symbols (starting with 'L') -+ * - assembly temporary symbol are not being saved (no -L flag) -+ * - the two symbols are in the same section -+ * - the section is a regular section or coalesced section (non-literal section) -+ * - there are no non-assembly temporary symbols defined between two symbols of -+ * the expression. For example if the assembly code is: -+ * L1: nop -+ * foo: nop -+ * L2: nop -+ * the expression is L1-L2 is not an assembly time constant because the block -+ * of code after foo (including the address of L2) could be link edited away -+ * from the block of code with L1. -+ */ -+static -+int -+is_assembly_time_constant_subtraction_expression( -+symbolS *add_symbolP, -+int add_symbol_nsect, -+symbolS *sub_symbolP, -+int sub_symbol_nsect) -+{ -+ struct frchain *frchainP; -+ uint32_t section_type, section_attributes; -+ symbolS *prev_symbol; -+ int non_assembly_temporary_symbol; -+ -+ /* see if both symbols are assembly temporary symbols */ -+ if(add_symbolP->sy_name == NULL || add_symbolP->sy_name[0] != 'L' || -+ sub_symbolP->sy_name == NULL || sub_symbolP->sy_name[0] != 'L') -+ return(0); -+ -+ /* make sure we are not saving assembly temporary symbols */ -+ if(flagseen[(int)'L']) -+ return(0); -+ -+ /* make sure the two symbols are in the same section */ -+ if(add_symbol_nsect != sub_symbol_nsect) -+ return(0); -+ -+ /* make sure the section is a regular or coalesced section */ -+ section_attributes = 0; -+ for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){ -+ if(frchainP->frch_nsect == add_symbol_nsect){ -+ section_type = frchainP->frch_section.flags & SECTION_TYPE; -+ section_attributes = frchainP->frch_section.flags & -+ SECTION_ATTRIBUTES; -+ if(section_type == S_REGULAR || section_type == S_COALESCED) -+ break; -+ else -+ return(0); -+ } -+ } -+ -+ /* -+ * See if we can find the chain of symbols from the add_symbolP through -+ * its previous symbols to the sub_symbolP. And check for non assembler -+ * temporary symbols along that chain. -+ */ -+ non_assembly_temporary_symbol = 0; -+ for(prev_symbol = add_symbolP->sy_prev_by_index; -+ prev_symbol != NULL; -+ prev_symbol = prev_symbol->sy_prev_by_index){ -+ if((prev_symbol->sy_type & N_SECT) == N_SECT && -+ (prev_symbol->sy_type & N_STAB) == 0 && -+ prev_symbol->sy_other == add_symbol_nsect){ -+ if(prev_symbol == sub_symbolP){ -+ if(non_assembly_temporary_symbol == 0) -+ return(1); -+ else -+ return(0); -+ } -+ if(prev_symbol->sy_name != NULL && -+ prev_symbol->sy_name[0] != 'L') -+ non_assembly_temporary_symbol = 1; -+ } -+ } -+ -+ /* -+ * Couldn't find the chain above, so now try we can find the chain of -+ * symbols from the sub_symbolP through its previous symbols to the -+ * add_symbolP. And check for non assembler temporary symbols along -+ * that chain. -+ */ -+ non_assembly_temporary_symbol = 0; -+ for(prev_symbol = sub_symbolP->sy_prev_by_index; -+ prev_symbol != NULL; -+ prev_symbol = prev_symbol->sy_prev_by_index){ -+ if((prev_symbol->sy_type & N_SECT) == N_SECT && -+ (prev_symbol->sy_type & N_STAB) == 0 && -+ prev_symbol->sy_other == sub_symbol_nsect){ -+ if(prev_symbol == add_symbolP){ -+ if(non_assembly_temporary_symbol == 0) -+ return(1); -+ else -+ return(0); -+ } -+ if(prev_symbol->sy_name != NULL && -+ prev_symbol->sy_name[0] != 'L') -+ non_assembly_temporary_symbol = 1; -+ } -+ } -+ -+ /* -+ * It is possible that this expression is coming from a dwarf section -+ * made from .file and .loc directives. If so both symbols would have -+ * the FAKE_LABEL_NAME and the section_type would be -+ * and in this case the then the expression is an assembly time -+ * constant. -+ */ -+ if((section_attributes & S_ATTR_DEBUG) == S_ATTR_DEBUG && -+ strcmp(add_symbolP->sy_name, FAKE_LABEL_NAME) == 0 && -+ strcmp(sub_symbolP->sy_name, FAKE_LABEL_NAME) == 0) -+ return(1); -+ -+ return(0); -+} -+#endif /* !defined(SPARC) */ - - /* - * relax_section() here we set the fr_address values in the frags. -@@ -711,7 +1068,7 @@ - * are know then they can be slid to their final address. - */ - static --void -+int - relax_section( - struct frag *frag_root, - int nsect) -@@ -719,30 +1076,34 @@ - struct frag *fragP; - relax_addressT address; - -- long stretch; /* May be any size, 0 or negative. */ -- /* Cumulative number of addresses we have */ -- /* relaxed this pass. */ -- /* We may have relaxed more than one address. */ -- long stretched; /* Have we stretched on this pass? */ -+ int32_t stretch; /* May be any size, 0 or negative. */ -+ /* Cumulative number of addresses we have */ -+ /* relaxed this pass. */ -+ /* We may have relaxed more than one address. */ -+ int32_t stretched; /* Have we stretched on this pass? */ - /* This is 'cuz stretch may be zero, when, - in fact some piece of code grew, and - another shrank. If a branch instruction - doesn't fit anymore, we need another pass */ - -+#ifndef ARM - const relax_typeS *this_type; - const relax_typeS *start_type; - relax_substateT next_state; - relax_substateT this_state; -+ int32_t aim; -+#endif /* !defined(ARM) */ - -- long growth; -- unsigned long was_address; -- long offset; -+ int32_t growth; -+ uint32_t was_address; -+ int32_t offset; - symbolS *symbolP; -- long target; -- long after; -- long aim; -- unsigned long oldoff, newoff; -+ int32_t target; -+ int32_t after; -+ uint32_t oldoff, newoff; -+ int ret; - -+ ret = 0; - growth = 0; - - /* -@@ -750,6 +1111,9 @@ - */ - address = 0; - for(fragP = frag_root; fragP != NULL; fragP = fragP->fr_next){ -+#ifdef ARM -+ fragP->relax_marker = 0; -+#endif /* ARM */ - fragP->fr_address = address; - address += fragP->fr_fix; - switch(fragP->fr_type){ -@@ -767,12 +1131,12 @@ - * section's alignment. - */ - if(fragP->fr_subtype != 0){ -- if(offset > (long)fragP->fr_subtype){ -+ if(offset > (int32_t)fragP->fr_subtype){ - offset = 0; - } - else{ - if(frchain_now->frch_section.align < -- (unsigned long)fragP->fr_offset) -+ (uint32_t)fragP->fr_offset) - frchain_now->frch_section.align = fragP->fr_offset; - } - } -@@ -789,6 +1153,16 @@ - address += md_estimate_size_before_relax(fragP, nsect); - break; - -+ case rs_dwarf2dbg: -+ address += dwarf2dbg_estimate_size_before_relax(fragP); -+ break; -+ -+ case rs_leb128: -+ /* Initial guess is always 1; doing otherwise can result in -+ stable solutions that are larger than the minimum. */ -+ address += fragP->fr_offset = 1; -+ break; -+ - default: - BAD_CASE(fragP->fr_type); - break; -@@ -806,6 +1180,9 @@ - stretch = 0; - stretched = 0; - for(fragP = frag_root; fragP != NULL; fragP = fragP->fr_next){ -+#ifdef ARM -+ fragP->relax_marker ^= 1; -+#endif /* ARM */ - was_address = fragP->fr_address; - fragP->fr_address += stretch; - address = fragP->fr_address; -@@ -855,6 +1232,9 @@ - break; - - case rs_machine_dependent: -+#ifdef ARM -+ growth = arm_relax_frag(nsect, fragP, stretch); -+#else /* !defined(ARM) */ - this_state = fragP->fr_subtype; - this_type = md_relax_table + this_state; - start_type = this_type; -@@ -906,6 +1286,45 @@ - } - if((growth = this_type->rlx_length -start_type->rlx_length)) - fragP->fr_subtype = this_state; -+#endif /* !defined(ARM) */ -+ break; -+ case rs_dwarf2dbg: -+ growth = dwarf2dbg_relax_frag(fragP); -+ break; -+ -+ case rs_leb128: -+ { -+ valueT value; -+ offsetT size; -+#ifdef OLD -+ value = resolve_symbol_value (fragP->fr_symbol); -+#else -+ expressionS *expression; -+ -+ if(fragP->fr_symbol->expression != NULL){ -+ expression = -+ (expressionS *)fragP->fr_symbol->expression; -+ value = 0; -+ if(expression->X_add_symbol != NULL) -+ value += -+ (expression->X_add_symbol->sy_nlist.n_value + -+ expression->X_add_symbol->sy_frag->fr_address); -+ if(expression->X_subtract_symbol != NULL) -+ value -= -+ (expression->X_subtract_symbol->sy_nlist.n_value + -+ expression->X_subtract_symbol-> -+ sy_frag->fr_address); -+ value += expression->X_add_number; -+ } -+ else{ -+ value = fragP->fr_symbol->sy_nlist.n_value + -+ fragP->fr_address; -+ } -+#endif -+ size = sizeof_leb128 (value, fragP->fr_subtype); -+ growth = size - fragP->fr_offset; -+ fragP->fr_offset = size; -+ } - break; - - default: -@@ -924,6 +1343,14 @@ - * are correct, relative to their own section. We have made all the - * fixS for this section that will be made. - */ -+ -+ for(fragP = frag_root; fragP != NULL; fragP = fragP->fr_next){ -+ if(fragP->last_fr_address != fragP->fr_address){ -+ fragP->last_fr_address = fragP->fr_address; -+ ret = 1; -+ } -+ } -+ return(ret); - } - - /* -@@ -934,7 +1361,7 @@ - relax_addressT /* How many addresses does the .align take? */ - relax_align( - relax_addressT address, /* Address now. */ --long alignment) /* Alignment (binary). */ -+uint32_t alignment) /* Alignment (binary). */ - { - relax_addressT mask; - relax_addressT new_address; -@@ -944,6 +1371,7 @@ - return(new_address - address); - } - -+#ifndef ARM - /* - * is_down_range() is used in relax_section() to determine it one fragment is - * after another to know if it will also be moved if the first is moved. -@@ -961,3 +1389,4 @@ - } - return(0); - } -+#endif /* !defined(ARM) */ -Index: odcctools-9.2-ld/as/layout.h -=================================================================== ---- odcctools-9.2-ld.orig/as/layout.h 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/layout.h 2013-09-03 21:08:01.901209515 +0000 -@@ -1,2 +1,4 @@ -+extern void add_last_frags_to_sections( -+ void); - extern void layout_addresses( - void); -Index: odcctools-9.2-ld/as/messages.c -=================================================================== ---- odcctools-9.2-ld.orig/as/messages.c 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/messages.c 2013-09-03 21:08:01.901209515 +0000 -@@ -243,6 +243,32 @@ - } - - /* -+ * Like as_warn_where but the file name and optional line number and column -+ * are passed in. -+ */ -+void -+as_warn_where_with_column (char *file, unsigned int line, unsigned int column, const char *format, ...) -+{ -+ va_list args; -+ -+ if (!flagseen['W']) -+ { -+ print_architecture_banner(); -+ fprintf(stderr, "%s:", file); -+ if (line) -+ { -+ fprintf(stderr, "%u:", line); -+ if (column) -+ fprintf(stderr, "%u:", column); -+ } -+ va_start (args, format); -+ vfprintf(stderr, format, args); -+ fprintf(stderr, "\n"); -+ va_end (args); -+ } -+} -+ -+/* - * a s _ b a d ( ) - * - * Send to stderr a string as a warning, * and locate warning in input file(s). -Index: odcctools-9.2-ld/as/messages.h -=================================================================== ---- odcctools-9.2-ld.orig/as/messages.h 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/as/messages.h 2013-09-03 21:08:01.901209515 +0000 -@@ -21,6 +21,13 @@ - const char *format, - ...) __attribute__ ((format (printf, 3, 4))); - -+extern void as_warn_where_with_column( -+ char *file, -+ unsigned int line, -+ unsigned int column, -+ const char *format, -+ ...) __attribute__ ((format (printf, 4, 5))); -+ - extern void as_bad( - const char *format, - ...) __attribute__ ((format (printf, 1, 2))); -Index: odcctools-9.2-ld/include/mach-o/reloc.h -=================================================================== ---- odcctools-9.2-ld.orig/include/mach-o/reloc.h 2013-09-03 21:08:00.933209537 +0000 -+++ odcctools-9.2-ld/include/mach-o/reloc.h 2013-09-03 21:08:01.901209515 +0000 -@@ -196,7 +196,8 @@ - GENERIC_RELOC_PAIR, /* Only follows a GENERIC_RELOC_SECTDIFF */ - GENERIC_RELOC_SECTDIFF, - GENERIC_RELOC_PB_LA_PTR, /* prebound lazy pointer */ -- GENERIC_RELOC_LOCAL_SECTDIFF -+ GENERIC_RELOC_LOCAL_SECTDIFF, -+ GENERIC_RELOC_TLV /* thread local variables */ - }; - - #endif /* _MACHO_RELOC_H_ */ diff --git a/recipes-devtools/odcctools/files/fix-280.patch b/recipes-devtools/odcctools/files/fix-280.patch deleted file mode 100644 index 3ac8fbf..0000000 --- a/recipes-devtools/odcctools/files/fix-280.patch +++ /dev/null @@ -1,194 +0,0 @@ -Index: odcctools-9.2-ld/ld64/src/MachOReaderRelocatable.hpp -=================================================================== ---- odcctools-9.2-ld.orig/ld64/src/MachOReaderRelocatable.hpp 2013-08-15 14:29:30.863784082 +0000 -+++ odcctools-9.2-ld/ld64/src/MachOReaderRelocatable.hpp 2013-08-15 14:29:30.931784083 +0000 -@@ -28,6 +28,7 @@ - #include <stdint.h> - #include <math.h> - #include <unistd.h> -+#include <stdio.h> - #include <sys/param.h> - #include <mach-o/ppc/reloc.h> - #include <mach-o/stab.h> -@@ -123,6 +124,21 @@ - Kinds fKind; - }; - -+class BaseAtom : public ObjectFile::Atom -+{ -+public: -+ BaseAtom() : fStabsStartIndex(0), fStabsCount(0) {} -+ -+ virtual void setSize(uint64_t size) = 0; -+ virtual void addReference(ObjectFile::Reference* ref) = 0; -+ virtual void addLineInfo(const ObjectFile::LineInfo& info) = 0; -+ virtual void alignAtLeast(uint8_t align) = 0; -+ -+ uint32_t fStabsStartIndex; -+ uint32_t fStabsCount; -+}; -+ -+ - - template <typename A> - Reference<A>::Reference(Kinds kind, const AtomAndOffset& at, const AtomAndOffset& toTarget) -@@ -213,19 +229,6 @@ - DataSegment DataSegment::fgSingleton; - - --class BaseAtom : public ObjectFile::Atom --{ --public: -- BaseAtom() : fStabsStartIndex(0), fStabsCount(0) {} -- -- virtual void setSize(uint64_t size) = 0; -- virtual void addReference(ObjectFile::Reference* ref) = 0; -- virtual void addLineInfo(const ObjectFile::LineInfo& info) = 0; -- virtual void alignAtLeast(uint8_t align) = 0; -- -- uint32_t fStabsStartIndex; -- uint32_t fStabsCount; --}; - - - // -Index: odcctools-9.2-ld/ld64/src/MachOWriterExecutable.hpp -=================================================================== ---- odcctools-9.2-ld.orig/ld64/src/MachOWriterExecutable.hpp 2013-08-15 14:29:30.863784082 +0000 -+++ odcctools-9.2-ld/ld64/src/MachOWriterExecutable.hpp 2013-08-15 14:29:30.935784083 +0000 -@@ -5029,6 +5029,30 @@ - } - - template <> -+StubHelperAtom<x86_64>::StubHelperAtom(Writer<x86_64>& writer, ObjectFile::Atom& target, ObjectFile::Atom& lazyPointer) -+ : WriterAtom<x86_64>(writer, Segment::fgTextSegment), fName(stubName(target.getName())), fTarget(target) -+{ -+ writer.fAllSynthesizedStubHelpers.push_back(this); -+ -+ fReferences.push_back(new WriterReference<x86_64>(3, x86_64::kPCRel32, &lazyPointer)); -+ fReferences.push_back(new WriterReference<x86_64>(8, x86_64::kPCRel32, writer.fDyldHelper)); -+ if ( writer.fDyldHelper == NULL ) -+ throw "symbol dyld_stub_binding_helper not defined (usually in crt1.o/dylib1.o/bundle1.o)"; -+} -+ -+// specialize lazy pointer for x86_64 to initially pointer to stub helper -+template <> -+LazyPointerAtom<x86_64>::LazyPointerAtom(Writer<x86_64>& writer, ObjectFile::Atom& target) -+ : WriterAtom<x86_64>(writer, Segment::fgDataSegment), fName(lazyPointerName(target.getName())), fTarget(target) -+{ -+ writer.fAllSynthesizedLazyPointers.push_back(this); -+ -+ StubHelperAtom<x86_64>* helper = new StubHelperAtom<x86_64>(writer, target, *this); -+ fReferences.push_back(new WriterReference<x86_64>(0, x86_64::kPointer, helper)); -+} -+ -+ -+template <> - StubAtom<x86_64>::StubAtom(Writer<x86_64>& writer, ObjectFile::Atom& target) - : WriterAtom<x86_64>(writer, Segment::fgTextSegment), fName(stubName(target.getName())), fTarget(target) - { -@@ -5165,20 +5189,6 @@ - return "__jump_table"; - } - -- -- --template <> --StubHelperAtom<x86_64>::StubHelperAtom(Writer<x86_64>& writer, ObjectFile::Atom& target, ObjectFile::Atom& lazyPointer) -- : WriterAtom<x86_64>(writer, Segment::fgTextSegment), fName(stubName(target.getName())), fTarget(target) --{ -- writer.fAllSynthesizedStubHelpers.push_back(this); -- -- fReferences.push_back(new WriterReference<x86_64>(3, x86_64::kPCRel32, &lazyPointer)); -- fReferences.push_back(new WriterReference<x86_64>(8, x86_64::kPCRel32, writer.fDyldHelper)); -- if ( writer.fDyldHelper == NULL ) -- throw "symbol dyld_stub_binding_helper not defined (usually in crt1.o/dylib1.o/bundle1.o)"; --} -- - template <> - uint64_t StubHelperAtom<x86_64>::getSize() const - { -@@ -5211,17 +5221,6 @@ - } - - --// specialize lazy pointer for x86_64 to initially pointer to stub helper --template <> --LazyPointerAtom<x86_64>::LazyPointerAtom(Writer<x86_64>& writer, ObjectFile::Atom& target) -- : WriterAtom<x86_64>(writer, Segment::fgDataSegment), fName(lazyPointerName(target.getName())), fTarget(target) --{ -- writer.fAllSynthesizedLazyPointers.push_back(this); -- -- StubHelperAtom<x86_64>* helper = new StubHelperAtom<x86_64>(writer, target, *this); -- fReferences.push_back(new WriterReference<x86_64>(0, x86_64::kPointer, helper)); --} -- - - template <typename A> - LazyPointerAtom<A>::LazyPointerAtom(Writer<A>& writer, ObjectFile::Atom& target) -Index: odcctools-9.2-ld/ld64/src/Options.cpp -=================================================================== ---- odcctools-9.2-ld.orig/ld64/src/Options.cpp 2013-08-15 14:29:30.863784082 +0000 -+++ odcctools-9.2-ld/ld64/src/Options.cpp 2013-08-15 14:29:30.935784083 +0000 -@@ -29,6 +29,10 @@ - #include <fcntl.h> - #include <ctype.h> - #include <vector> -+#include <stdio.h> -+#include <unistd.h> -+#include <string.h> -+#include <limits.h> - #include "config.h" - - #include "strlcpy.h" -Index: odcctools-9.2-ld/ld64/src/SectCreate.cpp -=================================================================== ---- odcctools-9.2-ld.orig/ld64/src/SectCreate.cpp 2013-08-15 14:29:30.863784082 +0000 -+++ odcctools-9.2-ld/ld64/src/SectCreate.cpp 2013-08-15 14:29:30.935784083 +0000 -@@ -23,7 +23,10 @@ - */ - - #include <vector> -- -+#include <stdio.h> -+#include <unistd.h> -+#include <time.h> -+#include <string.h> - #include "ObjectFile.h" - - namespace SectCreate { -Index: odcctools-9.2-ld/ld64/Makefile.in -=================================================================== ---- odcctools-9.2-ld.orig/ld64/Makefile.in 2013-08-15 14:29:30.863784082 +0000 -+++ odcctools-9.2-ld/ld64/Makefile.in 2013-08-15 14:29:30.935784083 +0000 -@@ -37,7 +37,7 @@ - MYWARNINGS = - MYDEFS = -DDEBUG - MYLDFLAGS = -L$(top_builddir)/libstuff --MYLIBS = -lstuff -+MYLIBS = -lstuff -luuid - - MYCOMPILEFLAGS = $(WARNINGS) $(MYWARNINGS) $(DEFS) $(MYDEFS) \ - $(CPPFLAGS) $(MYINCLUDES) $(CFLAGS) $(MDYNAMICNOPIC) -Index: odcctools-9.2-ld/ld64/src/ld.cpp -=================================================================== ---- odcctools-9.2-ld.orig/ld64/src/ld.cpp 2013-08-15 11:27:10.000000000 +0000 -+++ odcctools-9.2-ld/ld64/src/ld.cpp 2013-08-15 14:38:22.975773627 +0000 -@@ -639,12 +639,12 @@ - - void Linker::getVMInfo(vm_statistics_data_t& info) - { -- mach_msg_type_number_t count = sizeof(vm_statistics_data_t) / sizeof(natural_t); -- kern_return_t error = host_statistics(mach_host_self(), HOST_VM_INFO, -- (host_info_t)&info, &count); -- if (error != KERN_SUCCESS) { -+ //mach_msg_type_number_t count = sizeof(vm_statistics_data_t) / sizeof(natural_t); -+ //kern_return_t error = host_statistics(mach_host_self(), HOST_VM_INFO, -+ // (host_info_t)&info, &count); -+ //if (error != KERN_SUCCESS) { - bzero(&info, sizeof(vm_statistics_data_t)); -- } -+ //} - } - - void Linker::printStatistics() diff --git a/recipes-devtools/odcctools/files/fix-287.patch b/recipes-devtools/odcctools/files/fix-287.patch deleted file mode 100644 index 44a1516..0000000 --- a/recipes-devtools/odcctools/files/fix-287.patch +++ /dev/null @@ -1,154 +0,0 @@ -Index: odcctools-9.2-ld/ld64/src/MachOReaderRelocatable.hpp -=================================================================== ---- odcctools-9.2-ld.orig/ld64/src/MachOReaderRelocatable.hpp 2013-08-15 16:31:17.183614865 +0000 -+++ odcctools-9.2-ld/ld64/src/MachOReaderRelocatable.hpp 2013-08-15 16:31:17.251614861 +0000 -@@ -28,6 +28,7 @@ - #include <stdint.h> - #include <math.h> - #include <unistd.h> -+#include <stdio.h> - #include <sys/param.h> - - #include <vector> -@@ -83,6 +84,25 @@ - uint32_t offset; - }; - -+class BaseAtom : public ObjectFile::Atom -+{ -+public: -+ BaseAtom() : fStabsStartIndex(0), fStabsCount(0) {} -+ -+ virtual void setSize(uint64_t size) = 0; -+ virtual void addReference(ObjectFile::Reference* ref) = 0; -+ virtual void sortReferences() = 0; -+ virtual void addLineInfo(const ObjectFile::LineInfo& info) = 0; -+ virtual uint64_t getObjectAddress() const = 0; -+ virtual uint32_t getOrdinal() const { return fOrdinal; } -+ virtual void setOrdinal(uint32_t value) { fOrdinal = value; } -+ virtual const void* getSectionRecord() const = 0; -+ virtual bool isAlias() const { return false; } -+ -+ uint32_t fStabsStartIndex; -+ uint32_t fStabsCount; -+ uint32_t fOrdinal; -+}; - - template <typename A> - class Reference : public ObjectFile::Reference -@@ -268,26 +288,6 @@ - - LinkEditSegment LinkEditSegment::fgSingleton; - --class BaseAtom : public ObjectFile::Atom --{ --public: -- BaseAtom() : fStabsStartIndex(0), fStabsCount(0) {} -- -- virtual void setSize(uint64_t size) = 0; -- virtual void addReference(ObjectFile::Reference* ref) = 0; -- virtual void sortReferences() = 0; -- virtual void addLineInfo(const ObjectFile::LineInfo& info) = 0; -- virtual uint64_t getObjectAddress() const = 0; -- virtual uint32_t getOrdinal() const { return fOrdinal; } -- virtual void setOrdinal(uint32_t value) { fOrdinal = value; } -- virtual const void* getSectionRecord() const = 0; -- virtual bool isAlias() const { return false; } -- -- uint32_t fStabsStartIndex; -- uint32_t fStabsCount; -- uint32_t fOrdinal; --}; -- - class BaseAtomSorter - { - public: -Index: odcctools-9.2-ld/ld64/src/Options.cpp -=================================================================== ---- odcctools-9.2-ld.orig/ld64/src/Options.cpp 2013-08-15 16:31:17.183614865 +0000 -+++ odcctools-9.2-ld/ld64/src/Options.cpp 2013-08-15 16:31:17.251614861 +0000 -@@ -28,6 +28,10 @@ - #include <mach/vm_prot.h> - #include <fcntl.h> - #include <vector> -+#include <stdio.h> -+#include <unistd.h> -+#include <string.h> -+#include <limits.h> - - #include "strlcpy.h" - #include "config.h" -Index: odcctools-9.2-ld/as/read.c -=================================================================== ---- odcctools-9.2-ld.orig/as/read.c 2013-08-15 11:27:09.000000000 +0000 -+++ odcctools-9.2-ld/as/read.c 2013-08-15 17:03:04.983570702 +0000 -@@ -507,7 +507,6 @@ - { "lcomm", s_lcomm, 0 }, - { "line", s_line, 0 }, - { "long", cons, 4 }, -- { "word", cons, 4 }, - { "quad", cons, 8 }, - { "lsym", s_lsym, 0 }, - { "section", s_section, 0 }, -Index: odcctools-9.2-ld/ld64/src/ld.cpp -=================================================================== ---- odcctools-9.2-ld.orig/ld64/src/ld.cpp 2013-08-15 16:31:17.183614865 +0000 -+++ odcctools-9.2-ld/ld64/src/ld.cpp 2013-08-15 16:53:09.007584481 +0000 -@@ -2926,42 +2926,42 @@ - switch (fArchitecture) { - case CPU_TYPE_POWERPC: - if ( mach_o::relocatable::Reader<ppc>::validFile(p) ) -- return this->addObject(new mach_o::relocatable::Reader<ppc>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addObject(new mach_o::relocatable::Reader<ppc>(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( mach_o::dylib::Reader<ppc>::validFile(p, info.options.fBundleLoader) ) -- return this->addDylib(new mach_o::dylib::Reader<ppc>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addDylib(new mach_o::dylib::Reader<ppc>(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( archive::Reader<ppc>::validFile(p, len) ) -- return this->addArchive(new archive::Reader<ppc>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addArchive(new archive::Reader<ppc>(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - break; - case CPU_TYPE_POWERPC64: - if ( mach_o::relocatable::Reader<ppc64>::validFile(p) ) -- return this->addObject(new mach_o::relocatable::Reader<ppc64>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addObject(new mach_o::relocatable::Reader<ppc64>(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( mach_o::dylib::Reader<ppc64>::validFile(p, info.options.fBundleLoader) ) -- return this->addDylib(new mach_o::dylib::Reader<ppc64>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addDylib(new mach_o::dylib::Reader<ppc64>(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( archive::Reader<ppc64>::validFile(p, len) ) -- return this->addArchive(new archive::Reader<ppc64>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addArchive(new archive::Reader<ppc64>(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - break; - case CPU_TYPE_I386: - if ( mach_o::relocatable::Reader<x86>::validFile(p) ) -- return this->addObject(new mach_o::relocatable::Reader<x86>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addObject(new mach_o::relocatable::Reader<x86>(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( mach_o::dylib::Reader<x86>::validFile(p, info.options.fBundleLoader) ) -- return this->addDylib(new mach_o::dylib::Reader<x86>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addDylib(new mach_o::dylib::Reader<x86>(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( archive::Reader<x86>::validFile(p, len) ) -- return this->addArchive(new archive::Reader<x86>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addArchive(new archive::Reader<x86>(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - break; - case CPU_TYPE_X86_64: - if ( mach_o::relocatable::Reader<x86_64>::validFile(p) ) -- return this->addObject(new mach_o::relocatable::Reader<x86_64>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addObject(new mach_o::relocatable::Reader<x86_64>(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( mach_o::dylib::Reader<x86_64>::validFile(p, info.options.fBundleLoader) ) -- return this->addDylib(new mach_o::dylib::Reader<x86_64>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addDylib(new mach_o::dylib::Reader<x86_64>(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( archive::Reader<x86_64>::validFile(p, len) ) -- return this->addArchive(new archive::Reader<x86_64>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addArchive(new archive::Reader<x86_64>(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - case CPU_TYPE_ARM: - if ( mach_o::relocatable::Reader<arm>::validFile(p) ) -- return this->addObject(new mach_o::relocatable::Reader<arm>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addObject(new mach_o::relocatable::Reader<arm>(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( mach_o::dylib::Reader<arm>::validFile(p, info.options.fBundleLoader) ) -- return this->addDylib(new mach_o::dylib::Reader<arm>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addDylib(new mach_o::dylib::Reader<arm>(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( archive::Reader<arm>::validFile(p, len) ) -- return this->addArchive(new archive::Reader<arm>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addArchive(new archive::Reader<arm>(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - break; - break; - } diff --git a/recipes-devtools/odcctools/files/fix-758.patch b/recipes-devtools/odcctools/files/fix-758.patch deleted file mode 100644 index af99303..0000000 --- a/recipes-devtools/odcctools/files/fix-758.patch +++ /dev/null @@ -1,41 +0,0 @@ -Index: apple-x86-odcctools-758.159/ld64/src/Options.cpp -=================================================================== ---- apple-x86-odcctools-758.159.orig/ld64/src/Options.cpp 2013-09-03 21:54:26.325145025 +0000 -+++ apple-x86-odcctools-758.159/ld64/src/Options.cpp 2013-09-03 21:54:26.581145019 +0000 -@@ -30,6 +30,10 @@ - #include <ctype.h> - #include <vector> - #include <cstdio> -+#include <stdio.h> -+#include <unistd.h> -+#include <string.h> -+#include <limits.h> - - #include "config.h" - #include "Options.h" -Index: apple-x86-odcctools-758.159/ld64/Makefile.in -=================================================================== ---- apple-x86-odcctools-758.159.orig/ld64/Makefile.in 2013-09-03 21:54:26.325145025 +0000 -+++ apple-x86-odcctools-758.159/ld64/Makefile.in 2013-09-03 21:54:26.581145019 +0000 -@@ -47,7 +47,7 @@ - -DASPROG="\"$(ASPROG)\"" $(LTO_DEFS) - - MYLDFLAGS = -L$(top_builddir)/libstuff --MYLIBS = -lstuff $(SSL_LIBS) $(UUID_LIBS) $(LTO_LIBS) -+MYLIBS = -lstuff $(SSL_LIBS) $(UUID_LIBS) $(LTO_LIBS) -ldl - - MYCOMPILEFLAGS = $(WARNINGS) $(MYWARNINGS) $(DEFS) $(MYDEFS) \ - $(CPPFLAGS) $(MYINCLUDES) $(CFLAGS) $(MDYNAMICNOPIC) -Index: apple-x86-odcctools-758.159/configure.ac -=================================================================== ---- apple-x86-odcctools-758.159.orig/configure.ac 2011-03-31 17:08:42.000000000 +0000 -+++ apple-x86-odcctools-758.159/configure.ac 2013-09-03 22:28:45.781095869 +0000 -@@ -284,7 +284,7 @@ - ) - - AC_CHECK_FUNCS([strmode qsort_r qsort getattrlist NSIsSymbolNameDefined strlcpy strlcat]) --AC_CHECK_HEADERS([CommonCrypto/CommonDigest.h],[],[SSL_LIBS=-lssl]) -+AC_CHECK_HEADERS([CommonCrypto/CommonDigest.h],[],[SSL_LIBS=-lcrypto]) - AC_SUBST(SSL_LIBS) - - AC_CHECK_DECLS([getc_unlocked, strlcpy, strlcat]) diff --git a/recipes-devtools/odcctools/files/objc.patch b/recipes-devtools/odcctools/files/objc.patch deleted file mode 100755 index 183c354..0000000 --- a/recipes-devtools/odcctools/files/objc.patch +++ /dev/null @@ -1,11 +0,0 @@ ---- apple-x86-odcctools-758.159/otool/Makefile.in 2010-02-23 21:57:20.000000000 +0100 -+++ apple-x86-odcctools-758.159-patched/otool/Makefile.in 2010-02-23 21:57:54.000000000 +0100 -@@ -48,7 +48,7 @@ - m88k_disasm.c i386_disasm.c ppc_disasm.c hppa_disasm.c \ - sparc_disasm.c arm_disasm.c - --ifneq ($(OBJC),) -+ifeq ($(HAVE_OBJC_OBJC_RUNTIME_H),YES) - OBJCFILES = print_objc.c print_objc2_32bit.c print_objc2_64bit.c - OBJCOBJS = $(OBJCFILES:.c=.o) - endif diff --git a/recipes-devtools/odcctools/files/odcctools-9.2_p287-ar.patch b/recipes-devtools/odcctools/files/odcctools-9.2_p287-ar.patch deleted file mode 100644 index e0fd7ef..0000000 --- a/recipes-devtools/odcctools/files/odcctools-9.2_p287-ar.patch +++ /dev/null @@ -1,24 +0,0 @@ -Index: ar/ar.c -=================================================================== ---- ar/ar.c (revision 287) -+++ ar/ar.c (working copy) -@@ -82,6 +82,7 @@ - - #include "archive.h" - #include "extern.h" -+#include "stuff/allocate.h" - #include "stuff/execute.h" - #include "stuff/unix_standard_mode.h" - -Index: ar/contents.c -=================================================================== ---- ar/contents.c (revision 287) -+++ ar/contents.c (working copy) -@@ -75,6 +75,7 @@ - #include <fcntl.h> - #include <stdio.h> - #include <string.h> -+#include <time.h> - #include <unistd.h> - - #include "archive.h" diff --git a/recipes-devtools/odcctools/files/odcctools-9.2_p287-as.patch b/recipes-devtools/odcctools/files/odcctools-9.2_p287-as.patch deleted file mode 100644 index 0796364..0000000 --- a/recipes-devtools/odcctools/files/odcctools-9.2_p287-as.patch +++ /dev/null @@ -1,200 +0,0 @@ -Index: as/md.h -=================================================================== ---- as/md.h (revision 287) -+++ as/md.h (working copy) -@@ -19,13 +19,12 @@ - in a file named COPYING. Among other things, the copyright - notice and this notice must be preserved on all copies. */ - --#import <mach/machine.h> --#import "stuff/bytesex.h" --#import "frags.h" --#import "relax.h" --#import "struc-symbol.h" --#import "fixes.h" --#import "read.h" -+#include <mach/machine.h> -+#include "stuff/bytesex.h" -+#include "frags.h" -+#include "struc-symbol.h" -+#include "fixes.h" -+#include "read.h" - - /* These are the default cputype and cpusubtype for this target MACHINE */ - extern const cpu_type_t md_cputype; -Index: as/frags.h -=================================================================== ---- as/frags.h (revision 287) -+++ as/frags.h (working copy) -@@ -19,9 +19,9 @@ - along with GAS; see the file COPYING. If not, write to - the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ - --#import "as.h" --#import "relax.h" --#import "struc-symbol.h" -+#include "as.h" -+#include "relax.h" -+#include "struc-symbol.h" - - /* - * A code fragment (frag) is some known number of chars, followed by some -Index: as/read.h -=================================================================== ---- as/read.h (revision 287) -+++ as/read.h (working copy) -@@ -19,7 +19,7 @@ - along with GAS; see the file COPYING. If not, write to - the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ - --#import "expr.h" -+#include "expr.h" - - /* Define to make whitespace be allowed in many syntactically - unnecessary places. Normally undefined. For compatibility with -Index: as/app.h -=================================================================== ---- as/app.h (revision 287) -+++ as/app.h (working copy) -@@ -1,4 +1,4 @@ --#import <stdio.h> -+#include <stdio.h> - - extern FILE *scrub_file; - extern char *scrub_string; -Index: as/flonum.h -=================================================================== ---- as/flonum.h (revision 287) -+++ as/flonum.h (working copy) -@@ -32,7 +32,7 @@ - * * - \***********************************************************************/ - --#import "bignum.h" -+#include "bignum.h" - - /***********************************************************************\ - * * -Index: as/struc-symbol.h -=================================================================== ---- as/struc-symbol.h (revision 287) -+++ as/struc-symbol.h (working copy) -@@ -21,7 +21,7 @@ - - #ifdef NeXT_MOD - #include "arch64_32.h" --#import <mach-o/nlist.h> -+#include <mach-o/nlist.h> - #else /* !defined(NeXT_MOD) */ - #ifndef VMS - #include "a.out.h" /* Needed to define struct nlist. Sigh. */ -Index: as/write_object.c -=================================================================== ---- as/write_object.c (revision 287) -+++ as/write_object.c (working copy) -@@ -1,3 +1,4 @@ -+#include <unistd.h> - #include <stdlib.h> - #include <string.h> - #include <ctype.h> -Index: as/expr.h -=================================================================== ---- as/expr.h (revision 287) -+++ as/expr.h (working copy) -@@ -20,9 +20,8 @@ - the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ - - #include "as.h" --#import "struc-symbol.h" --#import "bignum.h" --#import "flonum.h" -+#include "struc-symbol.h" -+#include "flonum.h" - - enum { - /* FROM expr.h line 46 */ -Index: as/atof-ieee.h -=================================================================== ---- as/atof-ieee.h (revision 287) -+++ as/atof-ieee.h (working copy) -@@ -1,4 +1,4 @@ --#import "flonum.h" -+#include "flonum.h" - - extern char *atof_ieee( - char *str, -Index: as/as.h -=================================================================== ---- as/as.h (revision 287) -+++ as/as.h (working copy) -@@ -49,11 +49,11 @@ - */ - #undef SUSPECT - --/* These #imports are for type definitions etc. */ -+/* These #includes are for type definitions etc. */ - #include <stdint.h> --#import <stdio.h> --#import <assert.h> --#import <mach/machine.h> -+#include <stdio.h> -+#include <assert.h> -+#include <mach/machine.h> - - /* These defines are potentially useful */ - #undef FALSE -Index: as/sections.c -=================================================================== ---- as/sections.c (revision 287) -+++ as/sections.c (working copy) -@@ -24,6 +24,8 @@ - * Mach-O sections are chains of fragments. - */ - #include <stdlib.h> -+#include <stdio.h> -+#include <string.h> - #include <strings.h> - #include "sections.h" - #include "obstack.h" -Index: as/driver.c -=================================================================== ---- as/driver.c (revision 287) -+++ as/driver.c (working copy) -@@ -9,6 +9,7 @@ - #include "stdio.h" - #include "stdlib.h" - #include "string.h" -+#include <unistd.h> - #include <sys/param.h> - #include <sys/file.h> - #include <mach/mach.h> -Index: as/sections.h -=================================================================== ---- as/sections.h (revision 287) -+++ as/sections.h (working copy) -@@ -17,8 +17,8 @@ - along with GAS; see the file COPYING. If not, write to - the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ - --#import <mach-o/loader.h> --#import "struc-symbol.h" -+#include <mach-o/loader.h> -+#include "struc-symbol.h" - - /* - * For every section the user mentions in the assembley program, we make one -Index: as/symbols.h -=================================================================== ---- as/symbols.h (revision 287) -+++ as/symbols.h (working copy) -@@ -17,8 +17,8 @@ - along with GAS; see the file COPYING. If not, write to - the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ - --#import "struc-symbol.h" --#import "hash.h" -+#include "struc-symbol.h" -+#include "hash.h" - - extern struct hash_control *sy_hash; - extern struct obstack notes; diff --git a/recipes-devtools/odcctools/files/odcctools-9.2_p287-includes.patch b/recipes-devtools/odcctools/files/odcctools-9.2_p287-includes.patch deleted file mode 100644 index 36c15e7..0000000 --- a/recipes-devtools/odcctools/files/odcctools-9.2_p287-includes.patch +++ /dev/null @@ -1,383 +0,0 @@ -Index: include/stuff/ofile.h -=================================================================== ---- include/stuff/ofile.h (revision 287) -+++ include/stuff/ofile.h (working copy) -@@ -29,17 +29,17 @@ - #endif - - #include "stuff/target_arch.h" --#import <ar.h> -+#include <ar.h> - #ifndef AR_EFMT1 - #define AR_EFMT1 "#1/" /* extended format #1 */ - #endif --#import <mach-o/loader.h> -+#include <mach-o/loader.h> - #ifdef OFI --#import <mach-o/dyld.h> -+#include <mach-o/dyld.h> - #endif --#import "stuff/bytesex.h" --#import "stuff/bool.h" --#import "stuff/arch.h" -+#include "stuff/bytesex.h" -+#include "stuff/bool.h" -+#include "stuff/arch.h" - - enum ofile_type { - OFILE_UNKNOWN, -Index: include/stuff/breakout.h -=================================================================== ---- include/stuff/breakout.h (revision 287) -+++ include/stuff/breakout.h (working copy) -@@ -24,7 +24,7 @@ - #define __private_extern__ __declspec(private_extern) - #endif - --#import "stuff/ofile.h" -+#include "stuff/ofile.h" - - /* - * This is used to build the table of contents of an archive. Each toc_entry -Index: include/stuff/bytesex.h -=================================================================== ---- include/stuff/bytesex.h (revision 287) -+++ include/stuff/bytesex.h (working copy) -@@ -69,12 +69,10 @@ - (((a) >> 8) & 0x0000ff00) | \ - ((unsigned int)(a) >> 24) ) - --#ifndef __LP64__ - #define SWAP_LONG(a) ( ((a) << 24) | \ - (((a) << 8) & 0x00ff0000) | \ - (((a) >> 8) & 0x0000ff00) | \ - ((unsigned long)(a) >> 24) ) --#endif - - extern long long SWAP_LONG_LONG( - long long ll); -Index: include/ar.h -=================================================================== ---- include/ar.h (revision 287) -+++ include/ar.h (working copy) -@@ -86,4 +86,9 @@ - char ar_fmag[2]; /* consistency check */ - }; - -+#ifndef HAVE_STRMODE -+#include <sys/types.h> -+void strmode(mode_t mode, char *bp); -+#endif -+ - #endif /* !_AR_H_ */ -Index: include/i386/_types.h -=================================================================== ---- include/i386/_types.h (revision 287) -+++ include/i386/_types.h (working copy) -@@ -37,8 +37,6 @@ - typedef unsigned short __uint16_t; - typedef int __int32_t; - typedef unsigned int __uint32_t; --typedef long long __int64_t; --typedef unsigned long long __uint64_t; - - typedef long __darwin_intptr_t; - typedef unsigned int __darwin_natural_t; -Index: include/foreign/architecture/i386/frame.h -=================================================================== ---- include/foreign/architecture/i386/frame.h (revision 287) -+++ include/foreign/architecture/i386/frame.h (working copy) -@@ -63,7 +63,7 @@ - } pgfault; - } err_code_t; - --#import <architecture/i386/sel.h> -+#include <architecture/i386/sel.h> - - /* - * The actual hardware exception frame -Index: include/foreign/architecture/i386/fpu.h -=================================================================== ---- include/foreign/architecture/i386/fpu.h (revision 287) -+++ include/foreign/architecture/i386/fpu.h (working copy) -@@ -121,7 +121,7 @@ - :3; - } fp_control_t; - --#import <architecture/i386/sel.h> -+#include <architecture/i386/sel.h> - - /* - * Floating point 'environment' -Index: include/foreign/objc/error.h -=================================================================== ---- include/foreign/objc/error.h (revision 287) -+++ include/foreign/objc/error.h (working copy) -@@ -43,7 +43,7 @@ - #define _OBJC_ERROR_H_ - - #include <setjmp.h> --#import <objc/objc-api.h> -+#include <objc/objc-api.h> - - - typedef struct _NXHandler { /* a node in the handler chain */ -Index: include/foreign/objc/objc-load.h -=================================================================== ---- include/foreign/objc/objc-load.h (revision 287) -+++ include/foreign/objc/objc-load.h (working copy) -@@ -28,10 +28,10 @@ - #ifndef _OBJC_LOAD_H_ - #define _OBJC_LOAD_H_ - --#import <objc/objc-class.h> -+#include <objc/objc-class.h> - --#import <mach-o/loader.h> --#import <AvailabilityMacros.h> -+#include <mach-o/loader.h> -+#include <AvailabilityMacros.h> - - /* dynamically loading Mach-O object files that contain Objective-C code */ - -Index: include/foreign/objc/hashtable.h -=================================================================== ---- include/foreign/objc/hashtable.h (revision 287) -+++ include/foreign/objc/hashtable.h (working copy) -@@ -33,7 +33,7 @@ - #warning The API in this header is obsoleted by NSHashtable.h - #endif - --#import <objc/objc.h> -+#include <objc/objc.h> - #include <stdint.h> - - /************************************************************************* -Index: include/foreign/objc/objc-runtime.h -=================================================================== ---- include/foreign/objc/objc-runtime.h (revision 287) -+++ include/foreign/objc/objc-runtime.h (working copy) -@@ -1,2 +1,2 @@ --#import <objc/runtime.h> --#import <objc/message.h> -+#include <objc/runtime.h> -+#include <objc/message.h> -Index: include/foreign/objc/Protocol.h -=================================================================== ---- include/foreign/objc/Protocol.h (revision 287) -+++ include/foreign/objc/Protocol.h (working copy) -@@ -28,7 +28,7 @@ - #ifndef _OBJC_PROTOCOL_H_ - #define _OBJC_PROTOCOL_H_ - --#import <objc/Object.h> -+#include <objc/Object.h> - - /* Warning: All of these methods will disappear in 64-bit. */ - -Index: include/foreign/objc/Object.h -=================================================================== ---- include/foreign/objc/Object.h (revision 287) -+++ include/foreign/objc/Object.h (working copy) -@@ -33,7 +33,7 @@ - #define _OBJC_OBJECT_H_ - - #include <stdarg.h> --#import <objc/objc-runtime.h> -+#include <objc/objc-runtime.h> - - #if __OBJC2__ - -Index: include/foreign/objc/objc-exception.h -=================================================================== ---- include/foreign/objc/objc-exception.h (revision 287) -+++ include/foreign/objc/objc-exception.h (working copy) -@@ -24,7 +24,7 @@ - #ifndef __OBJC_EXCEPTION_H_ - #define __OBJC_EXCEPTION_H_ - --#import <objc/objc.h> -+#include <objc/objc.h> - - // ZEROCOST_SWITCH - #if !__LP64__ || !OBJC_ZEROCOST_EXCEPTIONS -Index: include/foreign/objc/zone.h -=================================================================== ---- include/foreign/objc/zone.h (revision 287) -+++ include/foreign/objc/zone.h (working copy) -@@ -24,7 +24,7 @@ - #ifndef _OBJC_ZONE_H_ - #define _OBJC_ZONE_H_ - --#import <malloc/malloc.h> -+#incldue <malloc/malloc.h> - - typedef malloc_zone_t NXZone; - -Index: include/foreign/objc/List.h -=================================================================== ---- include/foreign/objc/List.h (revision 287) -+++ include/foreign/objc/List.h (working copy) -@@ -40,8 +40,8 @@ - - #warning The API in this header is obsoleted by NSArray. - --#import <objc/Object.h> --#import <AvailabilityMacros.h> -+#include <objc/Object.h> -+#include <AvailabilityMacros.h> - - DEPRECATED_IN_MAC_OS_X_VERSION_10_5_AND_LATER - @interface List : Object -Index: include/foreign/objc/objc.h -=================================================================== ---- include/foreign/objc/objc.h (revision 287) -+++ include/foreign/objc/objc.h (working copy) -@@ -28,8 +28,8 @@ - #ifndef _OBJC_OBJC_H_ - #define _OBJC_OBJC_H_ - --#import <objc/objc-api.h> // for OBJC_EXPORT --#import <sys/types.h> -+#include <objc/objc-api.h> // for OBJC_EXPORT -+#include <sys/types.h> - - - typedef struct objc_class *Class; -Index: include/foreign/objc/hashtable2.h -=================================================================== ---- include/foreign/objc/hashtable2.h (revision 287) -+++ include/foreign/objc/hashtable2.h (working copy) -@@ -33,7 +33,7 @@ - #warning The API in this header is obsoleted by NSHashtable.h - #endif - --#import <objc/objc.h> -+#include <objc/objc.h> - #include <stdint.h> - - /************************************************************************* -Index: include/foreign/objc/objc-class.h -=================================================================== ---- include/foreign/objc/objc-class.h (revision 287) -+++ include/foreign/objc/objc-class.h (working copy) -@@ -1,2 +1,2 @@ --#import <objc/runtime.h> --#import <objc/message.h> -+#include <objc/runtime.h> -+#include <objc/message.h> -Index: include/foreign/objc/objc-auto.h -=================================================================== ---- include/foreign/objc/objc-auto.h (revision 287) -+++ include/foreign/objc/objc-auto.h (working copy) -@@ -24,7 +24,7 @@ - #ifndef _OBJC_AUTO_H_ - #define _OBJC_AUTO_H_ - --#import <objc/objc.h> -+#include <objc/objc.h> - #include <sys/types.h> - #include <stddef.h> - #include <stdint.h> -Index: include/foreign/objc/runtime.h -=================================================================== ---- include/foreign/objc/runtime.h (revision 287) -+++ include/foreign/objc/runtime.h (working copy) -@@ -24,13 +24,13 @@ - #ifndef _OBJC_RUNTIME_H - #define _OBJC_RUNTIME_H - --#import <objc/objc.h> -+#include <objc/objc.h> - --#import <sys/types.h> --#import <stdarg.h> --#import <stdint.h> --#import <stddef.h> --#import <AvailabilityMacros.h> -+#include <sys/types.h> -+#include <stdarg.h> -+#include <stdint.h> -+#include <stddef.h> -+#include <AvailabilityMacros.h> - - - /* Types */ -Index: include/foreign/objc/message.h -=================================================================== ---- include/foreign/objc/message.h (revision 287) -+++ include/foreign/objc/message.h (working copy) -@@ -21,8 +21,8 @@ - * @APPLE_LICENSE_HEADER_END@ - */ - --#import <objc/objc.h> --#import <objc/runtime.h> -+#include <objc/objc.h> -+#include <objc/runtime.h> - - - struct objc_super { -Index: include/mach-o/nlist.h -=================================================================== ---- include/mach-o/nlist.h (revision 287) -+++ include/mach-o/nlist.h (working copy) -@@ -75,9 +75,7 @@ - */ - struct nlist { - union { --#ifndef __LP64__ - char *n_name; /* for use when in-core */ --#endif - int32_t n_strx; /* index into the string table */ - } n_un; - uint8_t n_type; /* type flag, see below */ -Index: include/mach-o/ranlib.h -=================================================================== ---- include/mach-o/ranlib.h (revision 287) -+++ include/mach-o/ranlib.h (working copy) -@@ -60,9 +60,7 @@ - struct ranlib { - union { - uint32_t ran_strx; /* string table index of */ --#ifndef __LP64__ - char *ran_name; /* symbol defined by */ --#endif - } ran_un; - uint32_t ran_off; /* library member at this offset */ - }; -Index: include/mach/mach_traps.h -=================================================================== ---- include/mach/mach_traps.h (revision 287) -+++ include/mach/mach_traps.h (working copy) -@@ -106,7 +106,6 @@ - mach_port_name_t t, - int *x); - --#if !defined(__LP64__) - /* these should go away altogether - so no 64 legacy please */ - - extern kern_return_t map_fd( -@@ -116,7 +115,6 @@ - boolean_t findspace, - vm_size_t size); - --#endif /* !defined(__LP64__) */ - - - __END_DECLS -Index: include/mach/machine.h -=================================================================== ---- include/mach/machine.h (revision 287) -+++ include/mach/machine.h (working copy) -@@ -80,8 +80,8 @@ - #ifndef _MACH_MACHINE_H_ - #define _MACH_MACHINE_H_ - --#import <mach/machine/vm_types.h> --#import <mach/boolean.h> -+#include <mach/machine/vm_types.h> -+#include <mach/boolean.h> - - /* - * For each host, there is a maximum possible number of diff --git a/recipes-devtools/odcctools/files/odcctools-9.2_p287-ld.patch b/recipes-devtools/odcctools/files/odcctools-9.2_p287-ld.patch deleted file mode 100644 index fc828b4..0000000 --- a/recipes-devtools/odcctools/files/odcctools-9.2_p287-ld.patch +++ /dev/null @@ -1,247 +0,0 @@ -Index: ld/ld.c -=================================================================== ---- ld/ld.c (revision 287) -+++ ld/ld.c (working copy) -@@ -29,7 +29,7 @@ - * miscellaneous small global routines. It also defines the global varaibles - * that are set or changed by command line arguments. - */ --#include <stdlib.h> -+#define _GNU_SOURCE - #include <string.h> - #include <stdarg.h> - #include <sys/types.h> -@@ -54,6 +54,7 @@ - #include <ar.h> - #include <mach/mach.h> - #include <mach/mach_error.h> -+#include <foreign/mach/mach_traps.h> - #include "stuff/seg_addr_table.h" - #ifndef RLD - #include "stuff/symbol_list.h" -Index: ld/arm_reloc.c -=================================================================== ---- ld/arm_reloc.c (revision 287) -+++ ld/arm_reloc.c (working copy) -@@ -57,6 +57,89 @@ - #define U_ABS(l) (((long)(l))<0 ? (unsigned long)(-(l)) : (l)) - - /* -+ * fine_reloc_arm() returns TRUE if fine relocation entry for the input_offset -+ * in the section specified is for a symbol stub for a defined external symbol -+ * that is an arm symbol and stub will not be used. This information is needed -+ * when relocating an arm branch instruction that is targetted to a symbol stub -+ * that ends up going to target the address of an arm symbol. Then in this case -+ * the branch instruction needs to be changed from a blx to a bl instruction. -+ */ -+__private_extern__ -+enum bool -+fine_reloc_arm( -+struct section_map *map, -+unsigned long input_offset) -+{ -+ struct fine_reloc *fine_reloc; -+ struct merged_symbol *merged_symbol; -+ -+ fine_reloc = fine_reloc_for_input_offset(map, input_offset); -+ if((map->s->flags & SECTION_TYPE) == S_SYMBOL_STUBS && -+ fine_reloc->indirect_defined == TRUE && -+ (filetype != MH_DYLIB || multi_module_dylib == FALSE)){ -+ merged_symbol = fine_reloc->merged_symbol; -+ if(merged_symbol != NULL) -+ return((merged_symbol->nlist.n_desc & N_ARM_THUMB_DEF) -+ != N_ARM_THUMB_DEF); -+ } -+ return(FALSE); -+} -+ -+/* -+ * fine_reloc_thumb() returns TRUE if fine relocation entry for the input_offset -+ * in the section specified is for a symbol stub for a defined external symbol -+ * that a thumb symbol and stub will not be used. This information is needed -+ * when relocating an arm branch instruction that is targetted to a symbol stub -+ * that ends up going to target the address of a thumb symbol. Then in this case -+ * the branch instruction needs to be changed to a branch and exchange -+ * instuction. -+ */ -+__private_extern__ -+enum bool -+fine_reloc_thumb( -+struct section_map *map, -+unsigned long input_offset) -+{ -+ struct fine_reloc *fine_reloc; -+ struct merged_symbol *merged_symbol; -+ -+ fine_reloc = fine_reloc_for_input_offset(map, input_offset); -+ if((map->s->flags & SECTION_TYPE) == S_SYMBOL_STUBS && -+ fine_reloc->indirect_defined == TRUE && -+ (filetype != MH_DYLIB || multi_module_dylib == FALSE)){ -+ merged_symbol = fine_reloc->merged_symbol; -+ if(merged_symbol != NULL) -+ return((merged_symbol->nlist.n_desc & N_ARM_THUMB_DEF) -+ == N_ARM_THUMB_DEF); -+ } -+ return(FALSE); -+} -+ -+/* -+ * fine_reloc_local() returns TRUE if fine relocation entry for the input_offset -+ * in the section specified is for a symbol stub for a defined local symbol. -+ */ -+__private_extern__ -+enum bool -+fine_reloc_local( -+struct section_map *map, -+unsigned long input_offset) -+{ -+ struct fine_reloc *fine_reloc; -+ struct merged_symbol *merged_symbol; -+ -+ fine_reloc = fine_reloc_for_input_offset(map, input_offset); -+ if((map->s->flags & SECTION_TYPE) == S_SYMBOL_STUBS && -+ fine_reloc->indirect_defined == TRUE && -+ (filetype != MH_DYLIB || multi_module_dylib == FALSE)){ -+ merged_symbol = fine_reloc->merged_symbol; -+ if(merged_symbol == NULL) -+ return(TRUE); -+ } -+ return(FALSE); -+} -+ -+/* - * arm_reloc() relocates the contents of the specified section for the - * relocation entries using the section map from the current object (cur_obj). - * -Index: ld/pass1.c -=================================================================== ---- ld/pass1.c (revision 287) -+++ ld/pass1.c (working copy) -@@ -29,6 +29,7 @@ - * the things that need to be merged from the input objects are merged into - * tables (for output and relocation on the second pass). - */ -+#define _GNU_SOURCE - #include <stdlib.h> - #include <stdarg.h> - #include <string.h> -@@ -6007,7 +6008,11 @@ - * symbols and if found sets *(int *)fail_p. - */ - static int -+#if __GLIBC_PREREQ(2,8) -+symbol_address_compare (const void *a_p, const void *b_p, void *fail_p) -+#else - symbol_address_compare (void *fail_p, const void *a_p, const void *b_p) -+#endif - { - const struct nlist * const * aa = a_p; - const struct nlist * a = *aa; -@@ -6158,8 +6163,11 @@ - sst = allocate (sizeof (struct nlist *) * cur_obj->symtab->nsyms); - for (i = 0; i < cur_obj->symtab->nsyms; i++) - sst[i] = st + i; -- qsort_r (sst, cur_obj->symtab->nsyms, sizeof (struct nlist *), &has_stabs, -- symbol_address_compare); -+#if __GLIBC_PREREQ(2,8) -+ qsort_r (sst, cur_obj->symtab->nsyms, sizeof (struct nlist *), symbol_address_compare, &has_stabs); -+#else -+ qsort_r (sst, cur_obj->symtab->nsyms, sizeof (struct nlist *), &has_stabs, symbol_address_compare); -+#endif - if (has_stabs) { - error_with_cur_obj("has both STABS and DWARF debugging info"); - free (sst); -Index: ld/objects.c -=================================================================== ---- ld/objects.c (revision 287) -+++ ld/objects.c (working copy) -@@ -722,89 +722,6 @@ - } - - /* -- * fine_reloc_arm() returns TRUE if fine relocation entry for the input_offset -- * in the section specified is for a symbol stub for a defined external symbol -- * that is an arm symbol and stub will not be used. This information is needed -- * when relocating an arm branch instruction that is targetted to a symbol stub -- * that ends up going to target the address of an arm symbol. Then in this case -- * the branch instruction needs to be changed from a blx to a bl instruction. -- */ --__private_extern__ --enum bool --fine_reloc_arm( --struct section_map *map, --unsigned long input_offset) --{ -- struct fine_reloc *fine_reloc; -- struct merged_symbol *merged_symbol; -- -- fine_reloc = fine_reloc_for_input_offset(map, input_offset); -- if((map->s->flags & SECTION_TYPE) == S_SYMBOL_STUBS && -- fine_reloc->indirect_defined == TRUE && -- (filetype != MH_DYLIB || multi_module_dylib == FALSE)){ -- merged_symbol = fine_reloc->merged_symbol; -- if(merged_symbol != NULL) -- return((merged_symbol->nlist.n_desc & N_ARM_THUMB_DEF) -- != N_ARM_THUMB_DEF); -- } -- return(FALSE); --} -- --/* -- * fine_reloc_thumb() returns TRUE if fine relocation entry for the input_offset -- * in the section specified is for a symbol stub for a defined external symbol -- * that a thumb symbol and stub will not be used. This information is needed -- * when relocating an arm branch instruction that is targetted to a symbol stub -- * that ends up going to target the address of a thumb symbol. Then in this case -- * the branch instruction needs to be changed to a branch and exchange -- * instuction. -- */ --__private_extern__ --enum bool --fine_reloc_thumb( --struct section_map *map, --unsigned long input_offset) --{ -- struct fine_reloc *fine_reloc; -- struct merged_symbol *merged_symbol; -- -- fine_reloc = fine_reloc_for_input_offset(map, input_offset); -- if((map->s->flags & SECTION_TYPE) == S_SYMBOL_STUBS && -- fine_reloc->indirect_defined == TRUE && -- (filetype != MH_DYLIB || multi_module_dylib == FALSE)){ -- merged_symbol = fine_reloc->merged_symbol; -- if(merged_symbol != NULL) -- return((merged_symbol->nlist.n_desc & N_ARM_THUMB_DEF) -- == N_ARM_THUMB_DEF); -- } -- return(FALSE); --} -- --/* -- * fine_reloc_local() returns TRUE if fine relocation entry for the input_offset -- * in the section specified is for a symbol stub for a defined local symbol. -- */ --__private_extern__ --enum bool --fine_reloc_local( --struct section_map *map, --unsigned long input_offset) --{ -- struct fine_reloc *fine_reloc; -- struct merged_symbol *merged_symbol; -- -- fine_reloc = fine_reloc_for_input_offset(map, input_offset); -- if((map->s->flags & SECTION_TYPE) == S_SYMBOL_STUBS && -- fine_reloc->indirect_defined == TRUE && -- (filetype != MH_DYLIB || multi_module_dylib == FALSE)){ -- merged_symbol = fine_reloc->merged_symbol; -- if(merged_symbol == NULL) -- return(TRUE); -- } -- return(FALSE); --} -- --/* - * fine_reloc_for_input_offset() returns the fine relocation entry for the - * specified input offset and the section map. - */ diff --git a/recipes-devtools/odcctools/files/odcctools-9.2_p287-ld64.patch b/recipes-devtools/odcctools/files/odcctools-9.2_p287-ld64.patch deleted file mode 100644 index 56d22c7..0000000 --- a/recipes-devtools/odcctools/files/odcctools-9.2_p287-ld64.patch +++ /dev/null @@ -1,151 +0,0 @@ -Index: ld64/src/ld.cpp -=================================================================== ---- ld64/src/ld.cpp (revision 287) -+++ ld64/src/ld.cpp (working copy) -@@ -2926,49 +2926,49 @@ - switch (fArchitecture) { - case CPU_TYPE_POWERPC: - if ( mach_o::relocatable::Reader<ppc>::validFile(p) ) -- return this->addObject(new mach_o::relocatable::Reader<ppc>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addObject(new typename mach_o::relocatable::Reader<ppc>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( mach_o::dylib::Reader<ppc>::validFile(p, info.options.fBundleLoader) ) -- return this->addDylib(new mach_o::dylib::Reader<ppc>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addDylib(new typename mach_o::dylib::Reader<ppc>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( archive::Reader<ppc>::validFile(p, len) ) -- return this->addArchive(new archive::Reader<ppc>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addArchive(new typename archive::Reader<ppc>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - break; - case CPU_TYPE_POWERPC64: - if ( mach_o::relocatable::Reader<ppc64>::validFile(p) ) -- return this->addObject(new mach_o::relocatable::Reader<ppc64>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addObject(new typename mach_o::relocatable::Reader<ppc64>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( mach_o::dylib::Reader<ppc64>::validFile(p, info.options.fBundleLoader) ) -- return this->addDylib(new mach_o::dylib::Reader<ppc64>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addDylib(new typename mach_o::dylib::Reader<ppc64>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( archive::Reader<ppc64>::validFile(p, len) ) -- return this->addArchive(new archive::Reader<ppc64>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addArchive(new typename archive::Reader<ppc64>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - break; - case CPU_TYPE_I386: - if ( mach_o::relocatable::Reader<x86>::validFile(p) ) -- return this->addObject(new mach_o::relocatable::Reader<x86>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addObject(new typename mach_o::relocatable::Reader<x86>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( mach_o::dylib::Reader<x86>::validFile(p, info.options.fBundleLoader) ) -- return this->addDylib(new mach_o::dylib::Reader<x86>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addDylib(new typename mach_o::dylib::Reader<x86>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( archive::Reader<x86>::validFile(p, len) ) -- return this->addArchive(new archive::Reader<x86>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addArchive(new typename archive::Reader<x86>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - break; - case CPU_TYPE_X86_64: - if ( mach_o::relocatable::Reader<x86_64>::validFile(p) ) -- return this->addObject(new mach_o::relocatable::Reader<x86_64>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addObject(new typename mach_o::relocatable::Reader<x86_64>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( mach_o::dylib::Reader<x86_64>::validFile(p, info.options.fBundleLoader) ) -- return this->addDylib(new mach_o::dylib::Reader<x86_64>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addDylib(new typename mach_o::dylib::Reader<x86_64>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( archive::Reader<x86_64>::validFile(p, len) ) -- return this->addArchive(new archive::Reader<x86_64>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addArchive(new typename archive::Reader<x86_64>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - case CPU_TYPE_ARM: - if ( mach_o::relocatable::Reader<arm>::validFile(p) ) -- return this->addObject(new mach_o::relocatable::Reader<arm>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addObject(new typename mach_o::relocatable::Reader<arm>::Reader(p, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( mach_o::dylib::Reader<arm>::validFile(p, info.options.fBundleLoader) ) -- return this->addDylib(new mach_o::dylib::Reader<arm>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addDylib(new typename mach_o::dylib::Reader<arm>::Reader(p, len, info.path, info.options, fOptions.readerOptions(), fNextInputOrdinal), info, len); - else if ( archive::Reader<arm>::validFile(p, len) ) -- return this->addArchive(new archive::Reader<arm>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); -+ return this->addArchive(new typename archive::Reader<arm>::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fNextInputOrdinal), info, len); - break; - break; - } - - #if LTO_SUPPORT - if ( lto::Reader::validFile(p, len, fArchitecture) ) { -- return this->addObject(new lto::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fArchitecture), info, len); -+ return this->addObject(new typename lto::Reader(p, len, info.path, info.modTime, fOptions.readerOptions(), fArchitecture), info, len); - } - else if ( !lto::Reader::loaded() && (p[0] == 'B') && (p[1] == 'C') ) { - throw "could not process object file. Looks like an llvm bitcode object file, but libLTO.dylib could not be loaded"; -Index: ld64/src/Options.h -=================================================================== ---- ld64/src/Options.h (revision 287) -+++ ld64/src/Options.h (working copy) -@@ -25,8 +25,10 @@ - #ifndef __OPTIONS__ - #define __OPTIONS__ - -- -+#include <limits.h> -+#include <stdio.h> - #include <stdint.h> -+#include <string.h> - #include <mach/machine.h> - - #include <vector> -Index: ld64/src/MachOReaderRelocatable.hpp -=================================================================== ---- ld64/src/MachOReaderRelocatable.hpp (revision 287) -+++ ld64/src/MachOReaderRelocatable.hpp (working copy) -@@ -25,6 +25,7 @@ - #ifndef __OBJECT_FILE_MACH_O__ - #define __OBJECT_FILE_MACH_O__ - -+#include <stdio.h> - #include <stdint.h> - #include <math.h> - #include <unistd.h> -@@ -84,6 +85,25 @@ - }; - - -+class BaseAtom : public ObjectFile::Atom -+{ -+public: -+ BaseAtom() : fStabsStartIndex(0), fStabsCount(0) {} -+ -+ virtual void setSize(uint64_t size) = 0; -+ virtual void addReference(ObjectFile::Reference* ref) = 0; -+ virtual void sortReferences() = 0; -+ virtual void addLineInfo(const ObjectFile::LineInfo& info) = 0; -+ virtual uint64_t getObjectAddress() const = 0; -+ virtual uint32_t getOrdinal() const { return fOrdinal; } -+ virtual void setOrdinal(uint32_t value) { fOrdinal = value; } -+ virtual const void* getSectionRecord() const = 0; -+ virtual bool isAlias() const { return false; } -+ -+ uint32_t fStabsStartIndex; -+ uint32_t fStabsCount; -+ uint32_t fOrdinal; -+}; - template <typename A> - class Reference : public ObjectFile::Reference - { -@@ -268,26 +288,7 @@ - - LinkEditSegment LinkEditSegment::fgSingleton; - --class BaseAtom : public ObjectFile::Atom --{ --public: -- BaseAtom() : fStabsStartIndex(0), fStabsCount(0) {} - -- virtual void setSize(uint64_t size) = 0; -- virtual void addReference(ObjectFile::Reference* ref) = 0; -- virtual void sortReferences() = 0; -- virtual void addLineInfo(const ObjectFile::LineInfo& info) = 0; -- virtual uint64_t getObjectAddress() const = 0; -- virtual uint32_t getOrdinal() const { return fOrdinal; } -- virtual void setOrdinal(uint32_t value) { fOrdinal = value; } -- virtual const void* getSectionRecord() const = 0; -- virtual bool isAlias() const { return false; } -- -- uint32_t fStabsStartIndex; -- uint32_t fStabsCount; -- uint32_t fOrdinal; --}; -- - class BaseAtomSorter - { - public: diff --git a/recipes-devtools/odcctools/files/odcctools-9.2_p287-libstuff.patch b/recipes-devtools/odcctools/files/odcctools-9.2_p287-libstuff.patch deleted file mode 100644 index 84b6d98..0000000 --- a/recipes-devtools/odcctools/files/odcctools-9.2_p287-libstuff.patch +++ /dev/null @@ -1,66 +0,0 @@ -Index: include/stuff/bytesex.h -=================================================================== ---- include/stuff/bytesex.h (revision 287) -+++ include/stuff/bytesex.h (working copy) -@@ -306,6 +306,10 @@ - extern void swap_arm_thread_state(struct arm_thread_state *cpu, - enum byte_sex target_byte_sex); - -+extern void swap_encryption_command( -+ struct encryption_info_command *ec, -+ enum byte_sex target_byte_sex); -+ - extern void swap_ident_command( - struct ident_command *id_cmd, - enum byte_sex target_byte_sex); -Index: libstuff/swap_headers.c -=================================================================== ---- libstuff/swap_headers.c (revision 287) -+++ libstuff/swap_headers.c (working copy) -@@ -1469,7 +1469,7 @@ - switch(flavor){ - case ARM_THREAD_STATE: - cpu = (arm_thread_state_t *)state; -- swap_arm_thread_state_t(cpu, target_byte_sex); -+ swap_arm_thread_state(cpu, target_byte_sex); - state += sizeof(arm_thread_state_t); - break; - } -Index: libstuff/writeout.c -=================================================================== ---- libstuff/writeout.c (revision 287) -+++ libstuff/writeout.c (working copy) -@@ -21,6 +21,7 @@ - * @APPLE_LICENSE_HEADER_END@ - */ - #ifndef RLD -+#include <time.h> - #include <sys/time.h> - #include <mach/mach.h> - #include "stuff/openstep_mach.h" -Index: libstuff/ofile.c -=================================================================== ---- libstuff/ofile.c (revision 287) -+++ libstuff/ofile.c (working copy) -@@ -4511,7 +4511,7 @@ - } - cpu = (arm_thread_state_t *)state; - if(swapped) -- swap_arm_thread_state_t(cpu, host_byte_sex); -+ swap_arm_thread_state(cpu, host_byte_sex); - state += sizeof(arm_thread_state_t); - break; - default: -Index: libstuff/bytesex.c -=================================================================== ---- libstuff/bytesex.c (revision 287) -+++ libstuff/bytesex.c (working copy) -@@ -2331,7 +2331,7 @@ - - __private_extern__ - void --swap_arm_thread_state_t( -+swap_arm_thread_state( - struct arm_thread_state *cpu, - enum byte_sex target_byte_sex) - { diff --git a/recipes-devtools/odcctools/files/odcctools-9.2_p287-otool.patch b/recipes-devtools/odcctools/files/odcctools-9.2_p287-otool.patch deleted file mode 100644 index 57b71b5..0000000 --- a/recipes-devtools/odcctools/files/odcctools-9.2_p287-otool.patch +++ /dev/null @@ -1,32 +0,0 @@ -Index: Makefile.in -=================================================================== ---- Makefile.in (revision 287) -+++ Makefile.in (working copy) -@@ -23,7 +23,7 @@ - $(COMPONENTS): - cd $@ && $(MAKE) - --as ar ld ld64 misc otool: libstuff -+as ar ld ld64 misc: libstuff - - clean distclean install: - for c in $(COMPONENTS); do \ -Index: configure.ac -=================================================================== ---- configure.ac (revision 287) -+++ configure.ac (working copy) -@@ -297,7 +297,7 @@ - ;; - esac - --COMPONENTS="ar as include libstuff libmacho ld $LD64 man misc otool" -+COMPONENTS="ar as include libstuff libmacho ld $LD64 man misc" - AC_SUBST([COMPONENTS], [$COMPONENTS]) - - AC_CONFIG_FILES([Makefile include/Makefile libstuff/Makefile libmacho/Makefile]) -@@ -329,5 +329,4 @@ - AC_CONFIG_FILES([ld64/Makefile]) - AC_CONFIG_FILES([man/Makefile]) - AC_CONFIG_FILES([misc/Makefile]) --AC_CONFIG_FILES([otool/Makefile]) - AC_OUTPUT diff --git a/recipes-devtools/odcctools/files/vm_types_h.patch b/recipes-devtools/odcctools/files/vm_types_h.patch deleted file mode 100755 index b4e9ae1..0000000 --- a/recipes-devtools/odcctools/files/vm_types_h.patch +++ /dev/null @@ -1,16 +0,0 @@ ---- apple-x86-odcctools-758.159/include/foreign/mach/machine/vm_types.h 2011-04-07 11:27:03.605622001 +0200 -+++ apple-x86-odcctools-758.159-patched/include/foreign/mach/machine/vm_types.h 2011-04-07 11:27:12.951666000 +0200 -@@ -6,8 +6,13 @@ - typedef uint32_t natural_t; - typedef int32_t integer_t; - -+#ifdef __i386__ - typedef natural_t vm_offset_t; - typedef natural_t vm_size_t; -+#else -+typedef uint64_t vm_offset_t; -+typedef uint64_t vm_size_t; -+#endif - - typedef uint64_t mach_vm_address_t; - typedef uint64_t mach_vm_offset_t; diff --git a/recipes-devtools/odcctools/odcctools-crosssdk_0.0.bb b/recipes-devtools/odcctools/odcctools-crosssdk_0.0.bb deleted file mode 100644 index ce7be71..0000000 --- a/recipes-devtools/odcctools/odcctools-crosssdk_0.0.bb +++ /dev/null @@ -1,32 +0,0 @@ -SRC_URI = "svn://svn.macosforge.org/repository/odcctools;protocol=http;module=trunk" -SRC_URI = "svn://iphone-dev.googlecode.com/svn/branches;protocol=http;module=odcctools-9.2-ld \ - file://fix-${SRCREV}.patch" -LICENSE = "ApplePSLicense-2.0" -SRCREV = "287" - -PV = "0.0+svnr${SRCPV}" -S = "${WORKDIR}/odcctools-9.2-ld" - -LIC_FILES_CHKSUM = "file://APPLE_LICENSE;md5=dacaafbaf91483700da837d31213a1e8" - -inherit autotools crosssdk - -PROVIDES = "virtual/${TARGET_PREFIX}binutils-crosssdk" - -EXTRA_OECONF = "--enable-ld64" -BUILD_CFLAGS += "-m32" -BUILD_LDFLAGS += "-m32" -BUILD_CXXFLAGS += "-m32" - -do_install_append () { - ln -s ../libexec ${D}${bindir}/../libexec - ln -s ${TARGET_SYS}/gcc ${D}${exec_prefix}/libexec/gcc - mv ${D}${bindir}/${TARGET_PREFIX}ld ${D}${bindir}/${TARGET_PREFIX}ld_classic - ln -s ${TARGET_PREFIX}ld64 ${D}${bindir}/${TARGET_PREFIX}ld -} - - -sysroot_stage_all_append () { - sysroot_stage_dir ${D}${bindir}/.. ${SYSROOT_DESTDIR}${bindir}/.. - sysroot_stage_dir ${D}${exec_prefix}/libexec ${SYSROOT_DESTDIR}${exec_prefix}/libexec -} diff --git a/recipes-devtools/odcctools/odcctools2-crosssdk_758.159.bb b/recipes-devtools/odcctools/odcctools2-crosssdk_758.159.bb deleted file mode 100644 index 35df22c..0000000 --- a/recipes-devtools/odcctools/odcctools2-crosssdk_758.159.bb +++ /dev/null @@ -1,29 +0,0 @@ -SRC_URI = "file://apple-x86-odcctools_758.159-0flosoft11.tar.gz \ - file://odcctools-9.2_p287-ld64.patch;pnum=0 \ - file://objc.patch \ - file://fix-758.patch \ - file://vm_types_h.patch \ - file://as.patch \ - file://arch_c.patch " -LICENSE = "ApplePSLicense-2.0" - -S = "${WORKDIR}/apple-x86-odcctools-758.159" - -LIC_FILES_CHKSUM = "file://APPLE_LICENSE;md5=dacaafbaf91483700da837d31213a1e8" - -inherit autotools crosssdk - -DEPENDS += "util-linux-native openssl-native" -PROVIDES = "virtual/${TARGET_PREFIX}binutils-crosssdk" - -#EXTRA_OECONF = "--enable-ld64" - -do_install_append () { - ln -s ../libexec ${D}${bindir}/../libexec - ln -s ${TARGET_SYS}/gcc ${D}${exec_prefix}/libexec/gcc -} - -sysroot_stage_all_append () { - sysroot_stage_dir ${D}${bindir}/.. ${SYSROOT_DESTDIR}${bindir}/.. - sysroot_stage_dir ${D}${exec_prefix}/libexec ${SYSROOT_DESTDIR}${exec_prefix}/libexec -} diff --git a/recipes-devtools/opkg-utils/opkg-utils_%.bbappend b/recipes-devtools/opkg-utils/opkg-utils_%.bbappend new file mode 100644 index 0000000..88ed55a --- /dev/null +++ b/recipes-devtools/opkg-utils/opkg-utils_%.bbappend @@ -0,0 +1,3 @@ +PACKAGECONFIG:darwin21:class-nativesdk = "update-alternatives" + +RDEPENDS:opkg-utils:class-nativesdk = "" diff --git a/recipes-devtools/osx-runtime/files/remove_unsupported_attribute_availability_with_message_for_gcc.patch b/recipes-devtools/osx-runtime/files/remove_unsupported_attribute_availability_with_message_for_gcc.patch deleted file mode 100644 index ea2de5c..0000000 --- a/recipes-devtools/osx-runtime/files/remove_unsupported_attribute_availability_with_message_for_gcc.patch +++ /dev/null @@ -1,115 +0,0 @@ -Index: OSX-sdk/System/Library/Frameworks/CoreFoundation.framework/Headers/CFAvailability.h -=================================================================== ---- OSX-sdk.orig/System/Library/Frameworks/CoreFoundation.framework/Headers/CFAvailability.h -+++ OSX-sdk/System/Library/Frameworks/CoreFoundation.framework/Headers/CFAvailability.h -@@ -23,110 +23,6 @@ - #define __has_extension(x) 0 - #endif - --// The arguments to these availability macros is a version number, e.g. 10_6, 3_0 or 'NA' --// To use a deprecation message with the macro, add a string as the last argument. --#if __has_feature(attribute_availability_with_message) -- --#define __NSi_2_0 introduced=2.0 --#define __NSi_2_1 introduced=2.1 --#define __NSi_2_2 introduced=2.2 --#define __NSi_3_0 introduced=3.0 --#define __NSi_3_1 introduced=3.1 --#define __NSi_3_2 introduced=3.2 --#define __NSi_4_0 introduced=4.0 --#define __NSi_4_1 introduced=4.1 --#define __NSi_4_2 introduced=4.2 --#define __NSi_4_3 introduced=4.3 --#define __NSi_5_0 introduced=5.0 --#define __NSi_5_1 introduced=5.1 --#define __NSi_6_0 introduced=6.0 --#define __NSi_6_1 introduced=6.1 --#define __NSi_7_0 introduced=7.0 --#define __NSi_8_0 introduced=8.0 --#define __NSi_9_0 introduced=9.0 --#define __NSi_10_0 introduced=10.0 --#define __NSi_10_1 introduced=10.1 --#define __NSi_10_2 introduced=10.2 --#define __NSi_10_3 introduced=10.3 --#define __NSi_10_4 introduced=10.4 --#define __NSi_10_5 introduced=10.5 --#define __NSi_10_6 introduced=10.6 --#define __NSi_10_7 introduced=10.7 --#define __NSi_10_8 introduced=10.8 --#define __NSi_10_9 introduced=10.9 -- --#define __NSd_2_0 ,deprecated=2.0 --#define __NSd_2_1 ,deprecated=2.1 --#define __NSd_2_2 ,deprecated=2.2 --#define __NSd_3_0 ,deprecated=3.0 --#define __NSd_3_1 ,deprecated=3.1 --#define __NSd_3_2 ,deprecated=3.2 --#define __NSd_4_0 ,deprecated=4.0 --#define __NSd_4_1 ,deprecated=4.1 --#define __NSd_4_2 ,deprecated=4.2 --#define __NSd_4_3 ,deprecated=4.3 --#define __NSd_5_0 ,deprecated=5.0 --#define __NSd_5_1 ,deprecated=5.1 --#define __NSd_6_0 ,deprecated=6.0 --#define __NSd_6_1 ,deprecated=6.1 --#define __NSd_7_0 ,deprecated=7.0 --#define __NSd_8_0 ,deprecated=8.0 --#define __NSd_9_0 ,deprecated=9.0 --#define __NSd_10_0 ,deprecated=10.0 --#define __NSd_10_1 ,deprecated=10.1 --#define __NSd_10_2 ,deprecated=10.2 --#define __NSd_10_3 ,deprecated=10.3 --#define __NSd_10_4 ,deprecated=10.4 --#define __NSd_10_5 ,deprecated=10.5 --#define __NSd_10_6 ,deprecated=10.6 --#define __NSd_10_7 ,deprecated=10.7 --#define __NSd_10_8 ,deprecated=10.8 --#define __NSd_10_9 ,deprecated=10.9 -- --#define __NSi_NA unavailable --#define __NSd_NA -- --// Do not use TBD as an argument to NS_AVAILABLE --#define __NSi_TBD introduced=9876.5 -- --#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) --// This section is for compilers targeting OS X which support attribute_availability_with_message -- --#define CF_AVAILABLE(_mac, _ios) __attribute__((availability(macosx,__NSi_##_mac))) --#define CF_AVAILABLE_MAC(_mac) __attribute__((availability(macosx,__NSi_##_mac))) --#define CF_AVAILABLE_IOS(_ios) __attribute__((availability(macosx,unavailable))) --#define CF_DEPRECATED(_macIntro, _macDep, _iosIntro, _iosDep, ...) __attribute__((availability(macosx,__NSi_##_macIntro __NSd_##_macDep,message="" __VA_ARGS__))) --#define CF_DEPRECATED_MAC(_macIntro, _macDep, ...) __attribute__((availability(macosx,__NSi_##_macIntro __NSd_##_macDep,message="" __VA_ARGS__))) --#define CF_DEPRECATED_IOS(_iosIntro, _iosDep, ...) __attribute__((availability(macosx,unavailable))) -- --#elif (TARGET_OS_EMBEDDED || TARGET_OS_IPHONE) --// This section is for compilers targeting iOS which support attribute_availability_with_message -- --#define CF_AVAILABLE(_mac, _ios) __attribute__((availability(ios,__NSi_##_ios))) --#define CF_AVAILABLE_MAC(_mac) __attribute__((availability(ios,unavailable))) --#define CF_AVAILABLE_IOS(_ios) __attribute__((availability(ios,__NSi_##_ios))) --#define CF_DEPRECATED(_macIntro, _macDep, _iosIntro, _iosDep, ...) __attribute__((availability(ios,__NSi_##_iosIntro __NSd_##_iosDep,message="" __VA_ARGS__))) --#define CF_DEPRECATED_MAC(_macIntro, _macDep, ...) __attribute__((availability(ios,unavailable))) --#define CF_DEPRECATED_IOS(_iosIntro, _iosDep, ...) __attribute__((availability(ios,__NSi_##_iosIntro __NSd_##_iosDep,message="" __VA_ARGS__))) -- --#endif -- --#elif (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) || (TARGET_OS_EMBEDDED || TARGET_OS_IPHONE) --// This section is for OS X or iOS, and compilers without support for attribute_availability_with_message. We fall back to Availability.h. -- --#ifndef __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_0 --#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_0 __AVAILABILITY_INTERNAL_DEPRECATED --#endif -- --#define CF_AVAILABLE(_mac, _ios) __OSX_AVAILABLE_STARTING(__MAC_##_mac, __IPHONE_##_ios) --#define CF_AVAILABLE_MAC(_mac) __OSX_AVAILABLE_STARTING(__MAC_##_mac, __IPHONE_NA) --#define CF_AVAILABLE_IOS(_ios) __OSX_AVAILABLE_STARTING(__MAC_NA, __IPHONE_##_ios) --#define CF_DEPRECATED(_macIntro, _macDep, _iosIntro, _iosDep, ...) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_##_macIntro, __MAC_##_macDep, __IPHONE_##_iosIntro, __IPHONE_##_iosDep) --#define CF_DEPRECATED_MAC(_macIntro, _macDep, ...) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_##_macIntro, __MAC_##_macDep, __IPHONE_NA, __IPHONE_NA) --#define CF_DEPRECATED_IOS(_iosIntro, _iosDep, ...) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_NA, __MAC_NA, __IPHONE_##_iosIntro, __IPHONE_##_iosDep) -- --#endif // __has_feature(attribute_availability_with_message) -- - #ifndef CF_AVAILABLE - // This section is for platforms which do not support availability - #define CF_AVAILABLE(_mac, _ios) diff --git a/recipes-devtools/osx-runtime/nativesdk-osx-runtime_10.8.bb b/recipes-devtools/osx-runtime/nativesdk-osx-runtime_10.8.bb deleted file mode 100644 index 23750e0..0000000 --- a/recipes-devtools/osx-runtime/nativesdk-osx-runtime_10.8.bb +++ /dev/null @@ -1,57 +0,0 @@ -DESCRIPTION = "Runtime libraries from OSX" -LICENSE = "Proprietary" - -COMPATIBLE_HOST = ".*-darwin.*" - -SRC_URI = "file://OSX-sdk.zip \ - file://remove_unsupported_attribute_availability_with_message_for_gcc.patch \ - file://LICENSE" - -LIC_FILES_CHKSUM = "file://${WORKDIR}/LICENSE;md5=03fe683ef28b9ddfe7f658a0f4b3b80e" - -S = "${WORKDIR}/OSX-sdk" -#B = "${WORKDIR}/build-${TARGET_SYS}" - -inherit nativesdk - -INHIBIT_DEFAULT_DEPS = "1" - -PROVIDES += "virtual/nativesdk-libc" -PROVIDES += "virtual/nativesdk-${SDK_PREFIX}libc-initial" -PROVIDES += "virtual/nativesdk-${SDK_PREFIX}libc-for-gcc" - -# Work around pulling in eglibc for now... -PROVIDES += "virtual/nativesdk-libintl" -PROVIDES += "virtual/nativesdk-libiconv" - -CFLAGS[unexport] = "1" -CXXFLAGS[unexport] = "1" -CPPFLAGS[unexport] = "1" -LDFLAGS[unexport] = "1" -TARGET_CFLAGS[unexport] = "1" -TARGET_CXXFLAGS[unexport] = "1" -TARGET_CPPFLAGS[unexport] = "1" -TARGET_LDFLAGS[unexport] = "1" - -do_configure () { - : -} - -do_compile () { - : -} - -do_install () { - mkdir ${D}/usr - cp -r ${S}/usr/* ${D}/usr/ - mkdir -p ${D}/System/Library/Frameworks - cp -r ${S}/System/Library/Frameworks/* ${D}/System/Library/Frameworks/ -} - -FILES_${PN} = "/usr /System/Library/Frameworks" -FILES_${PN}-staticdev = "/usr/lib/*.a" - -sysroot_stage_all() { - sysroot_stage_dir ${D} ${SYSROOT_DESTDIR} -} - diff --git a/recipes-devtools/osx-runtime/nativesdk-osx-runtime_12.3.bb b/recipes-devtools/osx-runtime/nativesdk-osx-runtime_12.3.bb new file mode 100644 index 0000000..f572b16 --- /dev/null +++ b/recipes-devtools/osx-runtime/nativesdk-osx-runtime_12.3.bb @@ -0,0 +1,70 @@ +DESCRIPTION = "Runtime libraries from OSX" +LICENSE = "Proprietary" + +COMPATIBLE_HOST = ".*-darwin.*" + +OSX_SDK ?= "file://OSX-sdk.zip" + +SRC_URI = "${OSX_SDK} \ + file://LICENSE" + +LIC_FILES_CHKSUM = "file://${WORKDIR}/LICENSE;md5=03fe683ef28b9ddfe7f658a0f4b3b80e" + +PR = "1" + +S = "${WORKDIR}/OSX-sdk" + +inherit nativesdk + +INHIBIT_DEFAULT_DEPS = "1" +EXCLUDE_FROM_SHLIBS = "1" + +PROVIDES += "virtual/nativesdk-libc" +PROVIDES += "virtual/nativesdk-libc-locale" +PROVIDES += "virtual/nativesdk-${SDK_PREFIX}libc-initial" +PROVIDES += "virtual/nativesdk-${SDK_PREFIX}libc-for-gcc" + +# Work around pulling in eglibc for now... +PROVIDES += "virtual/nativesdk-libintl" +PROVIDES += "virtual/nativesdk-libiconv" + +CFLAGS[unexport] = "1" +CXXFLAGS[unexport] = "1" +CPPFLAGS[unexport] = "1" +LDFLAGS[unexport] = "1" +TARGET_CFLAGS[unexport] = "1" +TARGET_CXXFLAGS[unexport] = "1" +TARGET_CPPFLAGS[unexport] = "1" +TARGET_LDFLAGS[unexport] = "1" + +do_compile[noexec] = "1" +package_do_shlibs[noexec] = "1" + +INSANE_SKIP:${PN} += "file-rdeps staticdev" +INSANE_SKIP:${PN}-dontship += "file-rdeps staticdev" + +do_configure() { +} + +do_install () { + mkdir -p ${D} + cp -r ${WORKDIR}/OSX-sdk/* ${D}/ +} + +do_stash_locale () { +} +addtask do_stash_locale after do_install before do_populate_sysroot do_package + +ALLOW_EMPTY:${PN} = "1" + +PACKAGES = "${PN} ${PN}-dontship" + +FILES:${PN}-dontship = "/usr /System /Entitlements.plist /SDKSettings.json /SDKSettings.plist /Library" + +SYSROOT_DIRS_NATIVE:append = " ${SDKPATHNATIVE}/runtime" +SYSROOT_DIRS:append = " ${SDKPATHNATIVE}/runtime" + +sysroot_stage_all:append() { + sysroot_stage_dir ${D} ${SYSROOT_DESTDIR}${SDKPATHNATIVE}/runtime +} + diff --git a/recipes-devtools/qemu/qemu_2.1.0.bbappend b/recipes-devtools/qemu/qemu_2.1.0.bbappend deleted file mode 100644 index 2a1ef8f..0000000 --- a/recipes-devtools/qemu/qemu_2.1.0.bbappend +++ /dev/null @@ -1,4 +0,0 @@ -QEMU_TARGETS_darwin = "i386 x86_64" -EXTRA_OECONF_append_class-nativesdk_darwin = "--disable-linux-user --disable-sdl --disable-cocoa --disable-vnc --disable-stack-protector --disable-fdt" -PACKAGECONFIG_class-nativesdk_darwin = "" -PACKAGECONFIG_remove_class-nativesdk_darwin = "sdl" diff --git a/recipes-devtools/xar/xar/0001-fix-compilation-error.patch b/recipes-devtools/xar/xar/0001-fix-compilation-error.patch new file mode 100644 index 0000000..950c87f --- /dev/null +++ b/recipes-devtools/xar/xar/0001-fix-compilation-error.patch @@ -0,0 +1,77 @@ +From 17605e2eaa97227ddee3ceac48af560ac3b7a7ad Mon Sep 17 00:00:00 2001 +From: OpenEmbedded <oe.patch@oe> +Date: Fri, 12 May 2023 13:05:08 +0000 +Subject: [PATCH] fix compilation error + +Upstream-Status: Inappropriate [OE specific] +Signed-off-by: Dominik Schnitzer <dominik@snap.com> +--- + xar/Makefile.in | 2 +- + xar/configure | 6 +++--- + xar/configure.ac | 6 +++--- + 3 files changed, 7 insertions(+), 7 deletions(-) + +diff --git a/xar/Makefile.in b/xar/Makefile.in +index a6d6814..63d9445 100644 +--- a/xar/Makefile.in ++++ b/xar/Makefile.in +@@ -76,7 +76,7 @@ include $(dir_names:%=%/Makefile.inc) + # + ifeq (@enable_autogen@, 1) + @srcroot@configure : @srcroot@configure.ac +- cd ./@srcroot@ && $(AUTOCONF) ++ cd @srcroot@ && $(AUTOCONF) + + @objroot@config.status : @srcroot@configure + ./@objroot@config.status --recheck +diff --git a/xar/configure b/xar/configure +index cb44f98..97a9065 100755 +--- a/xar/configure ++++ b/xar/configure +@@ -4847,7 +4847,7 @@ fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libxml >= ${LIBXML2_VERSION_MIN}" >&5 + $as_echo_n "checking for libxml >= ${LIBXML2_VERSION_MIN}... " >&6; } +-LIBXML2_FOUND=`2>&1 ${XML2_CONFIG} --version` ++LIBXML2_FOUND=`2>&1 pkg-config libxml-2.0 --modversion` + LIBXML2_MAJOR=`echo ${LIBXML2_FOUND} | tr . " " | awk '{print $1}'` + LIBXML2_MINOR=`echo ${LIBXML2_FOUND} | tr . " " | awk '{print $2}' | tr a-z " " |awk '{print $1}'` + LIBXML2_BRANCH=`echo ${LIBXML2_FOUND} | tr . " " | awk '{print $3}' | tr a-z " " |awk '{print $1}'` +@@ -4866,8 +4866,8 @@ if test ${LIBXML2_MAJOR} -gt ${LIBXML2_MAJOR_MIN} \ + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${LIBXML2_MAJOR}.${LIBXML2_MINOR}.${LIBXML2_BRANCH}" >&5 + $as_echo "${LIBXML2_MAJOR}.${LIBXML2_MINOR}.${LIBXML2_BRANCH}" >&6; } + have_libxml2="1" +- CPPFLAGS="${CPPFLAGS} `${XML2_CONFIG} --cflags`" +- LIBS="${LIBS} `${XML2_CONFIG} --libs`" ++ CPPFLAGS="${CPPFLAGS} `pkg-config libxml-2.0 --cflags`" ++ LIBS="${LIBS} `pkg-config libxml-2.0 --libs`" + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 + $as_echo "no" >&6; } +diff --git a/xar/configure.ac b/xar/configure.ac +index d1e6362..a77fccc 100644 +--- a/xar/configure.ac ++++ b/xar/configure.ac +@@ -292,7 +292,7 @@ fi + + dnl Make sure the version of libxml2 found is sufficient. + AC_MSG_CHECKING([for libxml >= ${LIBXML2_VERSION_MIN}]) +-LIBXML2_FOUND=`2>&1 ${XML2_CONFIG} --version` ++LIBXML2_FOUND=`2>&1 pkg-config libxml-2.0 --modversion` + LIBXML2_MAJOR=`echo ${LIBXML2_FOUND} | tr . " " | awk '{print $1}'` + LIBXML2_MINOR=`echo ${LIBXML2_FOUND} | tr . " " | awk '{print $2}' | tr a-z " " |awk '{print $1}'` + LIBXML2_BRANCH=`echo ${LIBXML2_FOUND} | tr . " " | awk '{print $3}' | tr a-z " " |awk '{print $1}'` +@@ -310,8 +310,8 @@ if test ${LIBXML2_MAJOR} -gt ${LIBXML2_MAJOR_MIN} \ + -a ${LIBXML2_BRANCH} -ge $LIBXML2_BRANCH_MIN ; then + AC_MSG_RESULT([${LIBXML2_MAJOR}.${LIBXML2_MINOR}.${LIBXML2_BRANCH}]) + have_libxml2="1" +- CPPFLAGS="${CPPFLAGS} `${XML2_CONFIG} --cflags`" +- LIBS="${LIBS} `${XML2_CONFIG} --libs`" ++ CPPFLAGS="${CPPFLAGS} `pkg-config libxml-2.0 --cflags`" ++ LIBS="${LIBS} `pkg-config libxml-2.0 --libs`" + else + AC_MSG_RESULT([no]) + have_libxml2="0" +-- +2.36.1.vfs.0.0 + diff --git a/recipes-devtools/xar/xar_git.bb b/recipes-devtools/xar/xar_git.bb new file mode 100644 index 0000000..575ac36 --- /dev/null +++ b/recipes-devtools/xar/xar_git.bb @@ -0,0 +1,25 @@ +SUMMARY = "eXtensible ARchiver" +HOMEPAGE = "https://github.com/tpoechtrager/xar" +LICENSE = "BSD-3-Clause" +SECTION = "devel" + +SRCREV = "2b9a4ab7003f1db8c54da4fea55fcbb424fdecb0" +SRC_URI = " \ + git://github.com/tpoechtrager/xar.git;branch=master;protocol=https \ + file://0001-fix-compilation-error.patch \ +" + +inherit autotools pkgconfig + +LIC_FILES_CHKSUM = "file://${WORKDIR}/git/xar/LICENSE;md5=64becc7b238f5b2d599c009ab19c2c27" + +DEPENDS = "libxml2" + +BBCLASSEXTEND = "native" + +S = "${WORKDIR}/git" +B = "${WORKDIR}/build" + +do_configure() { + ${S}/xar/configure --enable-autogen --prefix=${STAGING_EXECPREFIXDIR} +} diff --git a/recipes-extended/zstd/zstd_%.bbappend b/recipes-extended/zstd/zstd_%.bbappend new file mode 100644 index 0000000..bb583f6 --- /dev/null +++ b/recipes-extended/zstd/zstd_%.bbappend @@ -0,0 +1,3 @@ +FILESEXTRAPATHS:prepend := "${THISDIR}/${PN}:" + +EXTRA_OEMAKE:append:darwin21 = " UNAME='Darwin'" diff --git a/recipes-gnome/libffi/libffi/darwinfix.patch b/recipes-gnome/libffi/libffi/darwinfix.patch deleted file mode 100644 index e504e46..0000000 --- a/recipes-gnome/libffi/libffi/darwinfix.patch +++ /dev/null @@ -1,49 +0,0 @@ -Hacky workaround for build failures on darwin. The linker is buggy and it -can't cope with arithmatic at the end of sections, therefore we pad the -sections with a dummy instruction. - -Also, our compiler doesn't support relocs so we need to enter the configure -section to run those tests and avoid build failures. - -RP 2014/8/4 - -Index: libffi-3.1/src/x86/win32.S -=================================================================== ---- libffi-3.1.orig/src/x86/win32.S 2014-07-09 16:23:45.361202177 +0000 -+++ libffi-3.1/src/x86/win32.S 2014-07-09 16:23:45.565202182 +0000 -@@ -1133,11 +1133,14 @@ - .ffi_closure_STDCALL_end: - .LFE5: - -+ hlt; -+ - #if defined(X86_DARWIN) - .section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5 - L_ffi_closure_SYSV_inner$stub: - .indirect_symbol _ffi_closure_SYSV_inner - hlt ; hlt ; hlt ; hlt ; hlt -+.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support - #endif - - #if defined(X86_WIN32) && !defined(__OS2__) -@@ -1301,6 +1304,6 @@ - /* End of DW_CFA_xxx CFI instructions. */ - .align 4 - .LEFDE5: -- -+ hlt - #endif /* !_MSC_VER */ - -Index: libffi-3.1/configure.ac -=================================================================== ---- libffi-3.1.orig/configure.ac 2014-05-11 13:57:49.000000000 +0000 -+++ libffi-3.1/configure.ac 2014-07-09 16:24:53.885204044 +0000 -@@ -393,7 +393,7 @@ - fi - fi - --if test x$TARGET = xX86 || test x$TARGET = xX86_WIN32 || test x$TARGET = xX86_64; then -+if test x$TARGET = xX86 || test x$TARGET = xX86_WIN32 || test x$TARGET = xX86_64 || test x$TARGET = xX86_DARWIN; then - AC_CACHE_CHECK([assembler supports pc related relocs], - libffi_cv_as_x86_pcrel, [ - libffi_cv_as_x86_pcrel=no diff --git a/recipes-gnome/libffi/libffi_%.bbappend b/recipes-gnome/libffi/libffi_%.bbappend deleted file mode 100644 index 9f420ed..0000000 --- a/recipes-gnome/libffi/libffi_%.bbappend +++ /dev/null @@ -1,3 +0,0 @@ -SRC_URI_append_darwin = " file://darwinfix.patch " - -FILESEXTRAPATHS_prepend := "${THISDIR}/${BPN}:" diff --git a/recipes-graphics/xorg-lib/pixman_%.bbappend b/recipes-graphics/xorg-lib/pixman_%.bbappend deleted file mode 100644 index 1a953cb..0000000 --- a/recipes-graphics/xorg-lib/pixman_%.bbappend +++ /dev/null @@ -1 +0,0 @@ -EXTRA_OECONF_append_darwin = " ac_cv_tls=none" diff --git a/recipes-support/libmpc/libmpc_%.bbappend b/recipes-support/libmpc/libmpc_%.bbappend new file mode 100644 index 0000000..9ec4e4f --- /dev/null +++ b/recipes-support/libmpc/libmpc_%.bbappend @@ -0,0 +1 @@ +EXTRA_OECONF:append:darwin21 = " --with-gmp=${STAGING_EXECPREFIXDIR}" diff --git a/recipes-support/lz4/lz4_%.bbappend b/recipes-support/lz4/lz4_%.bbappend new file mode 100644 index 0000000..e6ec2d3 --- /dev/null +++ b/recipes-support/lz4/lz4_%.bbappend @@ -0,0 +1,3 @@ +FILESEXTRAPATHS:prepend := "${THISDIR}/${PN}:" + +EXTRA_OEMAKE:append:darwin21 = " TARGET_OS='Darwin'" diff --git a/recipes-support/mpfr/mpfr_%.bbappend b/recipes-support/mpfr/mpfr_%.bbappend new file mode 100644 index 0000000..9ec4e4f --- /dev/null +++ b/recipes-support/mpfr/mpfr_%.bbappend @@ -0,0 +1 @@ +EXTRA_OECONF:append:darwin21 = " --with-gmp=${STAGING_EXECPREFIXDIR}" |