Update to Rust 2018 edition (#632)

* initial cargo fix run

* Upgrade cranelift-entity crate

* Upgrade bforest crate

* Upgrade the codegen crate

* Upgrade the faerie crate

* Upgrade the filetests crate

* Upgrade the codegen-meta crate

* Upgrade the frontend crate

* Upgrade the cranelift-module crate

* Upgrade the cranelift-native crate

* Upgrade the cranelift-preopt crate

* Upgrade the cranelift-reader crate

* Upgrade the cranelift-serde crate

* Upgrade the cranelift-simplejit crate

* Upgrade the cranelift or cranelift-umbrella crate

* Upgrade the cranelift-wasm crate

* Upgrade cranelift-tools crate

* Use new import style on remaining files

* run format-all.sh

* run test-all.sh, update Readme and travis ci configuration
fixed an AssertionError also

* Remove deprecated functions

.travis.yml

@@ -7,7 +7,7 @@ language: rust
 rust:
     # The oldest version we currently support. See
     # CONTRIBUTING.md#rustc-version-support for details.
-    - 1.30.1
+    - 1.31.1
     - beta
     - nightly
 matrix:

cranelift/Cargo.toml

@@ -7,6 +7,7 @@ license = "Apache-2.0 WITH LLVM-exception"
 documentation = "https://cranelift.readthedocs.io/"
 repository = "https://github.com/CraneStation/cranelift"
 publish = false
+edition = "2018"
 
 [[bin]]
 name = "clif-util"

cranelift/README.md

@@ -10,7 +10,7 @@ into executable machine code.
 [![Travis Status](https://travis-ci.org/CraneStation/cranelift.svg?branch=master)](https://travis-ci.org/CraneStation/cranelift)
 [![Appveyor Status](https://ci.appveyor.com/api/projects/status/oub7wrrb59utuv8x?svg=true)](https://ci.appveyor.com/project/CraneStation/cranelift)
 [![Gitter chat](https://badges.gitter.im/CraneStation/CraneStation.svg)](https://gitter.im/CraneStation/Lobby)
-![Minimum rustc 1.30](https://img.shields.io/badge/rustc-1.30+-green.svg)
+![Minimum rustc 1.31](https://img.shields.io/badge/rustc-1.31+-green.svg)
 
 For more information, see [the
 documentation](https://cranelift.readthedocs.io/en/latest/?badge=latest).

cranelift/src/cat.rs

@@ -3,9 +3,9 @@
 //! Read a sequence of Cranelift IR files and print them again to stdout. This has the effect of
 //! normalizing formatting and removing comments.
 
+use crate::utils::read_to_string;
+use crate::CommandResult;
 use cranelift_reader::parse_functions;
-use utils::read_to_string;
-use CommandResult;
 
 pub fn run(files: &[String]) -> CommandResult {
     for (i, f) in files.into_iter().enumerate() {

cranelift/src/clif-util.rs

@@ -13,28 +13,13 @@
     )
 )]
 
-extern crate file_per_thread_logger;
-#[macro_use]
-extern crate cfg_if;
-#[cfg(feature = "disas")]
-extern crate capstone;
-extern crate clap;
-extern crate cranelift_codegen;
-#[cfg(feature = "wasm")]
-extern crate cranelift_entity;
-extern crate cranelift_filetests;
-extern crate cranelift_reader;
-extern crate pretty_env_logger;
+use cfg_if::cfg_if;
 
 cfg_if! {
     if #[cfg(feature = "wasm")] {
-        extern crate cranelift_wasm;
-        extern crate term;
-        extern crate wabt;
         mod wasm;
     }
 }
-extern crate target_lexicon;
 
 use clap::{App, Arg, SubCommand};
 use cranelift_codegen::dbg::LOG_FILENAME_PREFIX;

cranelift/src/compile.rs

@@ -1,5 +1,7 @@
 //! CLI tool to read Cranelift IR files and compile them into native code.
 
+use crate::utils::{parse_sets_and_triple, read_to_string};
+use cfg_if::cfg_if;
 use cranelift_codegen::isa::TargetIsa;
 use cranelift_codegen::print_errors::pretty_error;
 use cranelift_codegen::settings::FlagsOrIsa;
@@ -9,7 +11,6 @@ use cranelift_codegen::{binemit, ir};
 use cranelift_reader::parse_test;
 use std::path::Path;
 use std::path::PathBuf;
-use utils::{parse_sets_and_triple, read_to_string};
 
 struct PrintRelocs {
     flag_print: bool,

cranelift/src/print_cfg.rs

@@ -3,10 +3,10 @@
 //! Read a series of Cranelift IR files and print their control flow graphs
 //! in graphviz format.
 
+use crate::utils::read_to_string;
+use crate::CommandResult;
 use cranelift_codegen::cfg_printer::CFGPrinter;
 use cranelift_reader::parse_functions;
-use utils::read_to_string;
-use CommandResult;
 
 pub fn run(files: &[String]) -> CommandResult {
     for (i, f) in files.into_iter().enumerate() {

cranelift/src/wasm.rs

@@ -18,7 +18,7 @@ use cranelift_wasm::{
 use std::path::Path;
 use std::path::PathBuf;
 use term;
-use utils::{parse_sets_and_triple, read_to_end};
+use crate::utils::{parse_sets_and_triple, read_to_end};
 use wabt::wat2wasm;
 
 macro_rules! vprintln {

cranelift/tests/filetests.rs

@@ -1,5 +1,3 @@
-extern crate cranelift_filetests;
-
 #[test]
 fn filetests() {
     // Run all the filetests in the following directories.

lib/bforest/Cargo.toml

@@ -9,6 +9,7 @@ repository = "https://github.com/CraneStation/cranelift"
 categories = ["no-std"]
 readme = "README.md"
 keywords = ["btree", "forest", "set", "map"]
+edition = "2018"
 
 [dependencies]
 cranelift-entity = { path = "../entity", version = "0.26.0", default-features = false }

lib/bforest/src/lib.rs

@@ -48,7 +48,7 @@ mod std {
 
 #[macro_use]
 extern crate cranelift_entity as entity;
-use entity::packed_option;
+use crate::entity::packed_option;
 
 use std::borrow::BorrowMut;
 use std::cmp::Ordering;
@@ -157,7 +157,7 @@ fn slice_shift<T: Copy>(s: &mut [T], n: usize) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use entity::EntityRef;
+    use crate::entity::EntityRef;
 
     /// An opaque reference to an extended basic block in a function.
     #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

lib/bforest/src/map.rs

@@ -1,7 +1,7 @@
 //! Forest of maps.
 
 use super::{Comparator, Forest, Node, NodeData, NodePool, Path, INNER_SIZE};
-use packed_option::PackedOption;
+use crate::packed_option::PackedOption;
 #[cfg(test)]
 use std::fmt;
 use std::marker::PhantomData;

lib/bforest/src/pool.rs

@@ -3,7 +3,7 @@
 #[cfg(test)]
 use super::Comparator;
 use super::{Forest, Node, NodeData};
-use entity::PrimaryMap;
+use crate::entity::PrimaryMap;
 #[cfg(test)]
 use std::fmt;
 use std::ops::{Index, IndexMut};
@@ -83,7 +83,7 @@ impl<F: Forest> NodePool<F> {
         NodeData<F>: fmt::Display,
         F::Key: fmt::Display,
     {
-        use entity::SparseSet;
+        use crate::entity::SparseSet;
         use std::borrow::Borrow;
         use std::cmp::Ordering;
         use std::vec::Vec;

lib/bforest/src/set.rs

@@ -1,7 +1,7 @@
 //! Forest of sets.
 
 use super::{Comparator, Forest, Node, NodeData, NodePool, Path, SetValue, INNER_SIZE};
-use packed_option::PackedOption;
+use crate::packed_option::PackedOption;
 #[cfg(test)]
 use std::fmt;
 use std::marker::PhantomData;

lib/codegen/Cargo.toml

@@ -10,6 +10,7 @@ categories = ["no-std"]
 readme = "README.md"
 keywords = ["compile", "compiler", "jit"]
 build = "build.rs"
+edition = "2018"
 
 [dependencies]
 cranelift-entity = { path = "../entity", version = "0.26.0", default-features = false }

lib/codegen/build.rs

@@ -18,9 +18,9 @@
 // The build script expects to be run from the directory where this build.rs file lives. The
 // current directory is used to find the sources.
 
-extern crate cranelift_codegen_meta as meta;
+use cranelift_codegen_meta as meta;
 
-use meta::isa::Isa;
+use crate::meta::isa::Isa;
 use std::env;
 use std::process;
 use std::time::Instant;

lib/codegen/meta-python/cdsl/predicates.py

@@ -244,7 +244,8 @@ class FieldPredicate(object):
         """
         # Prepend `field` to the predicate function arguments.
         args = (self.field.rust_name(),) + tuple(map(str, self.args))
-        return '::predicates::{}({})'.format(self.function, ', '.join(args))
+        return 'crate::predicates::{}({})'\
+            .format(self.function, ', '.join(args))
 
 
 class IsEqual(FieldPredicate):

lib/codegen/meta-python/cdsl/xform.py

@@ -394,7 +394,7 @@ class XFormGroup(object):
             # table referring to it.
             return self.name
         else:
-            return '::legalizer::{}'.format(self.name)
+            return 'crate::legalizer::{}'.format(self.name)
 
     def legalize(self, src, dst):
         # type: (Union[Def, Apply], Rtl) -> None

lib/codegen/meta-python/gen_encoding.py

@@ -110,7 +110,7 @@ def emit_instp(instp, fmt, has_func=False):
     fields = ', '.join(sorted(fnames))
 
     with fmt.indented(
-            'if let ir::InstructionData::{} {{ {}, .. }} = *inst {{'
+            'if let crate::ir::InstructionData::{} {{ {}, .. }} = *inst {{'
             .format(iform.name, fields), '}'):
         if has_type_check:
             # We could implement this if we need to.
@@ -132,7 +132,8 @@ def emit_inst_predicates(instps, fmt):
     for instp, number in instps.items():
         name = 'inst_predicate_{}'.format(number)
         with fmt.indented(
-                'fn {}(func: &ir::Function, inst: &ir::InstructionData)'
+                'fn {}(func: &crate::ir::Function, '
+                'inst: &crate::ir::InstructionData)'
                 '-> bool {{'.format(name), '}'):
             emit_instp(instp, fmt, has_func=True)
 
@@ -168,7 +169,7 @@ def emit_recipe_predicates(isa, fmt):
 
         # Generate the predicate function.
         with fmt.indented(
-                'fn {}({}: ::settings::PredicateView, '
+                'fn {}({}: crate::settings::PredicateView, '
                 '{}: &ir::InstructionData) -> bool {{'
                 .format(
                     name,
@@ -657,7 +658,8 @@ def emit_level2_hashtables(level2_hashtables, offt, level2_doc, fmt):
             if entry:
                 fmt.line(
                         'Level2Entry ' +
-                        '{{ opcode: Some(ir::Opcode::{}), offset: {:#08x} }},'
+                        '{{ opcode: Some(crate::ir::Opcode::{}), '
+                        'offset: {:#08x} }},'
                         .format(entry.inst.camel_name, entry.offset))
             else:
                 fmt.line(
@@ -682,15 +684,15 @@ def emit_level1_hashtable(cpumode, level1, offt, fmt):
             # Empty hash table entry. Include the default legalization action.
             if not level2:
                 fmt.format(
-                        'Level1Entry {{ ty: ir::types::INVALID, log2len: !0, '
-                        'offset: 0, legalize: {} }},',
+                        'Level1Entry {{ ty: crate::ir::types::INVALID, '
+                        'log2len: !0, offset: 0, legalize: {} }},',
                         level1.legalize_code)
                 continue
 
             if level2.ty is not None:
                 tyname = level2.ty.rust_name()
             else:
-                tyname = 'ir::types::INVALID'
+                tyname = 'crate::ir::types::INVALID'
 
             lcode = cpumode.isa.legalize_code(level2.legalize)
 

lib/codegen/meta-python/gen_instr.py

@@ -661,7 +661,7 @@ def gen_inst_builder(inst, fmt):
     # The controlling type variable will be inferred from the input values if
     # possible. Otherwise, it is the first method argument.
     if inst.is_polymorphic and not inst.use_typevar_operand:
-        args.append('{}: ir::Type'.format(inst.ctrl_typevar.name))
+        args.append('{}: crate::ir::Type'.format(inst.ctrl_typevar.name))
 
     tmpl_types = list()  # type: List[str]
     into_args = list()  # type: List[str]

lib/codegen/meta-python/gen_legalizer.py

@@ -103,19 +103,21 @@ def emit_runtime_typecheck(check, fmt, type_sets):
 
         base_exp = build_derived_expr(tv.base)
         if (tv.derived_func == TypeVar.LANEOF):
-            return "{}.map(|t: ir::Type| t.lane_type())".format(base_exp)
+            return "{}.map(|t: crate::ir::Type| t.lane_type())"\
+                .format(base_exp)
         elif (tv.derived_func == TypeVar.ASBOOL):
-            return "{}.map(|t: ir::Type| t.as_bool())".format(base_exp)
+            return "{}.map(|t: crate::ir::Type| t.as_bool())".format(base_exp)
         elif (tv.derived_func == TypeVar.HALFWIDTH):
-            return "{}.and_then(|t: ir::Type| t.half_width())".format(base_exp)
+            return "{}.and_then(|t: crate::ir::Type| t.half_width())"\
+                .format(base_exp)
         elif (tv.derived_func == TypeVar.DOUBLEWIDTH):
-            return "{}.and_then(|t: ir::Type| t.double_width())"\
+            return "{}.and_then(|t: crate::ir::Type| t.double_width())"\
                 .format(base_exp)
         elif (tv.derived_func == TypeVar.HALFVECTOR):
-            return "{}.and_then(|t: ir::Type| t.half_vector())"\
+            return "{}.and_then(|t: crate::ir::Type| t.half_vector())"\
                 .format(base_exp)
         elif (tv.derived_func == TypeVar.DOUBLEVECTOR):
-            return "{}.and_then(|t: ir::Type| t.by(2))".format(base_exp)
+            return "{}.and_then(|t: crate::ir::Type| t.by(2))".format(base_exp)
         else:
             assert False, "Unknown derived function {}".format(tv.derived_func)
 
@@ -174,7 +176,7 @@ def unwrap_inst(iref, node, fmt):
     arg_names = tuple(
             arg.name if isinstance(arg, Var) else '_' for arg in expr.args)
     with fmt.indented(
-            'let ({}, predicate) = if let ir::InstructionData::{} {{'
+            'let ({}, predicate) = if let crate::ir::InstructionData::{} {{'
             .format(', '.join(map(str, arg_names)), iform.name), '};'):
         # Fields are encoded directly.
         for f in iform.imm_fields:
@@ -359,13 +361,13 @@ def gen_xform_group(xgrp, fmt, type_sets):
     fmt.doc_comment("Legalize `inst`.")
     fmt.line('#[allow(unused_variables,unused_assignments,non_snake_case)]')
     with fmt.indented('pub fn {}('.format(xgrp.name)):
-        fmt.line('inst: ir::Inst,')
-        fmt.line('func: &mut ir::Function,')
-        fmt.line('cfg: &mut ::flowgraph::ControlFlowGraph,')
-        fmt.line('isa: &::isa::TargetIsa,')
+        fmt.line('inst: crate::ir::Inst,')
+        fmt.line('func: &mut crate::ir::Function,')
+        fmt.line('cfg: &mut crate::flowgraph::ControlFlowGraph,')
+        fmt.line('isa: &crate::isa::TargetIsa,')
     with fmt.indented(') -> bool {', '}'):
-        fmt.line('use ir::InstBuilder;')
-        fmt.line('use cursor::{Cursor, FuncCursor};')
+        fmt.line('use crate::ir::InstBuilder;')
+        fmt.line('use crate::cursor::{Cursor, FuncCursor};')
         fmt.line('let mut pos = FuncCursor::new(func).at_inst(inst);')
         fmt.line('pos.use_srcloc(inst);')
 

lib/codegen/meta-python/gen_settings.py

@@ -117,10 +117,10 @@ def gen_getters(sgrp, fmt):
     with fmt.indented('impl Flags {', '}'):
         fmt.doc_comment('Get a view of the boolean predicates.')
         with fmt.indented(
-                'pub fn predicate_view(&self) -> ::settings::PredicateView {',
-                '}'):
+                'pub fn predicate_view(&self) -> '
+                'crate::settings::PredicateView {', '}'):
             fmt.format(
-                    '::settings::PredicateView::new(&self.bytes[{}..])',
+                    'crate::settings::PredicateView::new(&self.bytes[{}..])',
                     sgrp.boolean_offset)
         if sgrp.settings:
             fmt.doc_comment('Dynamic numbered predicate getter.')

lib/codegen/meta-python/isa/x86/recipes.py

@@ -1934,7 +1934,7 @@ icscc = TailRecipe(
         PUT_OP(bits, rex2(in_reg0, in_reg1), sink);
         modrm_rr(in_reg0, in_reg1, sink);
         // `setCC` instruction, no REX.
-        use ir::condcodes::IntCC::*;
+        use crate::ir::condcodes::IntCC::*;
         let setcc = match cond {
             Equal => 0x94,
             NotEqual => 0x95,
@@ -1962,7 +1962,7 @@ icscc_ib = TailRecipe(
         let imm: i64 = imm.into();
         sink.put1(imm as u8);
         // `setCC` instruction, no REX.
-        use ir::condcodes::IntCC::*;
+        use crate::ir::condcodes::IntCC::*;
         let setcc = match cond {
             Equal => 0x94,
             NotEqual => 0x95,
@@ -1990,7 +1990,7 @@ icscc_id = TailRecipe(
         let imm: i64 = imm.into();
         sink.put4(imm as u32);
         // `setCC` instruction, no REX.
-        use ir::condcodes::IntCC::*;
+        use crate::ir::condcodes::IntCC::*;
         let setcc = match cond {
             Equal => 0x94,
             NotEqual => 0x95,
@@ -2030,7 +2030,7 @@ fcscc = TailRecipe(
         PUT_OP(bits, rex2(in_reg1, in_reg0), sink);
         modrm_rr(in_reg1, in_reg0, sink);
         // `setCC` instruction, no REX.
-        use ir::condcodes::FloatCC::*;
+        use crate::ir::condcodes::FloatCC::*;
         let setcc = match cond {
             Ordered                    => 0x9b, // EQ|LT|GT => setnp (P=0)
             Unordered                  => 0x9a, // UN       => setp  (P=1)

lib/codegen/meta-python/test_gen_legalizer.py

@@ -148,9 +148,9 @@ class TestRuntimeChecks(TestCase):
                 self.v5 << vselect(self.v1, self.v3, self.v4),
         )
         x = XForm(r, r)
-        tv2_exp = 'Some({}).map(|t: ir::Type| t.as_bool())'\
+        tv2_exp = 'Some({}).map(|t: crate::ir::Type| t.as_bool())'\
             .format(self.v2.get_typevar().name)
-        tv3_exp = 'Some({}).map(|t: ir::Type| t.as_bool())'\
+        tv3_exp = 'Some({}).map(|t: crate::ir::Type| t.as_bool())'\
             .format(self.v3.get_typevar().name)
 
         self.check_yo_check(

lib/codegen/meta/Cargo.toml

@@ -6,6 +6,7 @@ description = "Metaprogram for cranelift-codegen code generator library"
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/CraneStation/cranelift"
 readme = "README.md"
+edition = "2018"
 
 [dependencies]
 cranelift-entity = { path = "../../entity", version = "0.26.0" }

lib/codegen/meta/src/base/settings.rs

@@ -1,4 +1,4 @@
-use cdsl::settings::{SettingGroup, SettingGroupBuilder};
+use crate::cdsl::settings::{SettingGroup, SettingGroupBuilder};
 
 pub fn generate() -> SettingGroup {
     let mut settings = SettingGroupBuilder::new("shared");

lib/codegen/meta/src/cdsl/regs.rs

@@ -1,3 +1,4 @@
+use cranelift_entity::entity_impl;
 use cranelift_entity::EntityRef;
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

lib/codegen/meta/src/cdsl/types.rs

@@ -5,7 +5,7 @@
 
 use std::fmt;
 
-use base::types as base_types;
+use crate::base::types as base_types;
 
 // Numbering scheme for value types:
 //

lib/codegen/meta/src/gen_registers.rs

@@ -1,8 +1,8 @@
-use cdsl::isa::TargetIsa;
-use cdsl::regs::{RegBank, RegClass};
+use crate::cdsl::isa::TargetIsa;
+use crate::cdsl::regs::{RegBank, RegClass};
+use crate::error;
+use crate::srcgen::Formatter;
 use cranelift_entity::EntityRef;
-use error;
-use srcgen::Formatter;
 
 fn gen_regbank(fmt: &mut Formatter, reg_bank: &RegBank) {
     let names = if reg_bank.names.len() > 0 {

lib/codegen/meta/src/gen_settings.rs

@@ -1,12 +1,14 @@
-use base;
-use cdsl::camel_case;
-use cdsl::isa::TargetIsa;
-use cdsl::settings::{BoolSetting, Predicate, Preset, Setting, SettingGroup, SpecificSetting};
-use constant_hash::{generate_table, simple_hash};
-use error;
-use srcgen::{Formatter, Match};
+use crate::base;
+use crate::cdsl::camel_case;
+use crate::cdsl::isa::TargetIsa;
+use crate::cdsl::settings::{
+    BoolSetting, Predicate, Preset, Setting, SettingGroup, SpecificSetting,
+};
+use crate::constant_hash::{generate_table, simple_hash};
+use crate::error;
+use crate::srcgen::{Formatter, Match};
+use crate::unique_table::UniqueTable;
 use std::collections::HashMap;
-use unique_table::UniqueTable;
 
 enum ParentGroup {
     None,

lib/codegen/meta/src/gen_types.rs

@@ -7,9 +7,9 @@
 //! This ensures that the metaprogram and the generated program see the same
 //! type numbering.
 
-use cdsl::types as cdsl_types;
-use error;
-use srcgen;
+use crate::cdsl::types as cdsl_types;
+use crate::error;
+use crate::srcgen;
 
 /// Emit a constant definition of a single value type.
 fn emit_type(ty: &cdsl_types::ValueType, fmt: &mut srcgen::Formatter) -> Result<(), error::Error> {

lib/codegen/meta/src/isa/arm32/mod.rs

@@ -1,6 +1,6 @@
-use cdsl::isa::{TargetIsa, TargetIsaBuilder};
-use cdsl::regs::{RegBankBuilder, RegClassBuilder};
-use cdsl::settings::{SettingGroup, SettingGroupBuilder};
+use crate::cdsl::isa::{TargetIsa, TargetIsaBuilder};
+use crate::cdsl::regs::{RegBankBuilder, RegClassBuilder};
+use crate::cdsl::settings::{SettingGroup, SettingGroupBuilder};
 
 fn define_settings(_shared: &SettingGroup) -> SettingGroup {
     let setting = SettingGroupBuilder::new("arm32");

lib/codegen/meta/src/isa/arm64/mod.rs

@@ -1,6 +1,6 @@
-use cdsl::isa::{TargetIsa, TargetIsaBuilder};
-use cdsl::regs::{RegBankBuilder, RegClassBuilder};
-use cdsl::settings::{SettingGroup, SettingGroupBuilder};
+use crate::cdsl::isa::{TargetIsa, TargetIsaBuilder};
+use crate::cdsl::regs::{RegBankBuilder, RegClassBuilder};
+use crate::cdsl::settings::{SettingGroup, SettingGroupBuilder};
 
 fn define_settings(_shared: &SettingGroup) -> SettingGroup {
     let setting = SettingGroupBuilder::new("arm64");

lib/codegen/meta/src/isa/mod.rs

@@ -1,5 +1,5 @@
-use cdsl::isa::TargetIsa;
-use cdsl::settings::SettingGroup;
+use crate::cdsl::isa::TargetIsa;
+use crate::cdsl::settings::SettingGroup;
 use std::fmt;
 
 mod arm32;

lib/codegen/meta/src/isa/riscv/mod.rs

@@ -1,6 +1,6 @@
-use cdsl::isa::{TargetIsa, TargetIsaBuilder};
-use cdsl::regs::{RegBankBuilder, RegClassBuilder};
-use cdsl::settings::{PredicateNode, SettingGroup, SettingGroupBuilder};
+use crate::cdsl::isa::{TargetIsa, TargetIsaBuilder};
+use crate::cdsl::regs::{RegBankBuilder, RegClassBuilder};
+use crate::cdsl::settings::{PredicateNode, SettingGroup, SettingGroupBuilder};
 
 fn define_settings(shared: &SettingGroup) -> SettingGroup {
     let mut setting = SettingGroupBuilder::new("riscv");

lib/codegen/meta/src/isa/x86/mod.rs

@@ -1,6 +1,6 @@
-use cdsl::isa::{TargetIsa, TargetIsaBuilder};
-use cdsl::regs::{RegBankBuilder, RegClassBuilder};
-use cdsl::settings::{PredicateNode, SettingGroup, SettingGroupBuilder};
+use crate::cdsl::isa::{TargetIsa, TargetIsaBuilder};
+use crate::cdsl::regs::{RegBankBuilder, RegClassBuilder};
+use crate::cdsl::settings::{PredicateNode, SettingGroup, SettingGroupBuilder};
 
 pub fn define_settings(_shared: &SettingGroup) -> SettingGroup {
     let mut settings = SettingGroupBuilder::new("x86");

lib/codegen/meta/src/lib.rs

@@ -1,6 +1,3 @@
-#[macro_use]
-extern crate cranelift_entity;
-
 #[macro_use]
 mod cdsl;
 

lib/codegen/meta/src/srcgen.rs

@@ -9,7 +9,7 @@ use std::fs;
 use std::io::Write;
 use std::path;
 
-use error;
+use crate::error;
 
 static SHIFTWIDTH: usize = 4;
 
@@ -151,7 +151,7 @@ fn _indent(s: &str) -> Option<usize> {
     if s.is_empty() {
         None
     } else {
-        let t = s.trim_left();
+        let t = s.trim_start();
         Some(s.len() - t.len())
     }
 }
@@ -169,7 +169,7 @@ fn parse_multiline(s: &str) -> Vec<String> {
         .iter()
         .skip(1)
         .filter(|l| !l.trim().is_empty())
-        .map(|l| l.len() - l.trim_left().len())
+        .map(|l| l.len() - l.trim_start().len())
         .min();
 
     // Strip off leading blank lines.
@@ -186,12 +186,12 @@ fn parse_multiline(s: &str) -> Vec<String> {
         // Note that empty lines may have fewer than `indent` chars.
         lines_iter
             .map(|l| &l[cmp::min(indent, l.len())..])
-            .map(|l| l.trim_right())
+            .map(|l| l.trim_end())
             .map(|l| l.to_string())
             .collect::<Vec<_>>()
     } else {
         lines_iter
-            .map(|l| l.trim_right())
+            .map(|l| l.trim_end())
             .map(|l| l.to_string())
             .collect::<Vec<_>>()
     };

lib/codegen/src/abi.rs

@@ -3,7 +3,7 @@
 //! This module provides functions and data structures that are useful for implementing the
 //! `TargetIsa::legalize_signature()` method.
 
-use ir::{AbiParam, ArgumentExtension, ArgumentLoc, Type};
+use crate::ir::{AbiParam, ArgumentExtension, ArgumentLoc, Type};
 use std::cmp::Ordering;
 use std::vec::Vec;
 
@@ -182,8 +182,8 @@ pub fn legalize_abi_value(have: Type, arg: &AbiParam) -> ValueConversion {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ir::types;
-    use ir::AbiParam;
+    use crate::ir::types;
+    use crate::ir::AbiParam;
 
     #[test]
     fn legalize() {

lib/codegen/src/binemit/memorysink.rs

@@ -15,7 +15,7 @@
 //! `CodeSink::put*` methods, so the performance impact of the virtual callbacks is less severe.
 
 use super::{Addend, CodeOffset, CodeSink, Reloc};
-use ir::{ExternalName, JumpTable, SourceLoc, TrapCode};
+use crate::ir::{ExternalName, JumpTable, SourceLoc, TrapCode};
 use std::ptr::write_unaligned;
 
 /// A `CodeSink` that writes binary machine code directly into memory.
@@ -57,13 +57,13 @@ impl<'a> MemoryCodeSink<'a> {
 /// A trait for receiving relocations for code that is emitted directly into memory.
 pub trait RelocSink {
     /// Add a relocation referencing an EBB at the current offset.
-    fn reloc_ebb(&mut self, CodeOffset, Reloc, CodeOffset);
+    fn reloc_ebb(&mut self, _: CodeOffset, _: Reloc, _: CodeOffset);
 
     /// Add a relocation referencing an external symbol at the current offset.
-    fn reloc_external(&mut self, CodeOffset, Reloc, &ExternalName, Addend);
+    fn reloc_external(&mut self, _: CodeOffset, _: Reloc, _: &ExternalName, _: Addend);
 
     /// Add a relocation referencing a jump table.
-    fn reloc_jt(&mut self, CodeOffset, Reloc, JumpTable);
+    fn reloc_jt(&mut self, _: CodeOffset, _: Reloc, _: JumpTable);
 }
 
 /// A trait for receiving trap codes and offsets.
@@ -72,7 +72,7 @@ pub trait RelocSink {
 /// [`NullTrapSink`](binemit/trait.TrapSink.html) implementation.
 pub trait TrapSink {
     /// Add trap information for a specific offset.
-    fn trap(&mut self, CodeOffset, SourceLoc, TrapCode);
+    fn trap(&mut self, _: CodeOffset, _: SourceLoc, _: TrapCode);
 }
 
 impl<'a> CodeSink for MemoryCodeSink<'a> {

lib/codegen/src/binemit/mod.rs

@@ -10,9 +10,9 @@ mod shrink;
 pub use self::memorysink::{MemoryCodeSink, NullTrapSink, RelocSink, TrapSink};
 pub use self::relaxation::relax_branches;
 pub use self::shrink::shrink_instructions;
-pub use regalloc::RegDiversions;
+pub use crate::regalloc::RegDiversions;
 
-use ir::{ExternalName, Function, Inst, JumpTable, SourceLoc, TrapCode};
+use crate::ir::{ExternalName, Function, Inst, JumpTable, SourceLoc, TrapCode};
 use std::fmt;
 
 /// Offset in bytes from the beginning of the function.
@@ -72,28 +72,28 @@ pub trait CodeSink {
     fn offset(&self) -> CodeOffset;
 
     /// Add 1 byte to the code section.
-    fn put1(&mut self, u8);
+    fn put1(&mut self, _: u8);
 
     /// Add 2 bytes to the code section.
-    fn put2(&mut self, u16);
+    fn put2(&mut self, _: u16);
 
     /// Add 4 bytes to the code section.
-    fn put4(&mut self, u32);
+    fn put4(&mut self, _: u32);
 
     /// Add 8 bytes to the code section.
-    fn put8(&mut self, u64);
+    fn put8(&mut self, _: u64);
 
     /// Add a relocation referencing an EBB at the current offset.
-    fn reloc_ebb(&mut self, Reloc, CodeOffset);
+    fn reloc_ebb(&mut self, _: Reloc, _: CodeOffset);
 
     /// Add a relocation referencing an external symbol plus the addend at the current offset.
-    fn reloc_external(&mut self, Reloc, &ExternalName, Addend);
+    fn reloc_external(&mut self, _: Reloc, _: &ExternalName, _: Addend);
 
     /// Add a relocation referencing a jump table.
-    fn reloc_jt(&mut self, Reloc, JumpTable);
+    fn reloc_jt(&mut self, _: Reloc, _: JumpTable);
 
     /// Add trap information for the current offset.
-    fn trap(&mut self, TrapCode, SourceLoc);
+    fn trap(&mut self, _: TrapCode, _: SourceLoc);
 
     /// Code output is complete, read-only data may follow.
     fn begin_rodata(&mut self);

lib/codegen/src/binemit/relaxation.rs

@@ -27,14 +27,15 @@
 //! ebb23:
 //! ```
 
-use binemit::CodeOffset;
-use cursor::{Cursor, FuncCursor};
-use ir::{Function, InstructionData, Opcode};
-use isa::{EncInfo, TargetIsa};
-use iterators::IteratorExtras;
-use regalloc::RegDiversions;
-use timing;
-use CodegenResult;
+use crate::binemit::CodeOffset;
+use crate::cursor::{Cursor, FuncCursor};
+use crate::ir::{Function, InstructionData, Opcode};
+use crate::isa::{EncInfo, TargetIsa};
+use crate::iterators::IteratorExtras;
+use crate::regalloc::RegDiversions;
+use crate::timing;
+use crate::CodegenResult;
+use log::debug;
 
 /// Relax branches and compute the final layout of EBB headers in `func`.
 ///

lib/codegen/src/binemit/shrink.rs

@@ -5,11 +5,12 @@
 //! flexibility. However, once register allocation is done, this is no longer important, and we
 //! can switch to smaller encodings when possible.
 
-use ir::instructions::InstructionData;
-use ir::Function;
-use isa::TargetIsa;
-use regalloc::RegDiversions;
-use timing;
+use crate::ir::instructions::InstructionData;
+use crate::ir::Function;
+use crate::isa::TargetIsa;
+use crate::regalloc::RegDiversions;
+use crate::timing;
+use log::debug;
 
 /// Pick the smallest valid encodings for instructions.
 pub fn shrink_instructions(func: &mut Function, isa: &TargetIsa) {

lib/codegen/src/cfg_printer.rs

@@ -2,9 +2,9 @@
 
 use std::fmt::{Display, Formatter, Result, Write};
 
-use flowgraph::{BasicBlock, ControlFlowGraph};
-use ir::instructions::BranchInfo;
-use ir::Function;
+use crate::flowgraph::{BasicBlock, ControlFlowGraph};
+use crate::ir::instructions::BranchInfo;
+use crate::ir::Function;
 
 /// A utility for pretty-printing the CFG of a `Function`.
 pub struct CFGPrinter<'a> {

lib/codegen/src/context.rs

@@ -9,28 +9,28 @@
 //! contexts concurrently. Typically, you would have one context per compilation thread and only a
 //! single ISA instance.
 
-use binemit::{
+use crate::binemit::{
     relax_branches, shrink_instructions, CodeOffset, MemoryCodeSink, RelocSink, TrapSink,
 };
-use dce::do_dce;
-use dominator_tree::DominatorTree;
-use flowgraph::ControlFlowGraph;
-use ir::Function;
-use isa::TargetIsa;
-use legalize_function;
-use licm::do_licm;
-use loop_analysis::LoopAnalysis;
-use nan_canonicalization::do_nan_canonicalization;
-use postopt::do_postopt;
-use regalloc;
-use result::CodegenResult;
-use settings::{FlagsOrIsa, OptLevel};
-use simple_gvn::do_simple_gvn;
-use simple_preopt::do_preopt;
+use crate::dce::do_dce;
+use crate::dominator_tree::DominatorTree;
+use crate::flowgraph::ControlFlowGraph;
+use crate::ir::Function;
+use crate::isa::TargetIsa;
+use crate::legalize_function;
+use crate::licm::do_licm;
+use crate::loop_analysis::LoopAnalysis;
+use crate::nan_canonicalization::do_nan_canonicalization;
+use crate::postopt::do_postopt;
+use crate::regalloc;
+use crate::result::CodegenResult;
+use crate::settings::{FlagsOrIsa, OptLevel};
+use crate::simple_gvn::do_simple_gvn;
+use crate::simple_preopt::do_preopt;
+use crate::timing;
+use crate::unreachable_code::eliminate_unreachable_code;
+use crate::verifier::{verify_context, verify_locations, VerifierErrors, VerifierResult};
 use std::vec::Vec;
-use timing;
-use unreachable_code::eliminate_unreachable_code;
-use verifier::{verify_context, verify_locations, VerifierErrors, VerifierResult};
 
 /// Persistent data structures and compilation pipeline.
 pub struct Context {

lib/codegen/src/cursor.rs

@@ -2,8 +2,8 @@
 //!
 //! This module defines cursor data types that can be used for inserting instructions.
 
-use ir;
-use isa::TargetIsa;
+use crate::ir;
+use crate::isa::TargetIsa;
 
 /// The possible positions of a cursor.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]

lib/codegen/src/dce.rs

@@ -3,13 +3,13 @@
 //! Dead code here means instructions that have no side effects and have no
 //! result values used by other instructions.
 
-use cursor::{Cursor, FuncCursor};
-use dominator_tree::DominatorTree;
-use entity::EntityRef;
-use ir::instructions::InstructionData;
-use ir::{DataFlowGraph, Function, Inst, Opcode};
+use crate::cursor::{Cursor, FuncCursor};
+use crate::dominator_tree::DominatorTree;
+use crate::entity::EntityRef;
+use crate::ir::instructions::InstructionData;
+use crate::ir::{DataFlowGraph, Function, Inst, Opcode};
+use crate::timing;
 use std::vec::Vec;
-use timing;
 
 /// Test whether the given opcode is unsafe to even consider for DCE.
 fn trivially_unsafe_for_dce(opcode: Opcode) -> bool {

lib/codegen/src/dominator_tree.rs

@@ -1,15 +1,15 @@
 //! A Dominator Tree represented as mappings of Ebbs to their immediate dominator.
 
-use entity::SecondaryMap;
-use flowgraph::{BasicBlock, ControlFlowGraph};
-use ir::instructions::BranchInfo;
-use ir::{Ebb, ExpandedProgramPoint, Function, Inst, Layout, ProgramOrder, Value};
-use packed_option::PackedOption;
+use crate::entity::SecondaryMap;
+use crate::flowgraph::{BasicBlock, ControlFlowGraph};
+use crate::ir::instructions::BranchInfo;
+use crate::ir::{Ebb, ExpandedProgramPoint, Function, Inst, Layout, ProgramOrder, Value};
+use crate::packed_option::PackedOption;
+use crate::timing;
 use std::cmp;
 use std::cmp::Ordering;
 use std::mem;
 use std::vec::Vec;
-use timing;
 
 /// RPO numbers are not first assigned in a contiguous way but as multiples of STRIDE, to leave
 /// room for modifications of the dominator tree.
@@ -671,12 +671,12 @@ impl DominatorTreePreorder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use cursor::{Cursor, FuncCursor};
-    use flowgraph::ControlFlowGraph;
-    use ir::types::*;
-    use ir::{Function, InstBuilder, TrapCode};
-    use settings;
-    use verifier::{verify_context, VerifierErrors};
+    use crate::cursor::{Cursor, FuncCursor};
+    use crate::flowgraph::ControlFlowGraph;
+    use crate::ir::types::*;
+    use crate::ir::{Function, InstBuilder, TrapCode};
+    use crate::settings;
+    use crate::verifier::{verify_context, VerifierErrors};
 
     #[test]
     fn empty() {

lib/codegen/src/flowgraph.rs

@@ -23,12 +23,12 @@
 //! Here `Ebb1` and `Ebb2` would each have a single predecessor denoted as `(Ebb0, brz)`
 //! and `(Ebb0, jmp Ebb2)` respectively.
 
-use bforest;
-use entity::SecondaryMap;
-use ir::instructions::BranchInfo;
-use ir::{Ebb, Function, Inst};
+use crate::bforest;
+use crate::entity::SecondaryMap;
+use crate::ir::instructions::BranchInfo;
+use crate::ir::{Ebb, Function, Inst};
+use crate::timing;
 use std::mem;
-use timing;
 
 /// A basic block denoted by its enclosing Ebb and last instruction.
 #[derive(PartialEq, Eq)]
@@ -212,8 +212,8 @@ pub type SuccIter<'a> = bforest::SetIter<'a, Ebb>;
 #[cfg(test)]
 mod tests {
     use super::*;
-    use cursor::{Cursor, FuncCursor};
-    use ir::{types, Function, InstBuilder};
+    use crate::cursor::{Cursor, FuncCursor};
+    use crate::ir::{types, Function, InstBuilder};
     use std::vec::Vec;
 
     #[test]

lib/codegen/src/ir/builder.rs

@@ -3,11 +3,11 @@
 //! A `Builder` provides a convenient interface for inserting instructions into a Cranelift
 //! function. Many of its methods are generated from the meta language instruction definitions.
 
-use ir;
-use ir::types;
-use ir::{DataFlowGraph, InstructionData};
-use ir::{Inst, Opcode, Type, Value};
-use isa;
+use crate::ir;
+use crate::ir::types;
+use crate::ir::{DataFlowGraph, InstructionData};
+use crate::ir::{Inst, Opcode, Type, Value};
+use crate::isa;
 
 /// Base trait for instruction builders.
 ///
@@ -215,10 +215,10 @@ impl<'f> InstBuilderBase<'f> for ReplaceBuilder<'f> {
 
 #[cfg(test)]
 mod tests {
-    use cursor::{Cursor, FuncCursor};
-    use ir::condcodes::*;
-    use ir::types::*;
-    use ir::{Function, InstBuilder, ValueDef};
+    use crate::cursor::{Cursor, FuncCursor};
+    use crate::ir::condcodes::*;
+    use crate::ir::types::*;
+    use crate::ir::{Function, InstBuilder, ValueDef};
 
     #[test]
     fn types() {

lib/codegen/src/ir/dfg.rs

@@ -1,20 +1,20 @@
 //! Data flow graph tracking Instructions, Values, and EBBs.
 
-use entity::{self, PrimaryMap, SecondaryMap};
-use ir;
-use ir::builder::ReplaceBuilder;
-use ir::extfunc::ExtFuncData;
-use ir::instructions::{BranchInfo, CallInfo, InstructionData};
-use ir::types;
-use ir::{Ebb, FuncRef, Inst, SigRef, Signature, Type, Value, ValueList, ValueListPool};
-use isa::TargetIsa;
-use packed_option::ReservedValue;
+use crate::entity::{self, PrimaryMap, SecondaryMap};
+use crate::ir;
+use crate::ir::builder::ReplaceBuilder;
+use crate::ir::extfunc::ExtFuncData;
+use crate::ir::instructions::{BranchInfo, CallInfo, InstructionData};
+use crate::ir::types;
+use crate::ir::{Ebb, FuncRef, Inst, SigRef, Signature, Type, Value, ValueList, ValueListPool};
+use crate::isa::TargetIsa;
+use crate::packed_option::ReservedValue;
+use crate::write::write_operands;
 use std::fmt;
 use std::iter;
 use std::mem;
 use std::ops::{Index, IndexMut};
 use std::u16;
-use write::write_operands;
 
 /// A data flow graph defines all instructions and extended basic blocks in a function as well as
 /// the data flow dependencies between them. The DFG also tracks values which can be either
@@ -1063,9 +1063,9 @@ impl DataFlowGraph {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use cursor::{Cursor, FuncCursor};
-    use ir::types;
-    use ir::{Function, InstructionData, Opcode, TrapCode};
+    use crate::cursor::{Cursor, FuncCursor};
+    use crate::ir::types;
+    use crate::ir::{Function, InstructionData, Opcode, TrapCode};
     use std::string::ToString;
 
     #[test]
@@ -1218,8 +1218,8 @@ mod tests {
 
     #[test]
     fn aliases() {
-        use ir::condcodes::IntCC;
-        use ir::InstBuilder;
+        use crate::ir::condcodes::IntCC;
+        use crate::ir::InstBuilder;
 
         let mut func = Function::new();
         let ebb0 = func.dfg.make_ebb();

lib/codegen/src/ir/entities.rs

@@ -19,6 +19,7 @@
 //! The entity references all implement the `Display` trait in a way that matches the textual IR
 //! format.
 
+use crate::entity::entity_impl;
 use std::fmt;
 use std::u32;
 
@@ -318,7 +319,7 @@ mod tests {
 
     #[test]
     fn memory() {
-        use packed_option::PackedOption;
+        use crate::packed_option::PackedOption;
         use std::mem;
         // This is the whole point of `PackedOption`.
         assert_eq!(

lib/codegen/src/ir/extfunc.rs

@@ -5,8 +5,8 @@
 //!
 //! This module declares the data types used to represent external functions and call signatures.
 
-use ir::{ArgumentLoc, ExternalName, SigRef, Type};
-use isa::{CallConv, RegInfo, RegUnit};
+use crate::ir::{ArgumentLoc, ExternalName, SigRef, Type};
+use crate::isa::{CallConv, RegInfo, RegUnit};
 use std::fmt;
 use std::str::FromStr;
 use std::vec::Vec;
@@ -334,7 +334,7 @@ impl fmt::Display for ExtFuncData {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ir::types::{B8, F32, I32};
+    use crate::ir::types::{B8, F32, I32};
     use std::string::ToString;
 
     #[test]

lib/codegen/src/ir/extname.rs

@@ -4,7 +4,7 @@
 //! function. The name of an external declaration doesn't have any meaning to
 //! Cranelift, which compiles functions independently.
 
-use ir::LibCall;
+use crate::ir::LibCall;
 use std::cmp;
 use std::fmt::{self, Write};
 use std::str::FromStr;
@@ -119,7 +119,7 @@ impl FromStr for ExternalName {
 #[cfg(test)]
 mod tests {
     use super::ExternalName;
-    use ir::LibCall;
+    use crate::ir::LibCall;
     use std::string::ToString;
     use std::u32;
 

lib/codegen/src/ir/function.rs

@@ -3,20 +3,20 @@
 //! The `Function` struct defined in this module owns all of its extended basic blocks and
 //! instructions.
 
-use binemit::CodeOffset;
-use entity::{PrimaryMap, SecondaryMap};
-use ir;
-use ir::{DataFlowGraph, ExternalName, Layout, Signature};
-use ir::{
+use crate::binemit::CodeOffset;
+use crate::entity::{PrimaryMap, SecondaryMap};
+use crate::ir;
+use crate::ir::{DataFlowGraph, ExternalName, Layout, Signature};
+use crate::ir::{
     Ebb, ExtFuncData, FuncRef, GlobalValue, GlobalValueData, Heap, HeapData, JumpTable,
     JumpTableData, SigRef, StackSlot, StackSlotData, Table, TableData,
 };
-use ir::{EbbOffsets, InstEncodings, SourceLocs, StackSlots, ValueLocations};
-use ir::{JumpTableOffsets, JumpTables};
-use isa::{CallConv, EncInfo, Encoding, Legalize, TargetIsa};
-use regalloc::RegDiversions;
+use crate::ir::{EbbOffsets, InstEncodings, SourceLocs, StackSlots, ValueLocations};
+use crate::ir::{JumpTableOffsets, JumpTables};
+use crate::isa::{CallConv, EncInfo, Encoding, Legalize, TargetIsa};
+use crate::regalloc::RegDiversions;
+use crate::write::write_function;
 use std::fmt;
-use write::write_function;
 
 /// A function.
 ///

lib/codegen/src/ir/globalvalue.rs

@@ -1,8 +1,8 @@
 //! Global values.
 
-use ir::immediates::{Imm64, Offset32};
-use ir::{ExternalName, GlobalValue, Type};
-use isa::TargetIsa;
+use crate::ir::immediates::{Imm64, Offset32};
+use crate::ir::{ExternalName, GlobalValue, Type};
+use crate::isa::TargetIsa;
 use std::fmt;
 
 /// Information about a global value declaration.

lib/codegen/src/ir/heap.rs

@@ -1,7 +1,7 @@
 //! Heaps.
 
-use ir::immediates::Uimm64;
-use ir::{GlobalValue, Type};
+use crate::ir::immediates::Uimm64;
+use crate::ir::{GlobalValue, Type};
 use std::fmt;
 
 /// Information about a heap declaration.

lib/codegen/src/ir/instructions.rs

@@ -11,14 +11,14 @@ use std::ops::{Deref, DerefMut};
 use std::str::FromStr;
 use std::vec::Vec;
 
-use ir;
-use ir::types;
-use ir::{Ebb, FuncRef, JumpTable, SigRef, Type, Value};
-use isa;
+use crate::ir;
+use crate::ir::types;
+use crate::ir::{Ebb, FuncRef, JumpTable, SigRef, Type, Value};
+use crate::isa;
 
-use bitset::BitSet;
-use entity;
-use ref_slice::{ref_slice, ref_slice_mut};
+use crate::bitset::BitSet;
+use crate::entity;
+use crate::ref_slice::{ref_slice, ref_slice_mut};
 
 /// Some instructions use an external list of argument values because there is not enough space in
 /// the 16-byte `InstructionData` struct. These value lists are stored in a memory pool in
@@ -73,7 +73,7 @@ impl FromStr for Opcode {
 
     /// Parse an Opcode name from a string.
     fn from_str(s: &str) -> Result<Self, &'static str> {
-        use constant_hash::{probe, simple_hash, Table};
+        use crate::constant_hash::{probe, simple_hash, Table};
 
         impl<'a> Table<&'a str> for [Option<Opcode>] {
             fn len(&self) -> usize {
@@ -645,7 +645,7 @@ mod tests {
 
     #[test]
     fn value_set() {
-        use ir::types::*;
+        use crate::ir::types::*;
 
         let vts = ValueTypeSet {
             lanes: BitSet16::from_range(0, 8),

lib/codegen/src/ir/jumptable.rs

@@ -3,7 +3,7 @@
 //! Jump tables are declared in the preamble and assigned an `ir::entities::JumpTable` reference.
 //! The actual table of destinations is stored in a `JumpTableData` struct defined in this module.
 
-use ir::entities::Ebb;
+use crate::ir::entities::Ebb;
 use std::fmt::{self, Display, Formatter};
 use std::slice::{Iter, IterMut};
 use std::vec::Vec;
@@ -83,8 +83,8 @@ impl Display for JumpTableData {
 #[cfg(test)]
 mod tests {
     use super::JumpTableData;
-    use entity::EntityRef;
-    use ir::Ebb;
+    use crate::entity::EntityRef;
+    use crate::ir::Ebb;
     use std::string::ToString;
 
     #[test]

lib/codegen/src/ir/layout.rs

@@ -3,13 +3,14 @@
 //! The order of extended basic blocks in a function and the order of instructions in an EBB is
 //! determined by the `Layout` data structure defined in this module.
 
-use entity::SecondaryMap;
-use ir::progpoint::{ExpandedProgramPoint, ProgramOrder};
-use ir::{Ebb, Inst};
-use packed_option::PackedOption;
+use crate::entity::SecondaryMap;
+use crate::ir::progpoint::{ExpandedProgramPoint, ProgramOrder};
+use crate::ir::{Ebb, Inst};
+use crate::packed_option::PackedOption;
+use crate::timing;
+use log::debug;
 use std::cmp;
 use std::iter::{IntoIterator, Iterator};
-use timing;
 
 /// The `Layout` struct determines the layout of EBBs and instructions in a function. It does not
 /// contain definitions of instructions or EBBs, but depends on `Inst` and `Ebb` entity references
@@ -741,9 +742,9 @@ impl<'f> DoubleEndedIterator for Insts<'f> {
 #[cfg(test)]
 mod tests {
     use super::Layout;
-    use cursor::{Cursor, CursorPosition};
-    use entity::EntityRef;
-    use ir::{Ebb, Inst, ProgramOrder, SourceLoc};
+    use crate::cursor::{Cursor, CursorPosition};
+    use crate::entity::EntityRef;
+    use crate::ir::{Ebb, Inst, ProgramOrder, SourceLoc};
     use std::cmp::Ordering;
     use std::vec::Vec;
 

lib/codegen/src/ir/libcall.rs

@@ -1,10 +1,10 @@
 //! Naming well-known routines in the runtime library.
 
-use ir::{
+use crate::ir::{
     types, AbiParam, ArgumentPurpose, ExtFuncData, ExternalName, FuncRef, Function, Inst, Opcode,
     Signature, Type,
 };
-use isa::{CallConv, RegUnit, TargetIsa};
+use crate::isa::{CallConv, RegUnit, TargetIsa};
 use std::fmt;
 use std::str::FromStr;
 

lib/codegen/src/ir/mod.rs

@@ -23,32 +23,36 @@ mod trapcode;
 pub mod types;
 mod valueloc;
 
-pub use ir::builder::{InsertBuilder, InstBuilder, InstBuilderBase, InstInserterBase};
-pub use ir::dfg::{DataFlowGraph, ValueDef};
-pub use ir::entities::{
+pub use crate::ir::builder::{InsertBuilder, InstBuilder, InstBuilderBase, InstInserterBase};
+pub use crate::ir::dfg::{DataFlowGraph, ValueDef};
+pub use crate::ir::entities::{
     Ebb, FuncRef, GlobalValue, Heap, Inst, JumpTable, SigRef, StackSlot, Table, Value,
 };
-pub use ir::extfunc::{AbiParam, ArgumentExtension, ArgumentPurpose, ExtFuncData, Signature};
-pub use ir::extname::ExternalName;
-pub use ir::function::Function;
-pub use ir::globalvalue::GlobalValueData;
-pub use ir::heap::{HeapData, HeapStyle};
-pub use ir::instructions::{InstructionData, Opcode, ValueList, ValueListPool, VariableArgs};
-pub use ir::jumptable::JumpTableData;
-pub use ir::layout::Layout;
-pub use ir::libcall::{get_libcall_funcref, get_probestack_funcref, LibCall};
-pub use ir::memflags::MemFlags;
-pub use ir::progpoint::{ExpandedProgramPoint, ProgramOrder, ProgramPoint};
-pub use ir::sourceloc::SourceLoc;
-pub use ir::stackslot::{StackSlotData, StackSlotKind, StackSlots};
-pub use ir::table::TableData;
-pub use ir::trapcode::TrapCode;
-pub use ir::types::Type;
-pub use ir::valueloc::{ArgumentLoc, ValueLoc};
+pub use crate::ir::extfunc::{
+    AbiParam, ArgumentExtension, ArgumentPurpose, ExtFuncData, Signature,
+};
+pub use crate::ir::extname::ExternalName;
+pub use crate::ir::function::Function;
+pub use crate::ir::globalvalue::GlobalValueData;
+pub use crate::ir::heap::{HeapData, HeapStyle};
+pub use crate::ir::instructions::{
+    InstructionData, Opcode, ValueList, ValueListPool, VariableArgs,
+};
+pub use crate::ir::jumptable::JumpTableData;
+pub use crate::ir::layout::Layout;
+pub use crate::ir::libcall::{get_libcall_funcref, get_probestack_funcref, LibCall};
+pub use crate::ir::memflags::MemFlags;
+pub use crate::ir::progpoint::{ExpandedProgramPoint, ProgramOrder, ProgramPoint};
+pub use crate::ir::sourceloc::SourceLoc;
+pub use crate::ir::stackslot::{StackSlotData, StackSlotKind, StackSlots};
+pub use crate::ir::table::TableData;
+pub use crate::ir::trapcode::TrapCode;
+pub use crate::ir::types::Type;
+pub use crate::ir::valueloc::{ArgumentLoc, ValueLoc};
 
-use binemit;
-use entity::{PrimaryMap, SecondaryMap};
-use isa;
+use crate::binemit;
+use crate::entity::{PrimaryMap, SecondaryMap};
+use crate::isa;
 
 /// Map of value locations.
 pub type ValueLocations = SecondaryMap<Value, ValueLoc>;

lib/codegen/src/ir/progpoint.rs

@@ -1,7 +1,7 @@
 //! Program points.
 
-use entity::EntityRef;
-use ir::{Ebb, Inst, ValueDef};
+use crate::entity::EntityRef;
+use crate::ir::{Ebb, Inst, ValueDef};
 use std::cmp;
 use std::fmt;
 use std::u32;
@@ -146,8 +146,8 @@ pub trait ProgramOrder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use entity::EntityRef;
-    use ir::{Ebb, Inst};
+    use crate::entity::EntityRef;
+    use crate::ir::{Ebb, Inst};
     use std::string::ToString;
 
     #[test]

lib/codegen/src/ir/sourceloc.rs

@@ -50,7 +50,7 @@ impl fmt::Display for SourceLoc {
 
 #[cfg(test)]
 mod tests {
-    use ir::SourceLoc;
+    use crate::ir::SourceLoc;
     use std::string::ToString;
 
     #[test]

lib/codegen/src/ir/stackslot.rs

@@ -3,9 +3,9 @@
 //! The `StackSlotData` struct keeps track of a single stack slot in a function.
 //!
 
-use entity::{Iter, IterMut, Keys, PrimaryMap};
-use ir::{StackSlot, Type};
-use packed_option::PackedOption;
+use crate::entity::{Iter, IterMut, Keys, PrimaryMap};
+use crate::ir::{StackSlot, Type};
+use crate::packed_option::PackedOption;
 use std::cmp;
 use std::fmt;
 use std::ops::{Index, IndexMut};
@@ -340,8 +340,8 @@ impl StackSlots {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ir::types;
-    use ir::Function;
+    use crate::ir::types;
+    use crate::ir::Function;
     use std::string::ToString;
 
     #[test]

lib/codegen/src/ir/table.rs

@@ -1,7 +1,7 @@
 //! Tables.
 
-use ir::immediates::Uimm64;
-use ir::{GlobalValue, Type};
+use crate::ir::immediates::Uimm64;
+use crate::ir::{GlobalValue, Type};
 use std::fmt;
 
 /// Information about a table declaration.

lib/codegen/src/ir/valueloc.rs

@@ -3,8 +3,8 @@
 //! The register allocator assigns every SSA value to either a register or a stack slot. This
 //! assignment is represented by a `ValueLoc` object.
 
-use ir::StackSlot;
-use isa::{RegInfo, RegUnit};
+use crate::ir::StackSlot;
+use crate::isa::{RegInfo, RegUnit};
 use std::fmt;
 
 /// Value location.

lib/codegen/src/isa/arm32/abi.rs

@@ -1,10 +1,10 @@
 //! ARM ABI implementation.
 
 use super::registers::{D, GPR, Q, S};
-use ir;
-use isa::RegClass;
-use regalloc::RegisterSet;
-use settings as shared_settings;
+use crate::ir;
+use crate::isa::RegClass;
+use crate::regalloc::RegisterSet;
+use crate::settings as shared_settings;
 
 /// Legalize `sig`.
 pub fn legalize_signature(

lib/codegen/src/isa/arm32/binemit.rs

@@ -1,7 +1,7 @@
 //! Emitting binary ARM32 machine code.
 
-use binemit::{bad_encoding, CodeSink};
-use ir::{Function, Inst};
-use regalloc::RegDiversions;
+use crate::binemit::{bad_encoding, CodeSink};
+use crate::ir::{Function, Inst};
+use crate::regalloc::RegDiversions;
 
 include!(concat!(env!("OUT_DIR"), "/binemit-arm32.rs"));

lib/codegen/src/isa/arm32/enc_tables.rs

@@ -1,10 +1,9 @@
 //! Encoding tables for ARM32 ISA.
 
-use ir;
-use isa;
-use isa::constraints::*;
-use isa::enc_tables::*;
-use isa::encoding::RecipeSizing;
+use crate::isa;
+use crate::isa::constraints::*;
+use crate::isa::enc_tables::*;
+use crate::isa::encoding::RecipeSizing;
 
 include!(concat!(env!("OUT_DIR"), "/encoding-arm32.rs"));
 include!(concat!(env!("OUT_DIR"), "/legalize-arm32.rs"));

lib/codegen/src/isa/arm32/mod.rs

@@ -8,13 +8,13 @@ pub mod settings;
 
 use super::super::settings as shared_settings;
 #[cfg(feature = "testing_hooks")]
-use binemit::CodeSink;
-use binemit::{emit_function, MemoryCodeSink};
-use ir;
-use isa::enc_tables::{self as shared_enc_tables, lookup_enclist, Encodings};
-use isa::Builder as IsaBuilder;
-use isa::{EncInfo, RegClass, RegInfo, TargetIsa};
-use regalloc;
+use crate::binemit::CodeSink;
+use crate::binemit::{emit_function, MemoryCodeSink};
+use crate::ir;
+use crate::isa::enc_tables::{self as shared_enc_tables, lookup_enclist, Encodings};
+use crate::isa::Builder as IsaBuilder;
+use crate::isa::{EncInfo, RegClass, RegInfo, TargetIsa};
+use crate::regalloc;
 use std::boxed::Box;
 use std::fmt;
 use target_lexicon::{Architecture, Triple};

lib/codegen/src/isa/arm32/registers.rs

@@ -1,13 +1,13 @@
 //! ARM32 register descriptions.
 
-use isa::registers::{RegBank, RegClass, RegClassData, RegInfo, RegUnit};
+use crate::isa::registers::{RegBank, RegClass, RegClassData, RegInfo, RegUnit};
 
 include!(concat!(env!("OUT_DIR"), "/registers-arm32.rs"));
 
 #[cfg(test)]
 mod tests {
     use super::{D, GPR, INFO, S};
-    use isa::RegUnit;
+    use crate::isa::RegUnit;
     use std::string::{String, ToString};
 
     #[test]
@@ -34,7 +34,7 @@ mod tests {
     #[test]
     fn overlaps() {
         // arm32 has the most interesting register geometries, so test `regs_overlap()` here.
-        use isa::regs_overlap;
+        use crate::isa::regs_overlap;
 
         let r0 = GPR.unit(0);
         let r1 = GPR.unit(1);

lib/codegen/src/isa/arm32/settings.rs

@@ -1,6 +1,6 @@
 //! ARM32 Settings.
 
-use settings::{self, detail, Builder};
+use crate::settings::{self, detail, Builder};
 use std::fmt;
 
 // Include code generated by `lib/codegen/meta-python/gen_settings.py`. This file contains a public

lib/codegen/src/isa/arm64/abi.rs

@@ -1,10 +1,10 @@
 //! ARM 64 ABI implementation.
 
 use super::registers::{FPR, GPR};
-use ir;
-use isa::RegClass;
-use regalloc::RegisterSet;
-use settings as shared_settings;
+use crate::ir;
+use crate::isa::RegClass;
+use crate::regalloc::RegisterSet;
+use crate::settings as shared_settings;
 
 /// Legalize `sig`.
 pub fn legalize_signature(

lib/codegen/src/isa/arm64/binemit.rs

@@ -1,7 +1,7 @@
 //! Emitting binary ARM64 machine code.
 
-use binemit::{bad_encoding, CodeSink};
-use ir::{Function, Inst};
-use regalloc::RegDiversions;
+use crate::binemit::{bad_encoding, CodeSink};
+use crate::ir::{Function, Inst};
+use crate::regalloc::RegDiversions;
 
 include!(concat!(env!("OUT_DIR"), "/binemit-arm64.rs"));

lib/codegen/src/isa/arm64/enc_tables.rs

@@ -1,10 +1,9 @@
 //! Encoding tables for ARM64 ISA.
 
-use ir;
-use isa;
-use isa::constraints::*;
-use isa::enc_tables::*;
-use isa::encoding::RecipeSizing;
+use crate::isa;
+use crate::isa::constraints::*;
+use crate::isa::enc_tables::*;
+use crate::isa::encoding::RecipeSizing;
 
 include!(concat!(env!("OUT_DIR"), "/encoding-arm64.rs"));
 include!(concat!(env!("OUT_DIR"), "/legalize-arm64.rs"));

lib/codegen/src/isa/arm64/mod.rs

@@ -8,13 +8,13 @@ pub mod settings;
 
 use super::super::settings as shared_settings;
 #[cfg(feature = "testing_hooks")]
-use binemit::CodeSink;
-use binemit::{emit_function, MemoryCodeSink};
-use ir;
-use isa::enc_tables::{lookup_enclist, Encodings};
-use isa::Builder as IsaBuilder;
-use isa::{EncInfo, RegClass, RegInfo, TargetIsa};
-use regalloc;
+use crate::binemit::CodeSink;
+use crate::binemit::{emit_function, MemoryCodeSink};
+use crate::ir;
+use crate::isa::enc_tables::{lookup_enclist, Encodings};
+use crate::isa::Builder as IsaBuilder;
+use crate::isa::{EncInfo, RegClass, RegInfo, TargetIsa};
+use crate::regalloc;
 use std::boxed::Box;
 use std::fmt;
 use target_lexicon::Triple;

lib/codegen/src/isa/arm64/registers.rs

@@ -1,13 +1,13 @@
 //! ARM64 register descriptions.
 
-use isa::registers::{RegBank, RegClass, RegClassData, RegInfo, RegUnit};
+use crate::isa::registers::{RegBank, RegClass, RegClassData, RegInfo, RegUnit};
 
 include!(concat!(env!("OUT_DIR"), "/registers-arm64.rs"));
 
 #[cfg(test)]
 mod tests {
     use super::INFO;
-    use isa::RegUnit;
+    use crate::isa::RegUnit;
     use std::string::{String, ToString};
 
     #[test]

lib/codegen/src/isa/arm64/settings.rs

@@ -1,6 +1,6 @@
 //! ARM64 Settings.
 
-use settings::{self, detail, Builder};
+use crate::settings::{self, detail, Builder};
 use std::fmt;
 
 // Include code generated by `lib/codegen/meta-python/gen_settings.py`. This file contains a public

lib/codegen/src/isa/constraints.rs

@@ -7,10 +7,10 @@
 //! It is the register allocator's job to make sure that the register constraints on value operands
 //! are satisfied.
 
-use binemit::CodeOffset;
-use ir::{Function, Inst, ValueLoc};
-use isa::{RegClass, RegUnit};
-use regalloc::RegDiversions;
+use crate::binemit::CodeOffset;
+use crate::ir::{Function, Inst, ValueLoc};
+use crate::isa::{RegClass, RegUnit};
+use crate::regalloc::RegDiversions;
 
 /// Register constraint for a single value operand or instruction result.
 #[derive(PartialEq, Debug)]

lib/codegen/src/isa/enc_tables.rs

@@ -3,10 +3,10 @@
 //! This module contains types and functions for working with the encoding tables generated by
 //! `lib/codegen/meta-python/gen_encoding.py`.
 
-use constant_hash::{probe, Table};
-use ir::{Function, InstructionData, Opcode, Type};
-use isa::{Encoding, Legalize};
-use settings::PredicateView;
+use crate::constant_hash::{probe, Table};
+use crate::ir::{Function, InstructionData, Opcode, Type};
+use crate::isa::{Encoding, Legalize};
+use crate::settings::PredicateView;
 use std::ops::Range;
 
 /// A recipe predicate.

lib/codegen/src/isa/encoding.rs

@@ -1,9 +1,9 @@
 //! The `Encoding` struct.
 
-use binemit::CodeOffset;
-use ir::{Function, Inst};
-use isa::constraints::{BranchRange, RecipeConstraints};
-use regalloc::RegDiversions;
+use crate::binemit::CodeOffset;
+use crate::ir::{Function, Inst};
+use crate::isa::constraints::{BranchRange, RecipeConstraints};
+use crate::regalloc::RegDiversions;
 use std::fmt;
 
 /// Bits needed to encode an instruction as binary machine code.

lib/codegen/src/isa/mod.rs

@@ -46,24 +46,27 @@
 //! The configured target ISA trait object is a `Box<TargetIsa>` which can be used for multiple
 //! concurrent function compilations.
 
-pub use isa::call_conv::CallConv;
-pub use isa::constraints::{BranchRange, ConstraintKind, OperandConstraint, RecipeConstraints};
-pub use isa::encoding::{base_size, EncInfo, Encoding};
-pub use isa::registers::{regs_overlap, RegClass, RegClassIndex, RegInfo, RegUnit};
-pub use isa::stack::{StackBase, StackBaseMask, StackRef};
+pub use crate::isa::call_conv::CallConv;
+pub use crate::isa::constraints::{
+    BranchRange, ConstraintKind, OperandConstraint, RecipeConstraints,
+};
+pub use crate::isa::encoding::{base_size, EncInfo, Encoding};
+pub use crate::isa::registers::{regs_overlap, RegClass, RegClassIndex, RegInfo, RegUnit};
+pub use crate::isa::stack::{StackBase, StackBaseMask, StackRef};
 
-use binemit;
-use flowgraph;
-use ir;
-use isa::enc_tables::Encodings;
-use regalloc;
-use result::CodegenResult;
-use settings;
-use settings::SetResult;
+use crate::binemit;
+use crate::flowgraph;
+use crate::ir;
+use crate::isa::enc_tables::Encodings;
+use crate::regalloc;
+use crate::result::CodegenResult;
+use crate::settings;
+use crate::settings::SetResult;
+use crate::timing;
+use failure_derive::Fail;
 use std::boxed::Box;
 use std::fmt;
 use target_lexicon::{Architecture, PointerWidth, Triple};
-use timing;
 
 #[cfg(build_riscv)]
 mod riscv;
@@ -334,8 +337,8 @@ pub trait TargetIsa: fmt::Display + Sync {
     fn prologue_epilogue(&self, func: &mut ir::Function) -> CodegenResult<()> {
         let _tt = timing::prologue_epilogue();
         // This default implementation is unlikely to be good enough.
-        use ir::stackslot::{StackOffset, StackSize};
-        use stack_layout::layout_stack;
+        use crate::ir::stackslot::{StackOffset, StackSize};
+        use crate::stack_layout::layout_stack;
 
         let word_size = StackSize::from(self.pointer_bytes());
 

lib/codegen/src/isa/registers.rs

@@ -1,6 +1,6 @@
 //! Data structures describing the registers in an ISA.
 
-use entity::EntityRef;
+use crate::entity::EntityRef;
 use std::fmt;
 
 /// Register units are the smallest units of register allocation.

lib/codegen/src/isa/riscv/abi.rs

@@ -7,10 +7,10 @@
 
 use super::registers::{FPR, GPR};
 use super::settings;
-use abi::{legalize_args, ArgAction, ArgAssigner, ValueConversion};
-use ir::{self, AbiParam, ArgumentExtension, ArgumentLoc, ArgumentPurpose, Type};
-use isa::RegClass;
-use regalloc::RegisterSet;
+use crate::abi::{legalize_args, ArgAction, ArgAssigner, ValueConversion};
+use crate::ir::{self, AbiParam, ArgumentExtension, ArgumentLoc, ArgumentPurpose, Type};
+use crate::isa::RegClass;
+use crate::regalloc::RegisterSet;
 use std::i32;
 use target_lexicon::Triple;
 

lib/codegen/src/isa/riscv/binemit.rs

@@ -1,10 +1,10 @@
 //! Emitting binary RISC-V machine code.
 
-use binemit::{bad_encoding, CodeSink, Reloc};
-use ir::{Function, Inst, InstructionData};
-use isa::{RegUnit, StackBaseMask, StackRef};
-use predicates::is_signed_int;
-use regalloc::RegDiversions;
+use crate::binemit::{bad_encoding, CodeSink, Reloc};
+use crate::ir::{Function, Inst, InstructionData};
+use crate::isa::{RegUnit, StackBaseMask, StackRef};
+use crate::predicates::is_signed_int;
+use crate::regalloc::RegDiversions;
 use std::u32;
 
 include!(concat!(env!("OUT_DIR"), "/binemit-riscv.rs"));

lib/codegen/src/isa/riscv/enc_tables.rs

@@ -1,11 +1,11 @@
 //! Encoding tables for RISC-V.
 
 use super::registers::*;
-use ir;
-use isa;
-use isa::constraints::*;
-use isa::enc_tables::*;
-use isa::encoding::{base_size, RecipeSizing};
+use crate::ir;
+use crate::isa;
+use crate::isa::constraints::*;
+use crate::isa::enc_tables::*;
+use crate::isa::encoding::{base_size, RecipeSizing};
 
 // Include the generated encoding tables:
 // - `LEVEL1_RV32`

lib/codegen/src/isa/riscv/mod.rs

@@ -8,13 +8,13 @@ pub mod settings;
 
 use super::super::settings as shared_settings;
 #[cfg(feature = "testing_hooks")]
-use binemit::CodeSink;
-use binemit::{emit_function, MemoryCodeSink};
-use ir;
-use isa::enc_tables::{self as shared_enc_tables, lookup_enclist, Encodings};
-use isa::Builder as IsaBuilder;
-use isa::{EncInfo, RegClass, RegInfo, TargetIsa};
-use regalloc;
+use crate::binemit::CodeSink;
+use crate::binemit::{emit_function, MemoryCodeSink};
+use crate::ir;
+use crate::isa::enc_tables::{self as shared_enc_tables, lookup_enclist, Encodings};
+use crate::isa::Builder as IsaBuilder;
+use crate::isa::{EncInfo, RegClass, RegInfo, TargetIsa};
+use crate::regalloc;
 use std::boxed::Box;
 use std::fmt;
 use target_lexicon::{PointerWidth, Triple};
@@ -125,13 +125,13 @@ impl TargetIsa for Isa {
 
 #[cfg(test)]
 mod tests {
-    use ir::{immediates, types};
-    use ir::{Function, InstructionData, Opcode};
-    use isa;
-    use settings::{self, Configurable};
+    use crate::ir::{immediates, types};
+    use crate::ir::{Function, InstructionData, Opcode};
+    use crate::isa;
+    use crate::settings::{self, Configurable};
     use std::str::FromStr;
     use std::string::{String, ToString};
-    use target_lexicon;
+    use target_lexicon::triple;
 
     fn encstr(isa: &isa::TargetIsa, enc: Result<isa::Encoding, isa::Legalize>) -> String {
         match enc {

lib/codegen/src/isa/riscv/registers.rs

@@ -1,13 +1,13 @@
 //! RISC-V register descriptions.
 
-use isa::registers::{RegBank, RegClass, RegClassData, RegInfo, RegUnit};
+use crate::isa::registers::{RegBank, RegClass, RegClassData, RegInfo, RegUnit};
 
 include!(concat!(env!("OUT_DIR"), "/registers-riscv.rs"));
 
 #[cfg(test)]
 mod tests {
     use super::{FPR, GPR, INFO};
-    use isa::RegUnit;
+    use crate::isa::RegUnit;
     use std::string::{String, ToString};
 
     #[test]

lib/codegen/src/isa/riscv/settings.rs

@@ -1,6 +1,6 @@
 //! RISC-V Settings.
 
-use settings::{self, detail, Builder};
+use crate::settings::{self, detail, Builder};
 use std::fmt;
 
 // Include code generated by `lib/codegen/meta-python/gen_settings.py`. This file contains a public
@@ -11,7 +11,7 @@ include!(concat!(env!("OUT_DIR"), "/settings-riscv.rs"));
 #[cfg(test)]
 mod tests {
     use super::{builder, Flags};
-    use settings::{self, Configurable};
+    use crate::settings::{self, Configurable};
     use std::string::ToString;
 
     #[test]

lib/codegen/src/isa/stack.rs

@@ -4,8 +4,8 @@
 //! defined in this module expresses the low-level details of accessing a stack slot from an
 //! encoded instruction.
 
-use ir::stackslot::{StackOffset, StackSlotKind, StackSlots};
-use ir::StackSlot;
+use crate::ir::stackslot::{StackOffset, StackSlotKind, StackSlots};
+use crate::ir::StackSlot;
 
 /// A method for referencing a stack slot in the current stack frame.
 ///

lib/codegen/src/isa/x86/abi.rs

@@ -1,19 +1,19 @@
 //! x86 ABI implementation.
 
 use super::registers::{FPR, GPR, RU};
-use abi::{legalize_args, ArgAction, ArgAssigner, ValueConversion};
-use cursor::{Cursor, CursorPosition, EncCursor};
-use ir;
-use ir::immediates::Imm64;
-use ir::stackslot::{StackOffset, StackSize};
-use ir::{
+use crate::abi::{legalize_args, ArgAction, ArgAssigner, ValueConversion};
+use crate::cursor::{Cursor, CursorPosition, EncCursor};
+use crate::ir;
+use crate::ir::immediates::Imm64;
+use crate::ir::stackslot::{StackOffset, StackSize};
+use crate::ir::{
     get_probestack_funcref, AbiParam, ArgumentExtension, ArgumentLoc, ArgumentPurpose, InstBuilder,
     ValueLoc,
 };
-use isa::{CallConv, RegClass, RegUnit, TargetIsa};
-use regalloc::RegisterSet;
-use result::CodegenResult;
-use stack_layout::layout_stack;
+use crate::isa::{CallConv, RegClass, RegUnit, TargetIsa};
+use crate::regalloc::RegisterSet;
+use crate::result::CodegenResult;
+use crate::stack_layout::layout_stack;
 use std::i32;
 use target_lexicon::{PointerWidth, Triple};
 
@@ -511,7 +511,7 @@ fn insert_common_prologue(
 /// Insert a check that generates a trap if the stack pointer goes
 /// below a value in `stack_limit_arg`.
 fn insert_stack_check(pos: &mut EncCursor, stack_size: i64, stack_limit_arg: ir::Value) {
-    use ir::condcodes::IntCC;
+    use crate::ir::condcodes::IntCC;
 
     // Copy `stack_limit_arg` into a %rax and use it for calculating
     // a SP threshold.

lib/codegen/src/isa/x86/binemit.rs

@@ -2,11 +2,11 @@
 
 use super::enc_tables::{needs_offset, needs_sib_byte};
 use super::registers::RU;
-use binemit::{bad_encoding, CodeSink, Reloc};
-use ir::condcodes::{CondCode, FloatCC, IntCC};
-use ir::{Ebb, Function, Inst, InstructionData, JumpTable, Opcode, TrapCode};
-use isa::{RegUnit, StackBase, StackBaseMask, StackRef};
-use regalloc::RegDiversions;
+use crate::binemit::{bad_encoding, CodeSink, Reloc};
+use crate::ir::condcodes::{CondCode, FloatCC, IntCC};
+use crate::ir::{Ebb, Function, Inst, InstructionData, JumpTable, Opcode, TrapCode};
+use crate::isa::{RegUnit, StackBase, StackBaseMask, StackRef};
+use crate::regalloc::RegDiversions;
 
 include!(concat!(env!("OUT_DIR"), "/binemit-x86.rs"));
 
@@ -270,7 +270,7 @@ fn sib<CS: CodeSink + ?Sized>(scale: u8, index: RegUnit, base: RegUnit, sink: &m
 /// 0x0f 0x90: SetCC.
 ///
 fn icc2opc(cond: IntCC) -> u16 {
-    use ir::condcodes::IntCC::*;
+    use crate::ir::condcodes::IntCC::*;
     match cond {
         // 0x0 = Overflow.
         // 0x1 = !Overflow.
@@ -303,7 +303,7 @@ fn icc2opc(cond: IntCC) -> u16 {
 ///
 /// Not all floating point condition codes are supported.
 fn fcc2opc(cond: FloatCC) -> u16 {
-    use ir::condcodes::FloatCC::*;
+    use crate::ir::condcodes::FloatCC::*;
     match cond {
         Ordered                    => 0xb, // EQ|LT|GT => *np (P=0)
         Unordered                  => 0xa, // UN       => *p  (P=1)

lib/codegen/src/isa/x86/enc_tables.rs

@@ -1,18 +1,18 @@
 //! Encoding tables for x86 ISAs.
 
 use super::registers::*;
-use bitset::BitSet;
-use cursor::{Cursor, FuncCursor};
-use flowgraph::ControlFlowGraph;
-use ir::condcodes::IntCC;
-use ir::{self, Function, Inst, InstBuilder};
-use isa;
-use isa::constraints::*;
-use isa::enc_tables::*;
-use isa::encoding::base_size;
-use isa::encoding::RecipeSizing;
-use isa::RegUnit;
-use regalloc::RegDiversions;
+use crate::bitset::BitSet;
+use crate::cursor::{Cursor, FuncCursor};
+use crate::flowgraph::ControlFlowGraph;
+use crate::ir::condcodes::IntCC;
+use crate::ir::{self, Function, Inst, InstBuilder};
+use crate::isa;
+use crate::isa::constraints::*;
+use crate::isa::enc_tables::*;
+use crate::isa::encoding::base_size;
+use crate::isa::encoding::RecipeSizing;
+use crate::isa::RegUnit;
+use crate::regalloc::RegDiversions;
 
 include!(concat!(env!("OUT_DIR"), "/encoding-x86.rs"));
 include!(concat!(env!("OUT_DIR"), "/legalize-x86.rs"));
@@ -228,7 +228,7 @@ fn expand_minmax(
     cfg: &mut ControlFlowGraph,
     _isa: &isa::TargetIsa,
 ) {
-    use ir::condcodes::FloatCC;
+    use crate::ir::condcodes::FloatCC;
 
     let (x, y, x86_opc, bitwise_opc) = match func.dfg[inst] {
         ir::InstructionData::Binary {
@@ -322,7 +322,7 @@ fn expand_fcvt_from_uint(
     cfg: &mut ControlFlowGraph,
     _isa: &isa::TargetIsa,
 ) {
-    use ir::condcodes::IntCC;
+    use crate::ir::condcodes::IntCC;
 
     let x;
     match func.dfg[inst] {
@@ -395,8 +395,8 @@ fn expand_fcvt_to_sint(
     cfg: &mut ControlFlowGraph,
     _isa: &isa::TargetIsa,
 ) {
-    use ir::condcodes::{FloatCC, IntCC};
-    use ir::immediates::{Ieee32, Ieee64};
+    use crate::ir::condcodes::{FloatCC, IntCC};
+    use crate::ir::immediates::{Ieee32, Ieee64};
 
     let x = match func.dfg[inst] {
         ir::InstructionData::Unary {
@@ -491,8 +491,8 @@ fn expand_fcvt_to_sint_sat(
     cfg: &mut ControlFlowGraph,
     _isa: &isa::TargetIsa,
 ) {
-    use ir::condcodes::{FloatCC, IntCC};
-    use ir::immediates::{Ieee32, Ieee64};
+    use crate::ir::condcodes::{FloatCC, IntCC};
+    use crate::ir::immediates::{Ieee32, Ieee64};
 
     let x = match func.dfg[inst] {
         ir::InstructionData::Unary {
@@ -611,8 +611,8 @@ fn expand_fcvt_to_uint(
     cfg: &mut ControlFlowGraph,
     _isa: &isa::TargetIsa,
 ) {
-    use ir::condcodes::{FloatCC, IntCC};
-    use ir::immediates::{Ieee32, Ieee64};
+    use crate::ir::condcodes::{FloatCC, IntCC};
+    use crate::ir::immediates::{Ieee32, Ieee64};
 
     let x = match func.dfg[inst] {
         ir::InstructionData::Unary {
@@ -693,8 +693,8 @@ fn expand_fcvt_to_uint_sat(
     cfg: &mut ControlFlowGraph,
     _isa: &isa::TargetIsa,
 ) {
-    use ir::condcodes::{FloatCC, IntCC};
-    use ir::immediates::{Ieee32, Ieee64};
+    use crate::ir::condcodes::{FloatCC, IntCC};
+    use crate::ir::immediates::{Ieee32, Ieee64};
 
     let x = match func.dfg[inst] {
         ir::InstructionData::Unary {

lib/codegen/src/isa/x86/mod.rs

@@ -8,18 +8,18 @@ pub mod settings;
 
 use super::super::settings as shared_settings;
 #[cfg(feature = "testing_hooks")]
-use binemit::CodeSink;
-use binemit::{emit_function, MemoryCodeSink};
-use ir;
-use isa::enc_tables::{self as shared_enc_tables, lookup_enclist, Encodings};
-use isa::Builder as IsaBuilder;
-use isa::{EncInfo, RegClass, RegInfo, TargetIsa};
-use regalloc;
-use result::CodegenResult;
+use crate::binemit::CodeSink;
+use crate::binemit::{emit_function, MemoryCodeSink};
+use crate::ir;
+use crate::isa::enc_tables::{self as shared_enc_tables, lookup_enclist, Encodings};
+use crate::isa::Builder as IsaBuilder;
+use crate::isa::{EncInfo, RegClass, RegInfo, TargetIsa};
+use crate::regalloc;
+use crate::result::CodegenResult;
+use crate::timing;
 use std::boxed::Box;
 use std::fmt;
 use target_lexicon::{PointerWidth, Triple};
-use timing;
 
 #[allow(dead_code)]
 struct Isa {

lib/codegen/src/isa/x86/registers.rs

@@ -1,13 +1,13 @@
 //! x86 register descriptions.
 
-use isa::registers::{RegBank, RegClass, RegClassData, RegInfo, RegUnit};
+use crate::isa::registers::{RegBank, RegClass, RegClassData, RegInfo, RegUnit};
 
 include!(concat!(env!("OUT_DIR"), "/registers-x86.rs"));
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use isa::RegUnit;
+    use crate::isa::RegUnit;
     use std::string::{String, ToString};
 
     #[test]

lib/codegen/src/isa/x86/settings.rs

@@ -1,6 +1,6 @@
 //! x86 Settings.
 
-use settings::{self, detail, Builder};
+use crate::settings::{self, detail, Builder};
 use std::fmt;
 
 // Include code generated by `lib/codegen/meta-python/gen_settings.py`. This file contains a public
@@ -11,7 +11,7 @@ include!(concat!(env!("OUT_DIR"), "/settings-x86.rs"));
 #[cfg(test)]
 mod tests {
     use super::{builder, Flags};
-    use settings::{self, Configurable};
+    use crate::settings::{self, Configurable};
 
     #[test]
     fn presets() {

lib/codegen/src/legalizer/boundary.rs

@@ -17,16 +17,17 @@
 //! Between the two phases, preamble signatures and call/return arguments don't match. This
 //! intermediate state doesn't type check.
 
-use abi::{legalize_abi_value, ValueConversion};
-use cursor::{Cursor, FuncCursor};
-use flowgraph::ControlFlowGraph;
-use ir::instructions::CallInfo;
-use ir::{
+use crate::abi::{legalize_abi_value, ValueConversion};
+use crate::cursor::{Cursor, FuncCursor};
+use crate::flowgraph::ControlFlowGraph;
+use crate::ir::instructions::CallInfo;
+use crate::ir::{
     AbiParam, ArgumentLoc, ArgumentPurpose, DataFlowGraph, Ebb, Function, Inst, InstBuilder,
     SigRef, Signature, Type, Value, ValueLoc,
 };
-use isa::TargetIsa;
-use legalizer::split::{isplit, vsplit};
+use crate::isa::TargetIsa;
+use crate::legalizer::split::{isplit, vsplit};
+use log::debug;
 use std::vec::Vec;
 
 /// Legalize all the function signatures in `func`.

lib/codegen/src/legalizer/call.rs

@@ -3,10 +3,10 @@
 //! This module exports the `expand_call` function which transforms a `call`
 //! instruction into `func_addr` and `call_indirect` instructions.
 
-use cursor::{Cursor, FuncCursor};
-use flowgraph::ControlFlowGraph;
-use ir::{self, InstBuilder};
-use isa::TargetIsa;
+use crate::cursor::{Cursor, FuncCursor};
+use crate::flowgraph::ControlFlowGraph;
+use crate::ir::{self, InstBuilder};
+use crate::isa::TargetIsa;
 
 /// Expand a `call` instruction. This lowers it to a `call_indirect`, which
 /// is only done if the ABI doesn't support direct calls.

lib/codegen/src/legalizer/globalvalue.rs

@@ -3,10 +3,10 @@
 //! This module exports the `expand_global_value` function which transforms a `global_value`
 //! instruction into code that depends on the kind of global value referenced.
 
-use cursor::{Cursor, FuncCursor};
-use flowgraph::ControlFlowGraph;
-use ir::{self, InstBuilder};
-use isa::TargetIsa;
+use crate::cursor::{Cursor, FuncCursor};
+use crate::flowgraph::ControlFlowGraph;
+use crate::ir::{self, InstBuilder};
+use crate::isa::TargetIsa;
 
 /// Expand a `global_value` instruction according to the definition of the global value.
 pub fn expand_global_value(