basewhitelist: {'BB_TASKHASH', 'LICENSE_PATH', 'HOME', 'PKGDATA_DIR', 'PSEUDO_IGNORE_PATHS', 'SSTATE_HASHEQUIV_METHOD', 'CCACHE_DIR', 'FILESPATH', 'STAMPCLEAN', 'BB_LIMITEDDEPS', 'FILE', 'STAGING_DIR_HOST', 'TMPDIR', 'FILE_DIRNAME', 'SSTATE_HASHEQUIV_OWNER', 'WORKDIR', 'BBPATH', 'PRSERV_HOST', 'THISDIR', 'DEPLOY_DIR', 'STAMPS_DIR', 'OMP_NUM_THREADS', 'CCACHE_TOP_DIR', 'PRSERV_DUMPDIR', 'LOGNAME', 'GIT_CEILING_DIRECTORIES', 'COREBASE', 'PRSERV_DUMPFILE', 'STAGING_DIR_TARGET', 'BB_WORKERCONTEXT', 'BUILDHISTORY_DIR', 'BUILD_ARCH', 'SSTATE_DIR', 'PARALLEL_MAKE', 'BBSERVER', 'PATH', 'PRSERV_LOCKDOWN', 'FILESEXTRAPATHS', 'CCACHE_NOHASHDIR', 'SHELL', 'WARN_QA', 'SSTATE_HASHEQUIV_REPORT_TASKDATA', 'SDKPKGSUFFIX', 'USER', 'SOURCE_DATE_EPOCH', 'extend_recipe_sysroot', 'EXTERNAL_TOOLCHAIN', 'BB_HASHSERVE', 'CCACHE', 'ERROR_QA', 'BB_UNIHASH', 'SSTATE_PKGARCH', 'PWD', 'DL_DIR'}
taskwhitelist: None
Task dependencies: ['ARM_THUMB_OPT', 'DEFAULTTUNE', 'MACHINE', 'MACHINEOVERRIDES', 'PACKAGE_ARCH', 'RUST_PANIC_STRATEGY', 'TARGET_ARCH', 'TARGET_CC_ARCH', 'TARGET_FPU', 'TARGET_LLVM_CPU', 'TARGET_LLVM_FEATURES', 'TRANSLATED_TARGET_ARCH', 'TUNE_ARCH', 'TUNE_CCARGS', 'TUNE_FEATURES', 'TUNE_FEATURES:tune-x86', 'X86ARCH32', 'X86ARCH64', 'arch_to_rust_target_arch', 'llvm_cpu', 'llvm_features', 'llvm_features_from_cc_arch', 'llvm_features_from_target_fpu', 'llvm_features_from_tune', 'prefix_for', 'rust_gen_target', 'sys_for', 'target_is_armv7']
basehash: a6d3d19d11840aa1a5950cf2bd7a8f6dd249f95f40fd9e56fa77f337e43ae42e
List of dependencies for variable ARM_THUMB_OPT is set()
List of dependencies for variable DEFAULTTUNE is set()
List of dependencies for variable MACHINE is set()
List of dependencies for variable MACHINEOVERRIDES is {'MACHINE'}
List of dependencies for variable PACKAGE_ARCH is set()
List of dependencies for variable RUST_PANIC_STRATEGY is set()
List of dependencies for variable TARGET_ARCH is {'TUNE_ARCH'}
List of dependencies for variable TARGET_CC_ARCH is {'TUNE_CCARGS'}
List of dependencies for variable TARGET_FPU is set()
List of dependencies for variable TARGET_LLVM_CPU is {'llvm_cpu'}
List of dependencies for variable TARGET_LLVM_FEATURES is {'llvm_features'}
List of dependencies for variable TRANSLATED_TARGET_ARCH is {'TARGET_ARCH'}
List of dependencies for variable TUNE_ARCH is {'X86ARCH64', 'X86ARCH32'}
List of dependencies for variable TUNE_CCARGS is set()
List of dependencies for variable TUNE_FEATURES is {'DEFAULTTUNE', 'TUNE_FEATURES:tune-x86'}
List of dependencies for variable TUNE_FEATURES:tune-x86 is set()
List of dependencies for variable X86ARCH32 is set()
List of dependencies for variable X86ARCH64 is set()
List of dependencies for variable arch_to_rust_target_arch is set()
List of dependencies for variable llvm_cpu is {'TRANSLATED_TARGET_ARCH', 'TUNE_FEATURES', 'PACKAGE_ARCH'}
List of dependencies for variable llvm_features is {'llvm_features_from_cc_arch', 'llvm_features_from_tune', 'llvm_features_from_target_fpu'}
List of dependencies for variable llvm_features_from_cc_arch is {'TARGET_CC_ARCH'}
List of dependencies for variable llvm_features_from_target_fpu is {'TARGET_FPU'}
List of dependencies for variable llvm_features_from_tune is {'MACHINEOVERRIDES', 'TUNE_FEATURES', 'target_is_armv7', 'ARM_THUMB_OPT'}
List of dependencies for variable prefix_for is set()
List of dependencies for variable rust_gen_target is {'RUST_PANIC_STRATEGY', 'sys_for', 'prefix_for', 'arch_to_rust_target_arch'}
List of dependencies for variable sys_for is set()
List of dependencies for variable target_is_armv7 is {'MACHINEOVERRIDES', 'TUNE_FEATURES', 'TARGET_ARCH'}
Variable do_rust_gen_targets value is     wd = d.getVar('WORKDIR') + '/targets/'
    # It is important 'TARGET' is last here so that it overrides our less
    # informed choices for BUILD & HOST if TARGET happens to be the same as
    # either of them.
    for thing in ['BUILD', 'HOST', 'TARGET']:
        bb.debug(1, "rust_gen_target for " + thing)
        features = ""
        cpu = "generic"
        arch = d.getVar('{}_ARCH'.format(thing))
        if thing is "TARGET":
            # arm and armv7 have different targets in llvm
            if arch == "arm" and target_is_armv7(d):
                arch = 'armv7'
            features = d.getVar('TARGET_LLVM_FEATURES') or ""
            cpu = d.getVar('TARGET_LLVM_CPU')
        rust_gen_target(d, thing, wd, features, cpu, arch)

Variable ARM_THUMB_OPT value is None
Variable DEFAULTTUNE value is x86
Variable MACHINE value is qemux86copy
Variable MACHINEOVERRIDES value is ${@bb.utils.contains('TUNE_FEATURES', 'mx32', 'x86-x32:', '', d)}${@bb.utils.contains('TUNE_FEATURES', 'm32', 'x86:', '', d)}qemuall:${MACHINE}:qemux86
TUNE_FEATURES{m32} = Set
TUNE_FEATURES{mx32} = Unset
Variable PACKAGE_ARCH value is ${BUILD_ARCH}
Variable RUST_PANIC_STRATEGY value is unwind
Variable TARGET_ARCH value is ${TUNE_ARCH}
Variable TARGET_CC_ARCH value is ${TUNE_CCARGS} --sysroot=${STAGING_DIR_TARGET}
Variable TARGET_FPU value is 
Variable TARGET_LLVM_CPU value is ${@llvm_cpu(d)}
Variable TARGET_LLVM_FEATURES value is ${@llvm_features(d)}
Variable TRANSLATED_TARGET_ARCH value is ${@d.getVar('TARGET_ARCH').replace("_", "-")}
Variable TUNE_ARCH value is ${@bb.utils.contains('TUNE_FEATURES', 'm32', '${X86ARCH32}', '', d)}${@bb.utils.contains('TUNE_FEATURES', 'mx32', '${X86ARCH64}', '', d)}${@bb.utils.contains('TUNE_FEATURES', 'm64', '${X86ARCH64}', '', d)}
TUNE_FEATURES{m32} = Set
TUNE_FEATURES{m64} = Unset
TUNE_FEATURES{mx32} = Unset
Variable TUNE_CCARGS value is  -m32
Variable TUNE_FEATURES value is ${TUNE_FEATURES:tune-${DEFAULTTUNE}}
Variable TUNE_FEATURES:tune-x86 value is m32
Variable X86ARCH32 value is i686
Variable X86ARCH64 value is x86_64
Variable arch_to_rust_target_arch value is def arch_to_rust_target_arch(arch):
    if arch == "i586" or arch == "i686":
        return "x86"
    elif arch == "mipsel":
        return "mips"
    elif arch == "mip64sel":
        return "mips64"
    elif arch == "armv7":
        return "arm"
    elif arch == "powerpc64le":
        return "powerpc64"
    else:
        return arch

# generates our target CPU value
Variable llvm_cpu value is def llvm_cpu(d):
    cpu = d.getVar('PACKAGE_ARCH')
    target = d.getVar('TRANSLATED_TARGET_ARCH')

    trans = {}
    trans['corei7-64'] = "corei7"
    trans['core2-32'] = "core2"
    trans['x86-64'] = "x86-64"
    trans['i686'] = "i686"
    trans['i586'] = "i586"
    trans['powerpc'] = "powerpc"
    trans['mips64'] = "mips64"
    trans['mips64el'] = "mips64"
    trans['riscv64'] = "generic-rv64"
    trans['riscv32'] = "generic-rv32"

    if target in ["mips", "mipsel"]:
        feat = frozenset(d.getVar('TUNE_FEATURES').split())
        if "mips32r2" in feat:
            trans['mipsel'] = "mips32r2"
            trans['mips'] = "mips32r2"
        elif "mips32" in feat:
            trans['mipsel'] = "mips32"
            trans['mips'] = "mips32"

    try:
        return trans[cpu]
    except:
        return trans.get(target, "generic")

Variable llvm_features value is def llvm_features(d):
    return ','.join(llvm_features_from_tune(d) +
                    llvm_features_from_cc_arch(d) +
                    llvm_features_from_target_fpu(d))


## arm-unknown-linux-gnueabihf
Variable llvm_features_from_cc_arch value is def llvm_features_from_cc_arch(d):
    f = []
    feat = d.getVar('TARGET_CC_ARCH')
    if not feat:
        return []
    feat = frozenset(feat.split())

    if '-mmmx' in feat:
        f.append("+mmx")
    if '-msse' in feat:
        f.append("+sse")
    if '-msse2' in feat:
        f.append("+sse2")
    if '-msse3' in feat:
        f.append("+sse3")
    if '-mssse3' in feat:
        f.append("+ssse3")
    if '-msse4.1' in feat:
        f.append("+sse4.1")
    if '-msse4.2' in feat:
        f.append("+sse4.2")
    if '-msse4a' in feat:
        f.append("+sse4a")
    if '-mavx' in feat:
        f.append("+avx")
    if '-mavx2' in feat:
        f.append("+avx2")

    return f

Variable llvm_features_from_target_fpu value is def llvm_features_from_target_fpu(d):
    # TARGET_FPU can be hard or soft. +soft-float tell llvm to use soft float
    # ABI. There is no option for hard.

    fpu = d.getVar('TARGET_FPU', True)
    return ["+soft-float"] if fpu == "soft" else []

Variable llvm_features_from_tune value is def llvm_features_from_tune(d):
    f = []
    feat = d.getVar('TUNE_FEATURES')
    if not feat:
        return []
    feat = frozenset(feat.split())

    mach_overrides = d.getVar('MACHINEOVERRIDES')
    mach_overrides = frozenset(mach_overrides.split(':'))

    if 'vfpv4' in feat:
        f.append("+vfp4")
    if 'vfpv3' in feat:
        f.append("+vfp3")
    if 'vfpv3d16' in feat:
        f.append("+d16")

    if 'vfpv2' in feat or 'vfp' in feat:
        f.append("+vfp2")

    if 'neon' in feat:
        f.append("+neon")

    if 'mips32' in feat:
        f.append("+mips32")

    if 'mips32r2' in feat:
        f.append("+mips32r2")

    if target_is_armv7(d):
        f.append('+v7')

    if ('armv6' in mach_overrides) or ('armv6' in feat):
        f.append("+v6")
    if 'armv5te' in feat:
        f.append("+strict-align")
        f.append("+v5te")
    elif 'armv5' in feat:
        f.append("+strict-align")
        f.append("+v5")

    if ('armv4' in mach_overrides) or ('armv4' in feat):
        f.append("+strict-align")

    if 'dsp' in feat:
        f.append("+dsp")

    if 'thumb' in feat:
        if d.getVar('ARM_THUMB_OPT') == "thumb":
            if target_is_armv7(d):
                f.append('+thumb2')
            f.append("+thumb-mode")

    if 'cortexa5' in feat:
        f.append("+a5")
    if 'cortexa7' in feat:
        f.append("+a7")
    if 'cortexa9' in feat:
        f.append("+a9")
    if 'cortexa15' in feat:
        f.append("+a15")
    if 'cortexa17' in feat:
        f.append("+a17")
    if ('riscv64' in feat) or ('riscv32' in feat):
        f.append("+a,+c,+d,+f,+m")
    return f

# TARGET_CC_ARCH changes from build/cross/target so it'll do the right thing
# this should go away when https://github.com/rust-lang/rust/pull/31709 is
# stable (1.9.0?)
Variable prefix_for value is def prefix_for(d, thing):
    return d.getVar('{}_PREFIX'.format(thing))

# Convert a normal arch (HOST_ARCH, TARGET_ARCH, BUILD_ARCH, etc) to something
# rust's internals won't choke on.
Variable rust_gen_target value is def rust_gen_target(d, thing, wd, features, cpu, arch):
    import json
    sys = sys_for(d, thing)
    prefix = prefix_for(d, thing)

    features = features or d.getVarFlag('FEATURES', arch) or ""
    features = features.strip()

    # build tspec
    tspec = {}
    tspec['llvm-target'] = d.getVarFlag('LLVM_TARGET', arch)
    tspec['data-layout'] = d.getVarFlag('DATA_LAYOUT', arch)
    tspec['max-atomic-width'] = int(d.getVarFlag('MAX_ATOMIC_WIDTH', arch))
    tspec['target-pointer-width'] = d.getVarFlag('TARGET_POINTER_WIDTH', arch)
    tspec['target-c-int-width'] = d.getVarFlag('TARGET_C_INT_WIDTH', arch)
    tspec['target-endian'] = d.getVarFlag('TARGET_ENDIAN', arch)
    tspec['arch'] = arch_to_rust_target_arch(arch)
    tspec['os'] = "linux"
    if "musl" in tspec['llvm-target']:
        tspec['env'] = "musl"
    else:
        tspec['env'] = "gnu"
    if "riscv64" in tspec['llvm-target']:
        tspec['llvm-abiname'] = "lp64d"
    if "riscv32" in tspec['llvm-target']:
        tspec['llvm-abiname'] = "ilp32d"
    tspec['vendor'] = "unknown"
    tspec['target-family'] = "unix"
    tspec['linker'] = "{}{}gcc".format(d.getVar('CCACHE'), prefix)
    tspec['ar'] = "{}ar".format(prefix)
    tspec['cpu'] = cpu
    if features != "":
        tspec['features'] = features
    tspec['dynamic-linking'] = True
    tspec['executables'] = True
    tspec['linker-is-gnu'] = True
    tspec['linker-flavor'] = "gcc"
    tspec['has-rpath'] = True
    tspec['has-elf-tls'] = True
    tspec['position-independent-executables'] = True
    tspec['panic-strategy'] = d.getVar("RUST_PANIC_STRATEGY")

    # write out the target spec json file
    with open(wd + sys + '.json', 'w') as f:
        json.dump(tspec, f, indent=4)

Variable sys_for value is def sys_for(d, thing):
    return d.getVar('{}_SYS'.format(thing))

Variable target_is_armv7 value is def target_is_armv7(d):
    '''Determine if target is armv7'''
    # TUNE_FEATURES may include arm* even if the target is not arm
    # in the case of *-native packages
    if d.getVar('TARGET_ARCH') != 'arm':
        return False

    feat = d.getVar('TUNE_FEATURES')
    feat = frozenset(feat.split())
    mach_overrides = d.getVar('MACHINEOVERRIDES')
    mach_overrides = frozenset(mach_overrides.split(':'))

    v7=frozenset(['armv7a', 'armv7r', 'armv7m', 'armv7ve'])
    if mach_overrides.isdisjoint(v7) and feat.isdisjoint(v7):
        return False
    else:
        return True

# Responsible for taking Yocto triples and converting it to Rust triples
Tasks this task depends on: ['virtual:multilib:lib32:/ala-lpggp31/rmacleod/src/distro/yocto/poky-contrib.git/meta/recipes-devtools/rust/rust-cross_1.54.0.bb:do_patch']
This task depends on the checksums of files: []
Hash for dependent task virtual:multilib:lib32:/ala-lpggp31/rmacleod/src/distro/yocto/poky-contrib.git/meta/recipes-devtools/rust/rust-cross_1.54.0.bb:do_patch is 4652ea318cee215a87d8b925b337051f7c70cd4ee6e85d84922925efc979dfa4
Computed base hash is a6d3d19d11840aa1a5950cf2bd7a8f6dd249f95f40fd9e56fa77f337e43ae42e and from file a6d3d19d11840aa1a5950cf2bd7a8f6dd249f95f40fd9e56fa77f337e43ae42e
Computed task hash is 8ed5b5d7c9a60b44b5097425b26ce5557ec3420cb761c9295c56307d5ddaec22