Backed out 6 changesets (bug 1319228) for Btup bustages on Linux x64 on a CLOSED TREE
authorshindli <shindli@mozilla.com>
Thu, 14 Jun 2018 00:46:46 +0300
changeset 479195 f513c7af73e6cfac90e10be46d255a71e45b339c
parent 479194 1e37948aa30cc61be6b5ea884234de2d3af9cd3f
child 479196 ab114614abc26e65260f869fd276f1112b565b37
push id1757
push userffxbld-merge
push dateFri, 24 Aug 2018 17:02:43 +0000
treeherdermozilla-release@736023aebdb1 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1319228
milestone62.0a1
backs out2eedbab9137b6b11fa5eba3faef9fb46dcf4984f
6ba05238789ffd1a0e7cdeef9028d822e18cad1f
badf116dde30da2fded47fd9fbe5669358247410
a218f97e1b486ed37bba6c1cf05c448005f4c7fd
d3c835477d11416ab85e6b55732237012fce1387
3f3fa38b1a5fbd54b04cf4e5847de0f27e69cbf2
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 6 changesets (bug 1319228) for Btup bustages on Linux x64 on a CLOSED TREE Backed out changeset 2eedbab9137b (bug 1319228) Backed out changeset 6ba05238789f (bug 1319228) Backed out changeset badf116dde30 (bug 1319228) Backed out changeset a218f97e1b48 (bug 1319228) Backed out changeset d3c835477d11 (bug 1319228) Backed out changeset 3f3fa38b1a5f (bug 1319228)
browser/config/mozconfigs/linux64/tup
python/mozbuild/mozbuild/backend/cargo_build_defs.py
python/mozbuild/mozbuild/backend/tup.py
python/mozbuild/mozbuild/controller/building.py
taskcluster/ci/build/linux.yml
taskcluster/ci/toolchain/linux.yml
toolkit/library/dependentlibs.py
--- a/browser/config/mozconfigs/linux64/tup
+++ b/browser/config/mozconfigs/linux64/tup
@@ -8,10 +8,9 @@ MOZ_AUTOMATION_UPLOAD_SYMBOLS=0
 
 TOOLTOOL_DIR=${TOOLTOOL_DIR:-$topsrcdir}
 export TUP=${TOOLTOOL_DIR}/tup/tup
 
 . "$topsrcdir/browser/config/mozconfigs/linux64/common-opt"
 . "$topsrcdir/build/mozconfig.common.override"
 
 ac_add_options --enable-build-backends=Tup
-ac_add_options --disable-js-shell
 ac_add_options --upload-tup-db
deleted file mode 100644
--- a/python/mozbuild/mozbuild/backend/cargo_build_defs.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-from __future__ import absolute_import, unicode_literals
-
-cargo_extra_outputs = {
-    'bindgen': [
-        'tests.rs',
-        'host-target.txt',
-    ],
-    'cssparser': [
-        'tokenizer.rs',
-    ],
-    'gleam': [
-        'gl_and_gles_bindings.rs',
-        'gl_bindings.rs',
-        'gles_bindings.rs',
-    ],
-    'khronos_api': [
-        'webgl_exts.rs',
-    ],
-    'libloading': [
-        'libglobal_static.a',
-        'src/os/unix/global_static.o',
-    ],
-    'selectors': [
-        'ascii_case_insensitive_html_attributes.rs',
-    ],
-    'style': [
-        'gecko/atom_macro.rs',
-        'gecko/pseudo_element_definition.rs',
-        'gecko_properties.rs',
-        'properties.rs',
-        'gecko/bindings.rs',
-        'gecko/structs.rs',
-    ],
-    'webrender': [
-        'shaders.rs',
-    ],
-}
-
-cargo_extra_flags = {
-    'style': [
-        '-l', 'static=global_static',
-        '-L', 'native=%(libloading_outdir)s',
-    ]
-}
--- a/python/mozbuild/mozbuild/backend/tup.py
+++ b/python/mozbuild/mozbuild/backend/tup.py
@@ -1,16 +1,15 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from __future__ import absolute_import, unicode_literals
 
 import os
-import itertools
 import json
 import sys
 import shutil
 
 import mozpack.path as mozpath
 from mozbuild import shellutil
 from mozbuild.base import MozbuildObject
 from mozbuild.backend.base import PartialBackend, HybridBackend
@@ -41,35 +40,30 @@ from ..frontend.data import (
     JARManifest,
     ObjdirFiles,
     PerSourceFlag,
     Program,
     SimpleProgram,
     HostLibrary,
     HostProgram,
     HostSimpleProgram,
-    RustLibrary,
     SharedLibrary,
     Sources,
     StaticLibrary,
     VariablePassthru,
 )
 from ..util import (
     FileAvoidWrite,
     expand_variables,
 )
 from ..frontend.context import (
     AbsolutePath,
     ObjDirPath,
     RenamedSourcePath,
 )
-from .cargo_build_defs import (
-    cargo_extra_outputs,
-    cargo_extra_flags,
-)
 
 
 class BackendTupfile(object):
     """Represents a generated Tupfile.
     """
 
     def __init__(self, objdir, environment, topsrcdir, topobjdir, dry_run):
         self.topsrcdir = topsrcdir
@@ -83,28 +77,29 @@ class BackendTupfile(object):
         self.outputs = set()
         self.delayed_generated_files = []
         self.delayed_installed_files = []
         self.per_source_flags = defaultdict(list)
         self.local_flags = defaultdict(list)
         self.sources = defaultdict(list)
         self.host_sources = defaultdict(list)
         self.variables = {}
-        self.rust_library = None
         self.static_lib = None
         self.shared_lib = None
         self.programs = []
         self.host_programs = []
         self.host_library = None
         self.exports = set()
 
         # These files are special, ignore anything that generates them or
         # depends on them.
         self._skip_files = [
             'signmar',
+            'libxul.so',
+            'libtestcrasher.so',
         ]
 
         self.fh = FileAvoidWrite(self.name, capture_diff=True, dry_run=dry_run)
         self.fh.write('# THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT.\n')
         self.fh.write('\n')
 
     def write(self, buf):
         self.fh.write(buf)
@@ -245,27 +240,24 @@ class TupBackend(CommonBackend):
             '*.py',
             '*.rs',
         )
 
         # These are 'group' dependencies - All rules that list these as an output
         # will be built before any rules that list this as an input.
         self._installed_idls = '$(MOZ_OBJ_ROOT)/<installed-idls>'
         self._installed_files = '$(MOZ_OBJ_ROOT)/<installed-files>'
-        self._rust_libs = '$(MOZ_OBJ_ROOT)/<rust-libs>'
         # The preprocessor including source-repo.h and buildid.h creates
         # dependencies that aren't specified by moz.build and cause errors
         # in Tup. Express these as a group dependency.
         self._early_generated_files = '$(MOZ_OBJ_ROOT)/<early-generated-files>'
 
         self._built_in_addons = set()
         self._built_in_addons_file = 'dist/bin/browser/chrome/browser/content/browser/built_in_addons.json'
 
-        self._shlibs = '$(MOZ_OBJ_ROOT)/<shlibs>'
-
     def _get_mozconfig_env(self, config):
         env = {}
         loader = MozconfigLoader(config.topsrcdir)
         mozconfig = loader.read_mozconfig(config.substs['MOZCONFIG'])
         make_extra = mozconfig['make_extra'] or []
         env = {}
         for line in make_extra:
             if line.startswith('export '):
@@ -320,19 +312,16 @@ class TupBackend(CommonBackend):
 
     def _lib_paths(self, objdir, libs):
         return [mozpath.relpath(mozpath.join(l.objdir, l.import_name), objdir)
                 for l in libs]
 
     def _gen_shared_library(self, backend_file):
         shlib = backend_file.shared_lib
 
-        if backend_file.objdir.endswith('gtest') and shlib.name == 'libxul.so':
-            return
-
         if shlib.cxx_link:
             mkshlib = (
                 [backend_file.environment.substs['CXX']] +
                 backend_file.local_flags['CXX_LDFLAGS']
             )
         else:
             mkshlib = (
                 [backend_file.environment.substs['CC']] +
@@ -348,27 +337,18 @@ class TupBackend(CommonBackend):
 
         objs, _, shared_libs, os_libs, static_libs = self._expand_libs(shlib)
         static_libs = self._lib_paths(backend_file.objdir, static_libs)
         shared_libs = self._lib_paths(backend_file.objdir, shared_libs)
 
         list_file_name = '%s.list' % shlib.name.replace('.', '_')
         list_file = self._make_list_file(backend_file.objdir, objs, list_file_name)
 
-        rust_linked = self._lib_paths(backend_file.objdir,
-                                      (l for l in backend_file.shared_lib.linked_libraries
-                                       if isinstance(l, RustLibrary)))
-
         inputs = objs + static_libs + shared_libs
 
-        extra_inputs = []
-        if rust_linked:
-            extra_inputs = [self._rust_libs]
-            static_libs += rust_linked
-
         symbols_file = []
         if shlib.symbols_file:
             inputs.append(shlib.symbols_file)
             # TODO: Assumes GNU LD
             symbols_file = ['-Wl,--version-script,%s' % shlib.symbols_file]
 
         cmd = (
             mkshlib +
@@ -378,42 +358,36 @@ class TupBackend(CommonBackend):
             shared_libs +
             symbols_file +
             [backend_file.environment.substs['OS_LIBS']] +
             os_libs
         )
         backend_file.rule(
             cmd=cmd,
             inputs=inputs,
-            extra_inputs=extra_inputs,
             outputs=[shlib.lib_name],
-            extra_outputs=[self._shlibs],
             display='LINK %o'
         )
         backend_file.symlink_rule(mozpath.join(backend_file.objdir,
                                                shlib.lib_name),
                                   output=mozpath.join(self.environment.topobjdir,
                                                       shlib.install_target,
-                                                      shlib.lib_name),
-                                  output_group=self._shlibs)
+                                                      shlib.lib_name))
 
     def _gen_programs(self, backend_file):
         for p in backend_file.programs:
             self._gen_program(backend_file, p)
 
     def _gen_program(self, backend_file, prog):
         cc_or_cxx = 'CXX' if prog.cxx_link else 'CC'
         objs, _, shared_libs, os_libs, static_libs = self._expand_libs(prog)
         static_libs = self._lib_paths(backend_file.objdir, static_libs)
         shared_libs = self._lib_paths(backend_file.objdir, shared_libs)
 
-        # Linking some programs will access libraries installed to dist/bin,
-        # so depend on the installed libraries here. This can be made more
-        # accurate once we start building libraries in their final locations.
-        inputs = objs + static_libs + shared_libs + [self._shlibs]
+        inputs = objs + static_libs + shared_libs
 
         list_file_name = '%s.list' % prog.name.replace('.', '_')
         list_file = self._make_list_file(backend_file.objdir, objs, list_file_name)
 
         if isinstance(prog, SimpleProgram):
             outputs = [prog.name]
         else:
             outputs = [mozpath.relpath(prog.output_path.full_path,
@@ -567,18 +541,16 @@ class TupBackend(CommonBackend):
         elif isinstance(obj, ComputedFlags):
             self._process_computed_flags(obj, backend_file)
         elif isinstance(obj, (Sources, GeneratedSources)):
             backend_file.sources[obj.canonical_suffix].extend(obj.files)
         elif isinstance(obj, HostSources):
             backend_file.host_sources[obj.canonical_suffix].extend(obj.files)
         elif isinstance(obj, VariablePassthru):
             backend_file.variables = obj.variables
-        elif isinstance(obj, RustLibrary):
-            backend_file.rust_library = obj
         elif isinstance(obj, StaticLibrary):
             backend_file.static_lib = obj
         elif isinstance(obj, SharedLibrary):
             backend_file.shared_lib = obj
         elif isinstance(obj, (HostProgram, HostSimpleProgram)):
             backend_file.host_programs.append(obj)
         elif isinstance(obj, HostLibrary):
             backend_file.host_library = obj
@@ -606,18 +578,17 @@ class TupBackend(CommonBackend):
 
         for objdir, backend_file in sorted(self._backend_files.items()):
             backend_file.gen_sources_rules([self._installed_files])
             for var, gen_method in ((backend_file.shared_lib, self._gen_shared_library),
                                     (backend_file.static_lib and backend_file.static_lib.no_expand_lib,
                                      self._gen_static_library),
                                     (backend_file.programs, self._gen_programs),
                                     (backend_file.host_programs, self._gen_host_programs),
-                                    (backend_file.host_library, self._gen_host_library),
-                                    (backend_file.rust_library, self._gen_rust)):
+                                    (backend_file.host_library, self._gen_host_library)):
                 if var:
                     backend_file.export_shell()
                     gen_method(backend_file)
             for obj in backend_file.delayed_generated_files:
                 self._process_generated_file(backend_file, obj)
             for path, output, output_group in backend_file.delayed_installed_files:
                 backend_file.symlink_rule(path, output=output, output_group=output_group)
             with self._write_file(fh=backend_file):
@@ -645,186 +616,23 @@ class TupBackend(CommonBackend):
             fh.write('IDL_PARSER_DIR = $(topsrcdir)/xpcom/idl-parser\n')
             fh.write('IDL_PARSER_CACHE_DIR = $(MOZ_OBJ_ROOT)/xpcom/idl-parser/xpidl\n')
 
         # Run 'tup init' if necessary.
         if not os.path.exists(mozpath.join(self.environment.topsrcdir, ".tup")):
             tup = self.environment.substs.get('TUP', 'tup')
             self._cmd.run_process(cwd=self.environment.topsrcdir, log_name='tup', args=[tup, 'init'])
 
-
-    def _get_cargo_flags(self, obj):
-        cargo_flags = ['--build-plan', '-Z', 'unstable-options']
-        if not self.environment.substs.get('MOZ_DEBUG_RUST'):
-            cargo_flags += ['--release']
-        cargo_flags += [
-            '--frozen',
-            '--manifest-path', mozpath.join(obj.srcdir, 'Cargo.toml'),
-            '--lib',
-            '--target=%s' % self.environment.substs['RUST_TARGET'],
-        ]
-        if obj.features:
-            cargo_flags += [
-                '--features', ' '.join(obj.features)
-            ]
-        return cargo_flags
-
-    def _get_cargo_env(self, backend_file):
-        lib = backend_file.rust_library
-        env = {
-            'CARGO_TARGET_DIR': mozpath.normpath(mozpath.join(lib.objdir,
-                                                              lib.target_dir)),
-            'RUSTC': self.environment.substs['RUSTC'],
-            'MOZ_SRC': self.environment.topsrcdir,
-            'MOZ_DIST': self.environment.substs['DIST'],
-            'LIBCLANG_PATH': self.environment.substs['MOZ_LIBCLANG_PATH'],
-            'CLANG_PATH': self.environment.substs['MOZ_CLANG_PATH'],
-            'PKG_CONFIG_ALLOW_CROSS': '1',
-            'RUST_BACKTRACE': 'full',
-            'MOZ_TOPOBJDIR': self.environment.topobjdir,
-            'PYTHON': self.environment.substs['PYTHON'],
-            'PYTHONDONTWRITEBYTECODE': '1',
-        }
-        cargo_incremental = self.environment.substs.get('CARGO_INCREMENTAL')
-        if cargo_incremental is not None:
-            # TODO (bug 1468527): CARGO_INCREMENTAL produces outputs that Tup
-            # doesn't know about, disable it unconditionally for now.
-            pass # env['CARGO_INCREMENTAL'] = cargo_incremental
-
-        rust_simd = self.environment.substs.get('MOZ_RUST_SIMD')
-        if rust_simd is not None:
-            env['RUSTC_BOOTSTRAP'] = '1'
-
-        linker_env_var = ('CARGO_TARGET_%s_LINKER' %
-                          self.environment.substs['RUST_TARGET_ENV_NAME'])
-
-        env.update({
-            'MOZ_CARGO_WRAP_LDFLAGS': ' '.join(backend_file.local_flags['LDFLAGS']),
-            'MOZ_CARGO_WRAP_LD': backend_file.environment.substs['CC'],
-            linker_env_var: mozpath.join(self.environment.topsrcdir,
-                                         'build', 'cargo-linker'),
-            'RUSTFLAGS': '%s %s' % (' '.join(self.environment.substs['MOZ_RUST_DEFAULT_FLAGS']),
-                                    ' '.join(self.environment.substs['RUSTFLAGS'])),
-        })
-        return env
-
-    def _gen_cargo_rules(self, backend_file, build_plan, cargo_env):
-        invocations = build_plan['invocations']
-        processed = set()
-
-        def get_libloading_outdir():
-            for invocation in invocations:
-                if (invocation['package_name'] == 'libloading' and
-                    invocation['outputs'][0].endswith('.rlib')):
-                    return invocation['env']['OUT_DIR']
-
-        def display_name(invocation):
-            output_str = ''
-            if invocation['outputs']:
-                output_str = ' -> %s' % ' '.join([os.path.basename(f)
-                                                  for f in invocation['outputs']])
-            return '{name} v{version} {kind}{output}'.format(
-                name=invocation['package_name'],
-                version=invocation['package_version'],
-                kind=invocation['kind'],
-                output=output_str
-            )
-
-        def cargo_quote(s):
-            return shell_quote(s.replace('\n', '\\n'))
-
-        def _process(key, invocation):
-            if key in processed:
-                return
-            processed.add(key)
-            inputs = set()
-            shortname = invocation['package_name']
-            for dep in invocation['deps']:
-                # We'd expect to just handle dependencies transitively (so use
-                # invocations[dep]['outputs'] here, but because the weird host dependencies
-                # sometimes get used in the final library and not intermediate
-                # libraries, tup doesn't work well with them. So build up the full set
-                # of intermediate dependencies with 'full-deps'
-                depmod = invocations[dep]
-                _process(dep, depmod)
-                inputs.update(depmod['full-deps'])
-
-            command = [
-                'cd %s &&' % invocation['cwd'],
-                'env',
-            ]
-            envvars = invocation.get('env')
-            for k, v in itertools.chain(cargo_env.iteritems(),
-                                        envvars.iteritems()):
-                command.append("%s=%s" % (k, cargo_quote(v)))
-            command.append(invocation['program'])
-            command.extend(cargo_quote(a.replace('dep-info,', ''))
-                           for a in invocation['args'])
-            outputs = invocation['outputs']
-            if os.path.basename(invocation['program']) == 'build-script-build':
-                for output in cargo_extra_outputs.get(shortname, []):
-                    outputs.append(os.path.join(invocation['env']['OUT_DIR'], output))
-
-            if (invocation['target_kind'][0] == 'custom-build' and
-                os.path.basename(invocation['program']) == 'rustc'):
-                flags = cargo_extra_flags.get(shortname, [])
-                for flag in flags:
-                    command.append(flag % {'libloading_outdir': get_libloading_outdir()})
-
-            if 'rustc' in invocation['program']:
-                header = 'RUSTC'
-            else:
-                inputs.add(invocation['program'])
-                header = 'RUN'
-
-            invocation['full-deps'] = set(inputs)
-            invocation['full-deps'].update(invocation['outputs'])
-
-            backend_file.rule(
-                command,
-                inputs=sorted(inputs),
-                outputs=outputs,
-                extra_outputs=[self._rust_libs],
-                extra_inputs=[self._installed_files],
-                display='%s %s' % (header, display_name(invocation)),
-            )
-
-            for dst, link in invocation['links'].iteritems():
-                backend_file.symlink_rule(link, dst, self._rust_libs)
-
-        for val in enumerate(invocations):
-            _process(*val)
-
-
-    def _gen_rust(self, backend_file):
-        # TODO (bug 1468547): The gtest rust library depends on many of the same
-        # libraries as the main rust library, so we'll need to handle these all
-        # at once in order to build the gtest rust library.
-        if 'toolkit/library/gtest' in backend_file.objdir:
-            return
-
-        cargo_flags = self._get_cargo_flags(backend_file.rust_library)
-        cargo_env = self._get_cargo_env(backend_file)
-
-        output_lines = []
-        def accumulate_output(line):
-            output_lines.append(line)
-
-        cargo_status = self._cmd.run_process(
-            [self.environment.substs['CARGO'], 'build'] + cargo_flags,
-            line_handler=accumulate_output,
-            explicit_env=cargo_env)
-
-        cargo_plan = json.loads(''.join(output_lines))
-        self._gen_cargo_rules(backend_file, cargo_plan, cargo_env)
-        self.backend_input_files |= set(cargo_plan['inputs'])
-
-
     def _process_generated_file(self, backend_file, obj):
-        if obj.script and obj.method:
+        # TODO: These are directories that don't work in the tup backend
+        # yet, because things they depend on aren't built yet.
+        skip_directories = (
+            'toolkit/library', # libxul.so
+        )
+        if obj.script and obj.method and obj.relobjdir not in skip_directories:
             backend_file.export_shell()
             cmd = self._py_action('file_generate')
             if obj.localized:
                 cmd.append('--locale=en-US')
             cmd.extend([
                 obj.script,
                 obj.method,
                 obj.outputs[0],
@@ -849,35 +657,29 @@ class TupBackend(CommonBackend):
 
             if any(f.endswith(('automation.py', 'source-repo.h', 'buildid.h'))
                    for f in obj.outputs):
                 extra_outputs = [self._early_generated_files]
             else:
                 extra_outputs = [self._installed_files] if obj.required_for_compile else []
                 full_inputs += [self._early_generated_files]
 
-            extra_inputs = []
-            if any(f in obj.outputs for f in ('dependentlibs.list',
-                                              'dependendentlibs.list.gtest')):
-                extra_inputs += [self._shlibs]
-
             if len(outputs) > 3:
                 display_outputs = ', '.join(outputs[0:3]) + ', ...'
             else:
                 display_outputs = ', '.join(outputs)
             display = 'python {script}:{method} -> [{display_outputs}]'.format(
                 script=obj.script,
                 method=obj.method,
                 display_outputs=display_outputs
             )
             backend_file.rule(
                 display=display,
                 cmd=cmd,
                 inputs=full_inputs,
-                extra_inputs=extra_inputs,
                 outputs=outputs,
                 extra_outputs=extra_outputs,
                 check_unchanged=True,
             )
 
     def _process_defines(self, backend_file, obj, host=False):
         defines = list(obj.get_defines())
         if defines:
@@ -955,24 +757,28 @@ class TupBackend(CommonBackend):
                         backend_file.symlink_rule(f.full_path, output=f.target_basename, output_group=output_group)
                 else:
                     if (self.environment.is_artifact_build and
                         any(mozpath.match(f.target_basename, p) for p in self._compile_env_gen_files)):
                         # If we have an artifact build we never would have generated this file,
                         # so do not attempt to install it.
                         continue
 
-                    output = mozpath.join('$(MOZ_OBJ_ROOT)', target, path,
-                                          f.target_basename)
-                    gen_backend_file = self._get_backend_file(f.context.relobjdir)
-                    if gen_backend_file.requires_delay([f]):
-                        gen_backend_file.delayed_installed_files.append((f.full_path, output, output_group))
-                    else:
-                        gen_backend_file.symlink_rule(f.full_path, output=output,
-                                                      output_group=output_group)
+                    # We're not generating files in these directories yet, so
+                    # don't attempt to install files generated from them.
+                    if f.context.relobjdir not in ('toolkit/library',
+                                                   'js/src/shell'):
+                        output = mozpath.join('$(MOZ_OBJ_ROOT)', target, path,
+                                              f.target_basename)
+                        gen_backend_file = self._get_backend_file(f.context.relobjdir)
+                        if gen_backend_file.requires_delay([f]):
+                            gen_backend_file.delayed_installed_files.append((f.full_path, output, output_group))
+                        else:
+                            gen_backend_file.symlink_rule(f.full_path, output=output,
+                                                          output_group=output_group)
 
 
     def _process_final_target_pp_files(self, obj, backend_file):
         for i, (path, files) in enumerate(obj.files.walk()):
             self._add_features(obj.install_target, path)
             for f in files:
                 self._preprocess(backend_file, f.full_path,
                                  destdir=mozpath.join(self.environment.topobjdir, obj.install_target, path),
--- a/python/mozbuild/mozbuild/controller/building.py
+++ b/python/mozbuild/mozbuild/controller/building.py
@@ -1024,17 +1024,17 @@ class BuildDriver(MozbuildObject):
                 # backend (Tup), and otherwise be harmless.
                 if active_backend:
                     if backend_out_of_date(mozpath.join(self.topobjdir,
                                                         'backend.%sBackend' %
                                                         active_backend)):
                         print('Build configuration changed. Regenerating backend.')
                         args = [config.substs['PYTHON'],
                                 mozpath.join(self.topobjdir, 'config.status')]
-                        self.run_process(args, cwd=self.topobjdir, pass_thru=True)
+                        self.run_process(args, cwd=self.topobjdir)
                     backend_cls = get_backend_class(active_backend)(config)
                     return backend_cls.build(self, output, jobs, verbose, what)
                 return None
 
             monitor.start_resource_recording()
 
             config = None
             try:
--- a/taskcluster/ci/build/linux.yml
+++ b/taskcluster/ci/build/linux.yml
@@ -857,17 +857,17 @@ linux64-tup/opt:
         script: "mozharness/scripts/fx_desktop_build.py"
         secrets: true
         custom-build-variant-cfg: tup
         tooltool-downloads: public
         need-xvfb: true
     toolchains:
         - linux64-clang
         - linux64-gcc
-        - linux64-rust-nightly
+        - linux64-rust
         - linux64-sccache
         - linux64-tup
 
 linux64-jsdcov/opt:
     description: "Linux64-JSDCov Opt"
     index:
         product: firefox
         job-name: linux64-jsdcov-opt
--- a/taskcluster/ci/toolchain/linux.yml
+++ b/taskcluster/ci/toolchain/linux.yml
@@ -410,39 +410,16 @@ linux64-rust-1.24:
             '--channel', '1.24.0',
             '--host', 'x86_64-unknown-linux-gnu',
             '--target', 'x86_64-unknown-linux-gnu',
             '--target', 'i686-unknown-linux-gnu',
         ]
         toolchain-alias: linux64-rust
         toolchain-artifact: public/build/rustc.tar.xz
 
-linux64-rust-nightly:
-    description: "rust nightly repack"
-    treeherder:
-        kind: build
-        platform: toolchains/opt
-        symbol: TL(rust-nightly)
-        tier: 1
-    worker-type: aws-provisioner-v1/gecko-{level}-b-linux
-    worker:
-        max-run-time: 7200
-        env:
-            UPLOAD_DIR: artifacts
-    run:
-        using: toolchain-script
-        script: repack_rust.py
-        arguments: [
-            '--channel', 'nightly-2018-05-21',
-            '--host', 'x86_64-unknown-linux-gnu',
-            '--target', 'x86_64-unknown-linux-gnu',
-            '--target', 'i686-unknown-linux-gnu',
-        ]
-        toolchain-artifact: public/build/rustc.tar.xz
-
 linux64-rust-macos-1.24:
     description: "rust repack with macos-cross support"
     treeherder:
         kind: build
         platform: toolchains/opt
         symbol: TL(rust-macos)
         tier: 1
     worker-type: aws-provisioner-v1/gecko-{level}-b-linux
--- a/toolkit/library/dependentlibs.py
+++ b/toolkit/library/dependentlibs.py
@@ -123,18 +123,17 @@ def gen_list(output, lib):
     elif binary_type == MACHO:
         func = dependentlibs_otool
     else:
         ext = os.path.splitext(lib)[1]
         assert(ext == '.dll')
         func = dependentlibs_dumpbin
 
     deps = dependentlibs(lib, libpaths, func)
-    base_lib = mozpath.basename(lib)
-    deps[base_lib] = mozpath.join(libpaths[0], base_lib)
+    deps[lib] = mozpath.join(libpaths[0], lib)
     output.write('\n'.join(deps.keys()) + '\n')
 
     with open(output.name + ".gtest", 'w') as gtest_out:
         libs = deps.keys()
         libs[-1] = 'gtest/' + libs[-1]
         gtest_out.write('\n'.join(libs) + '\n')
 
     return set(deps.values())