diff --git a/src/librustc_trans/_match.rs b/src/librustc_trans/_match.rs
index f545ba2cbe0..b27929c80c2 100644
--- a/src/librustc_trans/_match.rs
+++ b/src/librustc_trans/_match.rs
@@ -242,7 +242,7 @@ impl<'a> ConstantExpr<'a> {
     fn eq(self, other: ConstantExpr<'a>, tcx: &TyCtxt) -> bool {
         match compare_lit_exprs(tcx, self.0, other.0) {
             Some(result) => result == Ordering::Equal,
-            None => panic!("compare_list_exprs: type mismatch"),
+            None => bug!("compare_list_exprs: type mismatch"),
         }
     }
 }
@@ -828,7 +828,7 @@ impl FailureHandler {
     fn handle_fail(&self, bcx: Block) {
         match *self {
             Infallible =>
-                panic!("attempted to panic in a non-panicking panic handler!"),
+                bug!("attempted to panic in a non-panicking panic handler!"),
             JumpToBasicBlock(basic_block) =>
                 Br(bcx, basic_block, DebugLoc::None),
             Unreachable =>
@@ -939,11 +939,11 @@ fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
 
                     compare_str(cx, lhs_data, lhs_len, rhs_data, rhs_len, rhs_t, debug_loc)
                 },
-                _ => cx.sess().bug("only byte strings supported in compare_values"),
+                _ => bug!("only byte strings supported in compare_values"),
             },
-            _ => cx.sess().bug("only string and byte strings supported in compare_values"),
+            _ => bug!("only string and byte strings supported in compare_values"),
         },
-        _ => cx.sess().bug("only scalars, byte strings, and strings supported in compare_values"),
+        _ => bug!("only scalars, byte strings, and strings supported in compare_values"),
     }
 }
 
@@ -986,7 +986,7 @@ fn insert_lllocals<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                         Lvalue::new_with_hint("_match::insert_lllocals (match_input)",
                                               bcx, binding_info.id, hint_kind)
                     }
-                    _ => unreachable!(),
+                    _ => bug!(),
                 };
                 let datum = Datum::new(llval, binding_info.ty, lvalue);
                 call_lifetime_start(bcx, llbinding);
@@ -1317,7 +1317,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                             bcx = r.bcx;
                         }
                         _ => {
-                            bcx.sess().bug(
+                            bug!(
                                 "in compile_submatch, expected \
                                  opt.trans() to return a SingleResult")
                         }
diff --git a/src/librustc_trans/abi.rs b/src/librustc_trans/abi.rs
index dd72322997a..6edc26c7009 100644
--- a/src/librustc_trans/abi.rs
+++ b/src/librustc_trans/abi.rs
@@ -218,7 +218,7 @@ impl FnType {
             Rust | RustCall => llvm::CCallConv,
 
             // It's the ABI's job to select this, not us.
-            System => ccx.sess().bug("system abi should be selected elsewhere"),
+            System => bug!("system abi should be selected elsewhere"),
 
             Stdcall => llvm::X86StdcallCallConv,
             Fastcall => llvm::X86FastcallCallConv,
@@ -241,8 +241,8 @@ impl FnType {
                     &tupled_arguments[..]
                 }
                 _ => {
-                    unreachable!("argument to function with \"rust-call\" ABI \
-                                  is not a tuple");
+                    bug!("argument to function with \"rust-call\" ABI \
+                          is not a tuple");
                 }
             }
         } else {
diff --git a/src/librustc_trans/adt.rs b/src/librustc_trans/adt.rs
index 7c190c2ff71..8922aa06182 100644
--- a/src/librustc_trans/adt.rs
+++ b/src/librustc_trans/adt.rs
@@ -302,9 +302,8 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             // non-empty body, explicit discriminants should have
             // been rejected by a checker before this point.
             if !cases.iter().enumerate().all(|(i,c)| c.discr == Disr::from(i)) {
-                cx.sess().bug(&format!("non-C-like enum {} with specified \
-                                        discriminants",
-                                       cx.tcx().item_path_str(def.did)));
+                bug!("non-C-like enum {} with specified discriminants",
+                     cx.tcx().item_path_str(def.did));
             }
 
             if cases.len() == 1 {
@@ -430,7 +429,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
             General(ity, fields, dtor_to_init_u8(dtor))
         }
-        _ => cx.sess().bug(&format!("adt::represent_type called on non-ADT type: {}", t))
+        _ => bug!("adt::represent_type called on non-ADT type: {}", t)
     }
 }
 
@@ -615,7 +614,7 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp
     match hint {
         attr::ReprInt(span, ity) => {
             if !bounds_usable(cx, ity, bounds) {
-                cx.sess().span_bug(span, "representation hint insufficient for discriminant range")
+                span_bug!(span, "representation hint insufficient for discriminant range")
             }
             return ity;
         }
@@ -632,10 +631,10 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp
             attempts = choose_shortest;
         },
         attr::ReprPacked => {
-            cx.tcx().sess.bug("range_to_inttype: found ReprPacked on an enum");
+            bug!("range_to_inttype: found ReprPacked on an enum");
         }
         attr::ReprSimd => {
-            cx.tcx().sess.bug("range_to_inttype: found ReprSimd on an enum");
+            bug!("range_to_inttype: found ReprSimd on an enum");
         }
     }
     for &ity in attempts {
@@ -835,7 +834,7 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                  Type::array(&Type::i64(cx), align_units),
                 a if a.count_ones() == 1 => Type::array(&Type::vector(&Type::i32(cx), a / 4),
                                                               align_units),
-                _ => panic!("unsupported enum alignment: {}", align)
+                _ => bug!("unsupported enum alignment: {}", align)
             };
             assert_eq!(machine::llalign_of_min(cx, fill_ty), align);
             assert_eq!(padded_discr_size % discr_size, 0); // Ensure discr_ty can fill pad evenly
@@ -984,7 +983,7 @@ pub fn trans_case<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr, discr: Disr)
             C_integral(ll_inttype(bcx.ccx(), ity), discr.0, true)
         }
         Univariant(..) => {
-            bcx.ccx().sess().bug("no cases for univariants or structs")
+            bug!("no cases for univariants or structs")
         }
         RawNullablePointer { .. } |
         StructWrappedNullablePointer { .. } => {
@@ -1088,7 +1087,7 @@ pub fn trans_field_ptr_builder<'blk, 'tcx>(bcx: &BlockAndBuilder<'blk, 'tcx>,
     // someday), it will need to return a possibly-new bcx as well.
     match *r {
         CEnum(..) => {
-            bcx.ccx().sess().bug("element access in C-like enum")
+            bug!("element access in C-like enum")
         }
         Univariant(ref st, _dtor) => {
             assert_eq!(discr, Disr(0));
@@ -1279,7 +1278,7 @@ pub fn fold_variants<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
 
             bcx_next
         }
-        _ => unreachable!()
+        _ => bug!()
     }
 }
 
@@ -1319,7 +1318,7 @@ pub fn trans_drop_flag_ptr<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
             fcx.pop_custom_cleanup_scope(custom_cleanup_scope);
             datum::DatumBlock::new(bcx, expr_datum)
         }
-        _ => bcx.ccx().sess().bug("tried to get drop flag of non-droppable type")
+        _ => bug!("tried to get drop flag of non-droppable type")
     }
 }
 
@@ -1478,7 +1477,7 @@ pub fn const_get_discrim(r: &Repr, val: ValueRef) -> Disr {
         }
         Univariant(..) => Disr(0),
         RawNullablePointer { .. } | StructWrappedNullablePointer { .. } => {
-            unreachable!("const discrim access of non c-like enum")
+            bug!("const discrim access of non c-like enum")
         }
     }
 }
@@ -1488,10 +1487,10 @@ pub fn const_get_discrim(r: &Repr, val: ValueRef) -> Disr {
 ///
 /// (Not to be confused with `common::const_get_elt`, which operates on
 /// raw LLVM-level structs and arrays.)
-pub fn const_get_field(ccx: &CrateContext, r: &Repr, val: ValueRef,
-                       _discr: Disr, ix: usize) -> ValueRef {
+pub fn const_get_field(r: &Repr, val: ValueRef, _discr: Disr,
+                       ix: usize) -> ValueRef {
     match *r {
-        CEnum(..) => ccx.sess().bug("element access in C-like enum const"),
+        CEnum(..) => bug!("element access in C-like enum const"),
         Univariant(..) => const_struct_field(val, ix),
         General(..) => const_struct_field(val, ix + 1),
         RawNullablePointer { .. } => {
diff --git a/src/librustc_trans/assert_dep_graph.rs b/src/librustc_trans/assert_dep_graph.rs
index dcf23039e25..bd98b3950d4 100644
--- a/src/librustc_trans/assert_dep_graph.rs
+++ b/src/librustc_trans/assert_dep_graph.rs
@@ -221,7 +221,7 @@ fn dump_graph(tcx: &TyCtxt) {
             // Expect one of: "-> target", "source -> target", or "source ->".
             let parts: Vec<_> = string.split("->").collect();
             if parts.len() > 2 {
-                panic!("Invalid RUST_DEP_GRAPH_FILTER: expected '[source] -> [target]'");
+                bug!("Invalid RUST_DEP_GRAPH_FILTER: expected '[source] -> [target]'");
             }
             let sources = node_set(&query, &parts[0]);
             let targets = node_set(&query, &parts[1]);
diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs
index 062f9482c72..7aef1d912ec 100644
--- a/src/librustc_trans/back/link.rs
+++ b/src/librustc_trans/back/link.rs
@@ -187,8 +187,8 @@ pub fn link_binary(sess: &Session,
     let mut out_filenames = Vec::new();
     for &crate_type in sess.crate_types.borrow().iter() {
         if invalid_output_for_target(sess, crate_type) {
-            sess.bug(&format!("invalid output type `{:?}` for target os `{}`",
-                             crate_type, sess.opts.target_triple));
+           bug!("invalid output type `{:?}` for target os `{}`",
+                crate_type, sess.opts.target_triple);
         }
         let out_file = link_binary_output(sess, trans, crate_type, outputs,
                                           crate_name);
@@ -282,7 +282,7 @@ pub fn each_linked_rlib(sess: &Session,
     let fmts = fmts.get(&config::CrateTypeExecutable).or_else(|| {
         fmts.get(&config::CrateTypeStaticlib)
     }).unwrap_or_else(|| {
-        sess.bug("could not find formats for rlibs")
+        bug!("could not find formats for rlibs")
     });
     for (cnum, path) in crates {
         match fmts[cnum as usize - 1] {
@@ -895,7 +895,7 @@ fn add_local_native_libraries(cmd: &mut Linker, sess: &Session) {
         match kind {
             NativeLibraryKind::NativeUnknown => cmd.link_dylib(l),
             NativeLibraryKind::NativeFramework => cmd.link_framework(l),
-            NativeLibraryKind::NativeStatic => unreachable!(),
+            NativeLibraryKind::NativeStatic => bug!(),
         }
     }
 }
@@ -1081,7 +1081,7 @@ fn add_upstream_native_libraries(cmd: &mut Linker, sess: &Session) {
                 NativeLibraryKind::NativeUnknown => cmd.link_dylib(lib),
                 NativeLibraryKind::NativeFramework => cmd.link_framework(lib),
                 NativeLibraryKind::NativeStatic => {
-                    sess.bug("statics shouldn't be propagated");
+                    bug!("statics shouldn't be propagated");
                 }
             }
         }
diff --git a/src/librustc_trans/back/linker.rs b/src/librustc_trans/back/linker.rs
index 29caf93dcd5..c02a482f812 100644
--- a/src/librustc_trans/back/linker.rs
+++ b/src/librustc_trans/back/linker.rs
@@ -271,10 +271,10 @@ impl<'a> Linker for MsvcLinker<'a> {
     }
 
     fn framework_path(&mut self, _path: &Path) {
-        panic!("frameworks are not supported on windows")
+        bug!("frameworks are not supported on windows")
     }
     fn link_framework(&mut self, _framework: &str) {
-        panic!("frameworks are not supported on windows")
+        bug!("frameworks are not supported on windows")
     }
 
     fn link_whole_staticlib(&mut self, lib: &str, _search_path: &[PathBuf]) {
diff --git a/src/librustc_trans/back/symbol_names.rs b/src/librustc_trans/back/symbol_names.rs
index ee5282e9881..a458307da40 100644
--- a/src/librustc_trans/back/symbol_names.rs
+++ b/src/librustc_trans/back/symbol_names.rs
@@ -224,8 +224,8 @@ fn exported_name_with_opt_suffix<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                 // to be a value or type-def or something in there
                 // *somewhere*
                 ty_def_id.index = key.parent.unwrap_or_else(|| {
-                    panic!("finding type for {:?}, encountered def-id {:?} with no \
-                            parent", def_id, ty_def_id);
+                    bug!("finding type for {:?}, encountered def-id {:?} with no \
+                         parent", def_id, ty_def_id);
                 });
             }
         }
diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs
index 2de650a59be..e6a51eb7c87 100644
--- a/src/librustc_trans/back/write.rs
+++ b/src/librustc_trans/back/write.rs
@@ -113,7 +113,7 @@ impl Emitter for SharedEmitter {
     }
 
     fn custom_emit(&mut self, _sp: &errors::RenderSpan, _msg: &str, _lvl: Level) {
-        panic!("SharedEmitter doesn't support custom_emit");
+        bug!("SharedEmitter doesn't support custom_emit");
     }
 }
 
@@ -159,7 +159,7 @@ pub fn create_target_machine(sess: &Session) -> TargetMachineRef {
                                  .cg
                                  .relocation_model));
             sess.abort_if_errors();
-            unreachable!();
+            bug!();
         }
     };
 
@@ -190,7 +190,7 @@ pub fn create_target_machine(sess: &Session) -> TargetMachineRef {
                                  .cg
                                  .code_model));
             sess.abort_if_errors();
-            unreachable!();
+            bug!();
         }
     };
 
diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs
index 559ba17e1ae..e5667e06b44 100644
--- a/src/librustc_trans/base.rs
+++ b/src/librustc_trans/base.rs
@@ -227,8 +227,7 @@ pub fn malloc_raw_dyn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 }
 
 
-pub fn bin_op_to_icmp_predicate(ccx: &CrateContext,
-                                op: hir::BinOp_,
+pub fn bin_op_to_icmp_predicate(op: hir::BinOp_,
                                 signed: bool)
                                 -> llvm::IntPredicate {
     match op {
@@ -239,15 +238,14 @@ pub fn bin_op_to_icmp_predicate(ccx: &CrateContext,
         hir::BiGt => if signed { llvm::IntSGT } else { llvm::IntUGT },
         hir::BiGe => if signed { llvm::IntSGE } else { llvm::IntUGE },
         op => {
-            ccx.sess()
-               .bug(&format!("comparison_op_to_icmp_predicate: expected comparison operator, \
-                              found {:?}",
-                             op));
+            bug!("comparison_op_to_icmp_predicate: expected comparison operator, \
+                  found {:?}",
+                 op)
         }
     }
 }
 
-pub fn bin_op_to_fcmp_predicate(ccx: &CrateContext, op: hir::BinOp_) -> llvm::RealPredicate {
+pub fn bin_op_to_fcmp_predicate(op: hir::BinOp_) -> llvm::RealPredicate {
     match op {
         hir::BiEq => llvm::RealOEQ,
         hir::BiNe => llvm::RealUNE,
@@ -256,10 +254,9 @@ pub fn bin_op_to_fcmp_predicate(ccx: &CrateContext, op: hir::BinOp_) -> llvm::Re
         hir::BiGt => llvm::RealOGT,
         hir::BiGe => llvm::RealOGE,
         op => {
-            ccx.sess()
-               .bug(&format!("comparison_op_to_fcmp_predicate: expected comparison operator, \
-                              found {:?}",
-                             op));
+            bug!("comparison_op_to_fcmp_predicate: expected comparison operator, \
+                  found {:?}",
+                 op);
         }
     }
 }
@@ -291,7 +288,7 @@ pub fn compare_fat_ptrs<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 hir::BiLe => (llvm::IntULE, llvm::IntULT),
                 hir::BiGt => (llvm::IntUGT, llvm::IntUGT),
                 hir::BiGe => (llvm::IntUGE, llvm::IntUGT),
-                _ => unreachable!(),
+                _ => bug!(),
             };
 
             let addr_eq = ICmp(bcx, llvm::IntEQ, lhs_addr, rhs_addr, debug_loc);
@@ -302,7 +299,7 @@ pub fn compare_fat_ptrs<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             Or(bcx, addr_strict, addr_eq_extra_op, debug_loc)
         }
         _ => {
-            bcx.tcx().sess.bug("unexpected fat ptr binop");
+            bug!("unexpected fat ptr binop");
         }
     }
 }
@@ -322,19 +319,19 @@ pub fn compare_scalar_types<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 hir::BiEq | hir::BiLe | hir::BiGe => return C_bool(bcx.ccx(), true),
                 hir::BiNe | hir::BiLt | hir::BiGt => return C_bool(bcx.ccx(), false),
                 // refinements would be nice
-                _ => bcx.sess().bug("compare_scalar_types: must be a comparison operator"),
+                _ => bug!("compare_scalar_types: must be a comparison operator"),
             }
         }
         ty::TyFnDef(..) | ty::TyFnPtr(_) | ty::TyBool | ty::TyUint(_) | ty::TyChar => {
             ICmp(bcx,
-                 bin_op_to_icmp_predicate(bcx.ccx(), op, false),
+                 bin_op_to_icmp_predicate(op, false),
                  lhs,
                  rhs,
                  debug_loc)
         }
         ty::TyRawPtr(mt) if common::type_is_sized(bcx.tcx(), mt.ty) => {
             ICmp(bcx,
-                 bin_op_to_icmp_predicate(bcx.ccx(), op, false),
+                 bin_op_to_icmp_predicate(op, false),
                  lhs,
                  rhs,
                  debug_loc)
@@ -356,20 +353,20 @@ pub fn compare_scalar_types<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         }
         ty::TyInt(_) => {
             ICmp(bcx,
-                 bin_op_to_icmp_predicate(bcx.ccx(), op, true),
+                 bin_op_to_icmp_predicate(op, true),
                  lhs,
                  rhs,
                  debug_loc)
         }
         ty::TyFloat(_) => {
             FCmp(bcx,
-                 bin_op_to_fcmp_predicate(bcx.ccx(), op),
+                 bin_op_to_fcmp_predicate(op),
                  lhs,
                  rhs,
                  debug_loc)
         }
         // Should never get here, because t is scalar.
-        _ => bcx.sess().bug("non-scalar type passed to compare_scalar_types"),
+        _ => bug!("non-scalar type passed to compare_scalar_types"),
     }
 }
 
@@ -383,15 +380,15 @@ pub fn compare_simd_types<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                       -> ValueRef {
     let signed = match t.sty {
         ty::TyFloat(_) => {
-            let cmp = bin_op_to_fcmp_predicate(bcx.ccx(), op);
+            let cmp = bin_op_to_fcmp_predicate(op);
             return SExt(bcx, FCmp(bcx, cmp, lhs, rhs, debug_loc), ret_ty);
         },
         ty::TyUint(_) => false,
         ty::TyInt(_) => true,
-        _ => bcx.sess().bug("compare_simd_types: invalid SIMD type"),
+        _ => bug!("compare_simd_types: invalid SIMD type"),
     };
 
-    let cmp = bin_op_to_icmp_predicate(bcx.ccx(), op, signed);
+    let cmp = bin_op_to_icmp_predicate(op, signed);
     // LLVM outputs an `< size x i1 >`, so we need to perform a sign extension
     // to get the correctly sized type. This will compile to a single instruction
     // once the IR is converted to assembly if the SIMD instruction is supported
@@ -578,9 +575,9 @@ pub fn unsized_info<'ccx, 'tcx>(ccx: &CrateContext<'ccx, 'tcx>,
             consts::ptrcast(meth::get_vtable(ccx, trait_ref),
                             Type::vtable_ptr(ccx))
         }
-        _ => ccx.sess().bug(&format!("unsized_info: invalid unsizing {:?} -> {:?}",
+        _ => bug!("unsized_info: invalid unsizing {:?} -> {:?}",
                                      source,
-                                     target)),
+                                     target),
     }
 }
 
@@ -604,7 +601,7 @@ pub fn unsize_thin_ptr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             (PointerCast(bcx, src, ptr_ty),
              unsized_info(bcx.ccx(), a, b, None))
         }
-        _ => bcx.sess().bug("unsize_thin_ptr: called on bad types"),
+        _ => bug!("unsize_thin_ptr: called on bad types"),
     }
 }
 
@@ -638,12 +635,12 @@ pub fn coerce_unsized_into<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             let src_repr = adt::represent_type(bcx.ccx(), src_ty);
             let src_fields = match &*src_repr {
                 &adt::Repr::Univariant(ref s, _) => &s.fields,
-                _ => bcx.sess().bug("struct has non-univariant repr"),
+                _ => bug!("struct has non-univariant repr"),
             };
             let dst_repr = adt::represent_type(bcx.ccx(), dst_ty);
             let dst_fields = match &*dst_repr {
                 &adt::Repr::Univariant(ref s, _) => &s.fields,
-                _ => bcx.sess().bug("struct has non-univariant repr"),
+                _ => bug!("struct has non-univariant repr"),
             };
 
             let src = adt::MaybeSizedValue::sized(src);
@@ -664,9 +661,9 @@ pub fn coerce_unsized_into<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 }
             }
         }
-        _ => bcx.sess().bug(&format!("coerce_unsized_into: invalid coercion {:?} -> {:?}",
-                                     src_ty,
-                                     dst_ty)),
+        _ => bug!("coerce_unsized_into: invalid coercion {:?} -> {:?}",
+                  src_ty,
+                  dst_ty),
     }
 }
 
@@ -689,8 +686,7 @@ pub fn custom_coerce_unsize_info<'ccx, 'tcx>(ccx: &CrateContext<'ccx, 'tcx>,
             ccx.tcx().custom_coerce_unsized_kind(impl_def_id)
         }
         vtable => {
-            ccx.sess().bug(&format!("invalid CoerceUnsized vtable: {:?}",
-                                    vtable));
+            bug!("invalid CoerceUnsized vtable: {:?}", vtable);
         }
     }
 }
@@ -758,7 +754,7 @@ pub fn llty_and_min_for_signed_ty<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
             };
             (llty, min)
         }
-        _ => unreachable!(),
+        _ => bug!(),
     }
 }
 
@@ -798,7 +794,7 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
             (res, false)
         }
         _ => {
-            cx.sess().bug(&format!("fail-if-zero on unexpected type: {}", rhs_t));
+            bug!("fail-if-zero on unexpected type: {}", rhs_t);
         }
     };
     let bcx = with_cond(cx, is_zero, |bcx| {
@@ -1323,15 +1319,15 @@ fn build_cfg(tcx: &TyCtxt, id: ast::NodeId) -> (ast::NodeId, Option<cfg::CFG>) {
                 hir::ItemFn(_, _, _, _, _, ref blk) => {
                     blk
                 }
-                _ => tcx.sess.bug("unexpected item variant in has_nested_returns"),
+                _ => bug!("unexpected item variant in has_nested_returns"),
             }
         }
         Some(hir_map::NodeTraitItem(trait_item)) => {
             match trait_item.node {
                 hir::MethodTraitItem(_, Some(ref body)) => body,
                 _ => {
-                    tcx.sess.bug("unexpected variant: trait item other than a provided method in \
-                                  has_nested_returns")
+                    bug!("unexpected variant: trait item other than a provided method in \
+                          has_nested_returns")
                 }
             }
         }
@@ -1339,14 +1335,14 @@ fn build_cfg(tcx: &TyCtxt, id: ast::NodeId) -> (ast::NodeId, Option<cfg::CFG>) {
             match impl_item.node {
                 hir::ImplItemKind::Method(_, ref body) => body,
                 _ => {
-                    tcx.sess.bug("unexpected variant: non-method impl item in has_nested_returns")
+                    bug!("unexpected variant: non-method impl item in has_nested_returns")
                 }
             }
         }
         Some(hir_map::NodeExpr(e)) => {
             match e.node {
                 hir::ExprClosure(_, _, ref blk) => blk,
-                _ => tcx.sess.bug("unexpected expr variant in has_nested_returns"),
+                _ => bug!("unexpected expr variant in has_nested_returns"),
             }
         }
         Some(hir_map::NodeVariant(..)) |
@@ -1355,8 +1351,8 @@ fn build_cfg(tcx: &TyCtxt, id: ast::NodeId) -> (ast::NodeId, Option<cfg::CFG>) {
         // glue, shims, etc
         None if id == ast::DUMMY_NODE_ID => return (ast::DUMMY_NODE_ID, None),
 
-        _ => tcx.sess.bug(&format!("unexpected variant in has_nested_returns: {}",
-                                   tcx.map.path_to_string(id))),
+        _ => bug!("unexpected variant in has_nested_returns: {}",
+                  tcx.map.path_to_string(id)),
     };
 
     (blk.id, Some(cfg::CFG::new(tcx, blk)))
@@ -1675,7 +1671,7 @@ impl<'blk, 'tcx> FunctionContext<'blk, 'tcx> {
                 // FIXME(pcwalton): Reduce the amount of code bloat this is responsible for.
                 let tupled_arg_tys = match arg_ty.sty {
                     ty::TyTuple(ref tys) => tys,
-                    _ => unreachable!("last argument of `rust-call` fn isn't a tuple?!")
+                    _ => bug!("last argument of `rust-call` fn isn't a tuple?!")
                 };
 
                 unpack_datum!(bcx, datum::lvalue_scratch_datum(bcx,
@@ -1978,7 +1974,7 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                                       expr::SaveIn(llresult),
                                       debug_loc);
             }
-            _ => ccx.sess().bug("expected expr as arguments for variant/struct tuple constructor"),
+            _ => bug!("expected expr as arguments for variant/struct tuple constructor"),
         }
     } else {
         // Just eval all the expressions (if any). Since expressions in Rust can have arbitrary
@@ -2381,7 +2377,7 @@ pub fn create_entry_wrapper(ccx: &CrateContext, sp: Span, main_llfn: ValueRef) {
                       .help("did you use #[no_mangle] on `fn main`? Use #[start] instead")
                       .emit();
             ccx.sess().abort_if_errors();
-            panic!();
+            bug!();
         }
         let llfn = declare::declare_cfn(ccx, "main", llfty);
 
@@ -2734,7 +2730,7 @@ pub fn trans_crate<'tcx>(tcx: &TyCtxt<'tcx>,
         });
 
         if POISONED {
-            tcx.sess.bug("couldn't enable multi-threaded LLVM");
+            bug!("couldn't enable multi-threaded LLVM");
         }
     }
 
diff --git a/src/librustc_trans/build.rs b/src/librustc_trans/build.rs
index 0ce7fdb8b6d..0185d158762 100644
--- a/src/librustc_trans/build.rs
+++ b/src/librustc_trans/build.rs
@@ -32,7 +32,7 @@ pub fn terminate(cx: Block, _: &str) {
 
 pub fn check_not_terminated(cx: Block) {
     if cx.terminated.get() {
-        panic!("already terminated!");
+        bug!("already terminated!");
     }
 }
 
diff --git a/src/librustc_trans/builder.rs b/src/librustc_trans/builder.rs
index 55f65d29bfd..92fb342497b 100644
--- a/src/librustc_trans/builder.rs
+++ b/src/librustc_trans/builder.rs
@@ -871,12 +871,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             .zip(args.iter().map(|&v| val_ty(v)));
         for (i, (expected_ty, actual_ty)) in iter.enumerate() {
             if expected_ty != actual_ty {
-                self.ccx.sess().bug(
-                    &format!(
-                        "Type mismatch in function call of {:?}. \
-                         Expected {:?} for param {}, got {:?}",
-                        Value(llfn),
-                        expected_ty, i, actual_ty));
+                bug!("Type mismatch in function call of {:?}. \
+                      Expected {:?} for param {}, got {:?}",
+                     Value(llfn),
+                     expected_ty, i, actual_ty);
 
             }
         }
diff --git a/src/librustc_trans/cabi_aarch64.rs b/src/librustc_trans/cabi_aarch64.rs
index b2929d118a6..4903af2a6ff 100644
--- a/src/librustc_trans/cabi_aarch64.rs
+++ b/src/librustc_trans/cabi_aarch64.rs
@@ -49,7 +49,7 @@ fn ty_align(ty: Type) -> usize {
             let elt = ty.element_type();
             ty_align(elt) * len
         }
-        _ => panic!("ty_align: unhandled type")
+        _ => bug!("ty_align: unhandled type")
     }
 }
 
@@ -81,7 +81,7 @@ fn ty_size(ty: Type) -> usize {
             let eltsz = ty_size(elt);
             len * eltsz
         }
-        _ => panic!("ty_size: unhandled type")
+        _ => bug!("ty_size: unhandled type")
     }
 }
 
diff --git a/src/librustc_trans/cabi_arm.rs b/src/librustc_trans/cabi_arm.rs
index 5dbcf1ef86e..35099399e31 100644
--- a/src/librustc_trans/cabi_arm.rs
+++ b/src/librustc_trans/cabi_arm.rs
@@ -56,7 +56,7 @@ fn general_ty_align(ty: Type) -> usize {
             let elt = ty.element_type();
             general_ty_align(elt) * len
         }
-        _ => panic!("ty_align: unhandled type")
+        _ => bug!("ty_align: unhandled type")
     }
 }
 
@@ -90,7 +90,7 @@ fn ios_ty_align(ty: Type) -> usize {
             let elt = ty.element_type();
             ios_ty_align(elt) * len
         }
-        _ => panic!("ty_align: unhandled type")
+        _ => bug!("ty_align: unhandled type")
     }
 }
 
@@ -125,7 +125,7 @@ fn ty_size(ty: Type, align_fn: TyAlignFn) -> usize {
             let eltsz = ty_size(elt, align_fn);
             len * eltsz
         }
-        _ => panic!("ty_size: unhandled type")
+        _ => bug!("ty_size: unhandled type")
     }
 }
 
diff --git a/src/librustc_trans/cabi_mips.rs b/src/librustc_trans/cabi_mips.rs
index d0fce01ce73..be9d4cad1db 100644
--- a/src/librustc_trans/cabi_mips.rs
+++ b/src/librustc_trans/cabi_mips.rs
@@ -50,7 +50,7 @@ fn ty_align(ty: Type) -> usize {
             let elt = ty.element_type();
             ty_align(elt) * len
         }
-        _ => panic!("ty_align: unhandled type")
+        _ => bug!("ty_align: unhandled type")
     }
 }
 
@@ -82,7 +82,7 @@ fn ty_size(ty: Type) -> usize {
             let eltsz = ty_size(elt);
             len * eltsz
         }
-        _ => panic!("ty_size: unhandled type")
+        _ => bug!("ty_size: unhandled type")
     }
 }
 
diff --git a/src/librustc_trans/cabi_powerpc.rs b/src/librustc_trans/cabi_powerpc.rs
index c9751aa25c1..d118cc86f24 100644
--- a/src/librustc_trans/cabi_powerpc.rs
+++ b/src/librustc_trans/cabi_powerpc.rs
@@ -48,7 +48,7 @@ fn ty_align(ty: Type) -> usize {
             let elt = ty.element_type();
             ty_align(elt)
         }
-        _ => panic!("ty_size: unhandled type")
+        _ => bug!("ty_size: unhandled type")
     }
 }
 
@@ -78,7 +78,7 @@ fn ty_size(ty: Type) -> usize {
             let eltsz = ty_size(elt);
             len * eltsz
         }
-        _ => panic!("ty_size: unhandled type")
+        _ => bug!("ty_size: unhandled type")
     }
 }
 
diff --git a/src/librustc_trans/cabi_powerpc64.rs b/src/librustc_trans/cabi_powerpc64.rs
index 7e7033b4686..7bc41d26f8b 100644
--- a/src/librustc_trans/cabi_powerpc64.rs
+++ b/src/librustc_trans/cabi_powerpc64.rs
@@ -49,7 +49,7 @@ fn ty_align(ty: Type) -> usize {
             let elt = ty.element_type();
             ty_align(elt)
         }
-        _ => panic!("ty_align: unhandled type")
+        _ => bug!("ty_align: unhandled type")
     }
 }
 
@@ -75,7 +75,7 @@ fn ty_size(ty: Type) -> usize {
             let eltsz = ty_size(elt);
             len * eltsz
         }
-        _ => panic!("ty_size: unhandled type")
+        _ => bug!("ty_size: unhandled type")
     }
 }
 
diff --git a/src/librustc_trans/cabi_x86_64.rs b/src/librustc_trans/cabi_x86_64.rs
index a08d9fb5b40..e9e9e266c77 100644
--- a/src/librustc_trans/cabi_x86_64.rs
+++ b/src/librustc_trans/cabi_x86_64.rs
@@ -112,7 +112,7 @@ fn classify_ty(ty: Type) -> Vec<RegClass> {
                 let elt = ty.element_type();
                 ty_align(elt) * len
             }
-            _ => panic!("ty_align: unhandled type")
+            _ => bug!("ty_align: unhandled type")
         }
     }
 
@@ -144,7 +144,7 @@ fn classify_ty(ty: Type) -> Vec<RegClass> {
                 len * eltsz
             }
 
-            _ => panic!("ty_size: unhandled type")
+            _ => bug!("ty_size: unhandled type")
         }
     }
 
@@ -255,7 +255,7 @@ fn classify_ty(ty: Type) -> Vec<RegClass> {
                     Integer => SSEInt(elt.int_width()),
                     Float => SSEFv,
                     Double => SSEDv,
-                    _ => panic!("classify: unhandled vector element type")
+                    _ => bug!("classify: unhandled vector element type")
                 };
 
                 let mut i = 0;
@@ -268,7 +268,7 @@ fn classify_ty(ty: Type) -> Vec<RegClass> {
                     i += 1;
                 }
             }
-            _ => panic!("classify: unhandled type")
+            _ => bug!("classify: unhandled type")
         }
     }
 
@@ -357,7 +357,7 @@ fn llreg_ty(ccx: &CrateContext, cls: &[RegClass]) -> Type {
                                 "llreg_ty: unsupported SSEInt width {}", bits);
                         (64 / bits, Type::ix(ccx, bits))
                     }
-                    _ => unreachable!(),
+                    _ => bug!(),
                 };
                 let vec_len = llvec_len(&cls[i + 1..]);
                 let vec_ty = Type::vector(&elt_ty, vec_len as u64 * elts_per_word);
@@ -371,7 +371,7 @@ fn llreg_ty(ccx: &CrateContext, cls: &[RegClass]) -> Type {
             SSEDs => {
                 tys.push(Type::f64(ccx));
             }
-            _ => panic!("llregtype: unhandled class")
+            _ => bug!("llregtype: unhandled class")
         }
         i += 1;
     }
diff --git a/src/librustc_trans/callee.rs b/src/librustc_trans/callee.rs
index d3c2a895379..a323d63adae 100644
--- a/src/librustc_trans/callee.rs
+++ b/src/librustc_trans/callee.rs
@@ -184,8 +184,8 @@ impl<'tcx> Callee<'tcx> {
                 let method_ty = def_ty(tcx, def_id, substs);
                 let fn_ptr_ty = match method_ty.sty {
                     ty::TyFnDef(_, _, fty) => tcx.mk_ty(ty::TyFnPtr(fty)),
-                    _ => unreachable!("expected fn item type, found {}",
-                                      method_ty)
+                    _ => bug!("expected fn item type, found {}",
+                              method_ty)
                 };
                 Callee::ptr(immediate_rvalue(llfn, fn_ptr_ty))
             }
@@ -196,8 +196,8 @@ impl<'tcx> Callee<'tcx> {
                 let method_ty = def_ty(tcx, def_id, substs);
                 let fn_ptr_ty = match method_ty.sty {
                     ty::TyFnDef(_, _, fty) => tcx.mk_ty(ty::TyFnPtr(fty)),
-                    _ => unreachable!("expected fn item type, found {}",
-                                      method_ty)
+                    _ => bug!("expected fn item type, found {}",
+                              method_ty)
                 };
                 Callee::ptr(immediate_rvalue(llfn, fn_ptr_ty))
             }
@@ -209,7 +209,7 @@ impl<'tcx> Callee<'tcx> {
                 }
             }
             vtable => {
-                unreachable!("resolved vtable bad vtable {:?} in trans", vtable);
+                bug!("resolved vtable bad vtable {:?} in trans", vtable);
             }
         }
     }
@@ -269,9 +269,9 @@ impl<'tcx> Callee<'tcx> {
                 ty::TyFnDef(def_id, substs, _) => {
                     return get_fn(ccx, def_id, substs);
                 }
-                _ => unreachable!("expected fn item type, found {}", self.ty)
+                _ => bug!("expected fn item type, found {}", self.ty)
             },
-            Intrinsic => unreachable!("intrinsic {} getting reified", self.ty)
+            Intrinsic => bug!("intrinsic {} getting reified", self.ty)
         }
     }
 }
@@ -356,8 +356,8 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>(
                                     ref sig }) => sig,
 
         _ => {
-            tcx.sess.bug(&format!("trans_fn_pointer_shim invoked on invalid type: {}",
-                                    bare_fn_ty));
+            bug!("trans_fn_pointer_shim invoked on invalid type: {}",
+                 bare_fn_ty);
         }
     };
     let sig = tcx.erase_late_bound_regions(sig);
@@ -481,7 +481,7 @@ fn get_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                 // Create a fn pointer with the substituted signature.
                 tcx.mk_ty(ty::TyFnPtr(fty))
             }
-            _ => unreachable!("expected fn item type, found {}", fn_ty)
+            _ => bug!("expected fn item type, found {}", fn_ty)
         };
         assert_eq!(type_of::type_of(ccx, fn_ptr_ty), common::val_ty(val));
         return immediate_rvalue(val, fn_ptr_ty);
@@ -494,7 +494,7 @@ fn get_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
             // Create a fn pointer with the normalized signature.
             tcx.mk_fn_ptr(infer::normalize_associated_type(tcx, fty))
         }
-        _ => unreachable!("expected fn item type, found {}", ty)
+        _ => bug!("expected fn item type, found {}", ty)
     };
 
     let instance = Instance::mono(ccx.tcx(), def_id);
@@ -537,7 +537,7 @@ fn get_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         }
 
         ref variant => {
-            ccx.sess().bug(&format!("get_fn: unexpected variant: {:?}", variant))
+            bug!("get_fn: unexpected variant: {:?}", variant)
         }
     };
 
@@ -689,7 +689,7 @@ fn trans_call_inner<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
 
     let llfn = match callee {
         Fn(f) => f,
-        _ => unreachable!("expected fn pointer callee, found {:?}", callee)
+        _ => bug!("expected fn pointer callee, found {:?}", callee)
     };
 
     let (llret, mut bcx) = base::invoke(bcx, llfn, &llargs, debug_loc);
@@ -830,8 +830,8 @@ fn trans_args_under_call_abi<'blk, 'tcx>(
             }
         }
         _ => {
-            bcx.sess().span_bug(tuple_expr.span,
-                                "argument to `.call()` wasn't a tuple?!")
+            span_bug!(tuple_expr.span,
+                      "argument to `.call()` wasn't a tuple?!")
         }
     };
 
diff --git a/src/librustc_trans/cleanup.rs b/src/librustc_trans/cleanup.rs
index 3a8dc144f9c..514e6bda594 100644
--- a/src/librustc_trans/cleanup.rs
+++ b/src/librustc_trans/cleanup.rs
@@ -378,7 +378,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> {
                 return id;
             }
         }
-        self.ccx.sess().bug("no loop scope found");
+        bug!("no loop scope found");
     }
 
     /// Returns a block to branch to which will perform all pending cleanups and
@@ -568,9 +568,8 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> {
             }
         }
 
-        self.ccx.sess().bug(
-            &format!("no cleanup scope {} found",
-                    self.ccx.tcx().map.node_to_string(cleanup_scope)));
+        bug!("no cleanup scope {} found",
+             self.ccx.tcx().map.node_to_string(cleanup_scope));
     }
 
     /// Schedules a cleanup to occur in the top-most scope, which must be a temporary scope.
@@ -763,9 +762,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx
                     }
 
                     LoopExit(id, _) => {
-                        self.ccx.sess().bug(&format!(
-                                "cannot exit from scope {}, \
-                                not in scope", id));
+                        bug!("cannot exit from scope {}, not in scope", id);
                     }
                 }
             }
@@ -1189,8 +1186,7 @@ pub fn temporary_scope(tcx: &TyCtxt,
             r
         }
         None => {
-            tcx.sess.bug(&format!("no temporary scope available for expr {}",
-                                 id))
+            bug!("no temporary scope available for expr {}", id)
         }
     }
 }
diff --git a/src/librustc_trans/closure.rs b/src/librustc_trans/closure.rs
index 44b4f256082..cb94c9dfeb8 100644
--- a/src/librustc_trans/closure.rs
+++ b/src/librustc_trans/closure.rs
@@ -297,7 +297,6 @@ pub fn trans_closure_method<'a, 'tcx>(ccx: &'a CrateContext<'a, 'tcx>,
     let llfn_closure_kind = ccx.tcx().closure_kind(closure_def_id);
 
     let _icx = push_ctxt("trans_closure_adapter_shim");
-    let tcx = ccx.tcx();
 
     debug!("trans_closure_adapter_shim(llfn_closure_kind={:?}, \
            trait_closure_kind={:?}, llfn={:?})",
@@ -329,9 +328,9 @@ pub fn trans_closure_method<'a, 'tcx>(ccx: &'a CrateContext<'a, 'tcx>,
             trans_fn_once_adapter_shim(ccx, closure_def_id, substs, llfn)
         }
         _ => {
-            tcx.sess.bug(&format!("trans_closure_adapter_shim: cannot convert {:?} to {:?}",
-                                  llfn_closure_kind,
-                                  trait_closure_kind));
+            bug!("trans_closure_adapter_shim: cannot convert {:?} to {:?}",
+                 llfn_closure_kind,
+                 trait_closure_kind);
         }
     }
 }
diff --git a/src/librustc_trans/collector.rs b/src/librustc_trans/collector.rs
index 7c5f784216a..1c18f3ca393 100644
--- a/src/librustc_trans/collector.rs
+++ b/src/librustc_trans/collector.rs
@@ -597,7 +597,7 @@ fn find_drop_glue_neighbors<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 
         let substs = match fulfill_obligation(ccx, DUMMY_SP, trait_ref) {
             traits::VtableImpl(data) => data.substs,
-            _ => unreachable!()
+            _ => bug!()
         };
 
         if can_have_local_instance(ccx, destructor_did) {
@@ -665,7 +665,7 @@ fn find_drop_glue_neighbors<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         ty::TyParam(_)      |
         ty::TyInfer(_)      |
         ty::TyError         => {
-            ccx.sess().bug("encountered unexpected type");
+            bug!("encountered unexpected type");
         }
     }
 }
@@ -701,7 +701,7 @@ fn do_static_dispatch<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                     }
                 }
             }
-            _ => unreachable!()
+            _ => bug!()
         }
     } else {
         debug!(" => regular function");
@@ -760,7 +760,7 @@ fn do_static_trait_method_dispatch<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
             None
         }
         _ => {
-            tcx.sess.bug(&format!("static call to invalid vtable: {:?}", vtbl))
+            bug!("static call to invalid vtable: {:?}", vtbl)
         }
     }
 }
@@ -845,10 +845,9 @@ fn find_vtable_types_for_unsizing<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                            target_fields[coerce_index].ty(ccx.tcx(),
                                                                           target_substs))
         }
-        _ => ccx.sess()
-                .bug(&format!("find_vtable_types_for_unsizing: invalid coercion {:?} -> {:?}",
-                               source_ty,
-                               target_ty))
+        _ => bug!("find_vtable_types_for_unsizing: invalid coercion {:?} -> {:?}",
+                  source_ty,
+                  target_ty)
     }
 }
 
@@ -1019,7 +1018,7 @@ impl<'b, 'a, 'v> hir_visit::Visitor<'v> for RootCollector<'b, 'a, 'v> {
                         generics.is_type_parameterized()
                     }
                     _ => {
-                        unreachable!()
+                        bug!()
                     }
                 };
 
@@ -1101,7 +1100,7 @@ fn create_trans_items_for_default_impls<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
             }
         }
         _ => {
-            unreachable!()
+            bug!()
         }
     }
 }
@@ -1252,8 +1251,8 @@ pub fn push_unique_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         ty::TyInfer(_) |
         ty::TyProjection(..) |
         ty::TyParam(_) => {
-            cx.sess().bug(&format!("debuginfo: Trying to create type name for \
-                unexpected type: {:?}", t));
+            bug!("debuginfo: Trying to create type name for \
+                  unexpected type: {:?}", t);
         }
     }
 }
diff --git a/src/librustc_trans/common.rs b/src/librustc_trans/common.rs
index c5d54e30f13..589e6f3266e 100644
--- a/src/librustc_trans/common.rs
+++ b/src/librustc_trans/common.rs
@@ -194,9 +194,7 @@ impl<'tcx> VariantInfo<'tcx> {
             }
 
             _ => {
-                tcx.sess.bug(&format!(
-                    "cannot get field types from the type {:?}",
-                    ty));
+                bug!("cannot get field types from the type {:?}", ty);
             }
         }
     }
@@ -209,7 +207,7 @@ impl<'tcx> VariantInfo<'tcx> {
 
     pub fn field_index(&self, name: ast::Name) -> usize {
         self.fields.iter().position(|&Field(n,_)| n == name).unwrap_or_else(|| {
-            panic!("unknown field `{}`", name)
+            bug!("unknown field `{}`", name)
         })
     }
 }
@@ -596,8 +594,7 @@ impl<'blk, 'tcx> BlockS<'blk, 'tcx> {
         match self.tcx().def_map.borrow().get(&nid) {
             Some(v) => v.full_def(),
             None => {
-                self.tcx().sess.bug(&format!(
-                    "no def associated with node id {}", nid));
+                bug!("no def associated with node id {}", nid);
             }
         }
     }
@@ -910,7 +907,7 @@ pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> Va
         let gsym = token::gensym("str");
         let sym = format!("str{}", gsym.0);
         let g = declare::define_global(cx, &sym[..], val_ty(sc)).unwrap_or_else(||{
-            cx.sess().bug(&format!("symbol `{}` is already defined", sym));
+            bug!("symbol `{}` is already defined", sym);
         });
         llvm::LLVMSetInitializer(g, sc);
         llvm::LLVMSetGlobalConstant(g, True);
@@ -1102,11 +1099,11 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                 "reached the recursion limit during monomorphization (selection ambiguity)");
         }
         Err(e) => {
-            tcx.sess.span_bug(
+            span_bug!(
                 span,
-                &format!("Encountered error `{:?}` selecting `{:?}` during trans",
-                        e,
-                        trait_ref))
+                "Encountered error `{:?}` selecting `{:?}` during trans",
+                e,
+                trait_ref)
         }
     };
 
@@ -1194,7 +1191,7 @@ pub fn inlined_variant_def<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         inlined_vid_def_id == v.did ||
             ccx.external().borrow().get(&v.did) == Some(&Some(inlined_vid))
     }).unwrap_or_else(|| {
-        ccx.sess().bug(&format!("no variant for {:?}::{}", adt_def, inlined_vid))
+        bug!("no variant for {:?}::{}", adt_def, inlined_vid)
     })
 }
 
@@ -1255,6 +1252,6 @@ pub fn shift_mask_val<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             let mask = shift_mask_val(bcx, llty.element_type(), mask_llty.element_type(), invert);
             build::VectorSplat(bcx, mask_llty.vector_length(), mask)
         },
-        _ => panic!("shift_mask_val: expected Integer or Vector, found {:?}", kind),
+        _ => bug!("shift_mask_val: expected Integer or Vector, found {:?}", kind),
     }
 }
diff --git a/src/librustc_trans/consts.rs b/src/librustc_trans/consts.rs
index 555c12807ba..3e516c0eec4 100644
--- a/src/librustc_trans/consts.rs
+++ b/src/librustc_trans/consts.rs
@@ -75,10 +75,10 @@ pub fn const_lit(cx: &CrateContext, e: &hir::Expr, lit: &ast::Lit)
                 ty::TyUint(t) => {
                     C_integral(Type::uint_from_ty(cx, t), i as u64, false)
                 }
-                _ => cx.sess().span_bug(lit.span,
-                        &format!("integer literal has type {:?} (expected int \
-                                 or usize)",
-                                lit_int_ty))
+                _ => span_bug!(lit.span,
+                        "integer literal has type {:?} (expected int \
+                         or usize)",
+                        lit_int_ty)
             }
         }
         LitKind::Float(ref fs, t) => {
@@ -91,7 +91,7 @@ pub fn const_lit(cx: &CrateContext, e: &hir::Expr, lit: &ast::Lit)
                     C_floating(&fs, Type::float_from_ty(cx, t))
                 }
                 _ => {
-                    cx.sess().span_bug(lit.span,
+                    span_bug!(lit.span,
                         "floating point literal doesn't have the right type");
                 }
             }
@@ -121,7 +121,7 @@ fn addr_of_mut(ccx: &CrateContext,
         let gsym = token::gensym("_");
         let name = format!("{}{}", kind, gsym.0);
         let gv = declare::define_global(ccx, &name[..], val_ty(cv)).unwrap_or_else(||{
-            ccx.sess().bug(&format!("symbol `{}` is already defined", name));
+            bug!("symbol `{}` is already defined", name);
         });
         llvm::LLVMSetInitializer(gv, cv);
         llvm::LLVMSetAlignment(gv, align);
@@ -186,8 +186,7 @@ fn const_deref<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             }
         }
         None => {
-            cx.sess().bug(&format!("unexpected dereferenceable type {:?}",
-                                   ty))
+            bug!("unexpected dereferenceable type {:?}", ty)
         }
     }
 }
@@ -232,7 +231,7 @@ pub fn get_const_expr<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     match lookup_const_by_id(ccx.tcx(), def_id, Some(substs)) {
         Some((ref expr, _ty)) => expr,
         None => {
-            ccx.sess().span_bug(ref_expr.span, "constant item not found")
+            span_bug!(ref_expr.span, "constant item not found")
         }
     }
 }
@@ -357,7 +356,7 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                     llconst = Callee::def(cx, def_id, substs).reify(cx).val;
                 }
                 _ => {
-                    unreachable!("{} cannot be reified to a fn ptr", ety)
+                    bug!("{} cannot be reified to a fn ptr", ety)
                 }
             }
         }
@@ -441,9 +440,9 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             llvm::LLVMDumpValue(llconst);
             llvm::LLVMDumpValue(C_undef(llty));
         }
-        cx.sess().bug(&format!("const {:?} of type {:?} has size {} instead of {}",
-                         e, ety_adjusted,
-                         csize, tsize));
+        bug!("const {:?} of type {:?} has size {} instead of {}",
+             e, ety_adjusted,
+             csize, tsize);
     }
     Ok((llconst, ety_adjusted))
 }
@@ -550,7 +549,7 @@ fn const_err(cx: &CrateContext,
 fn check_binary_expr_validity(cx: &CrateContext, e: &hir::Expr, t: Ty,
                               te1: ValueRef, te2: ValueRef,
                               trueconst: TrueConst) -> Result<(), ConstEvalFailure> {
-    let b = if let hir::ExprBinary(b, _, _) = e.node { b } else { unreachable!() };
+    let b = if let hir::ExprBinary(b, _, _) = e.node { b } else { bug!() };
     let (lhs, rhs) = match (to_const_int(te1, t, cx.tcx()), to_const_int(te2, t, cx.tcx())) {
         (Some(v1), Some(v2)) => (v1, v2),
         _ => return Ok(()),
@@ -642,10 +641,10 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 },
                 hir::BiEq | hir::BiNe | hir::BiLt | hir::BiLe | hir::BiGt | hir::BiGe => {
                     if is_float {
-                        let cmp = base::bin_op_to_fcmp_predicate(cx, b.node);
+                        let cmp = base::bin_op_to_fcmp_predicate(b.node);
                         ConstFCmp(cmp, te1, te2)
                     } else {
-                        let cmp = base::bin_op_to_icmp_predicate(cx, b.node, signed);
+                        let cmp = base::bin_op_to_icmp_predicate(b.node, signed);
                         ConstICmp(cmp, te1, te2)
                     }
                 },
@@ -669,13 +668,13 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             let brepr = adt::represent_type(cx, bt);
             let vinfo = VariantInfo::from_ty(cx.tcx(), bt, None);
             let ix = vinfo.field_index(field.node);
-            adt::const_get_field(cx, &brepr, bv, vinfo.discr, ix)
+            adt::const_get_field(&brepr, bv, vinfo.discr, ix)
         },
         hir::ExprTupField(ref base, idx) => {
             let (bv, bt) = const_expr(cx, &base, param_substs, fn_args, trueconst)?;
             let brepr = adt::represent_type(cx, bt);
             let vinfo = VariantInfo::from_ty(cx.tcx(), bt, None);
-            adt::const_get_field(cx, &brepr, bv, vinfo.discr, idx.node)
+            adt::const_get_field(&brepr, bv, vinfo.discr, idx.node)
         },
         hir::ExprIndex(ref base, ref index) => {
             let (bv, bt) = const_expr(cx, &base, param_substs, fn_args, trueconst)?;
@@ -683,7 +682,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             let iv = if let Some(iv) = const_to_opt_uint(iv) {
                 iv
             } else {
-                cx.sess().span_bug(index.span, "index is not an integer-constant expression");
+                span_bug!(index.span, "index is not an integer-constant expression");
             };
             let (arr, len) = match bt.sty {
                 ty::TyArray(_, u) => (bv, C_uint(cx, u)),
@@ -695,15 +694,15 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                     ty::TyArray(_, u) => {
                         (load_const(cx, bv, mt.ty), C_uint(cx, u))
                     },
-                    _ => cx.sess().span_bug(base.span,
-                                            &format!("index-expr base must be a vector \
-                                                      or string type, found {:?}",
-                                                     bt)),
+                    _ => span_bug!(base.span,
+                                   "index-expr base must be a vector \
+                                    or string type, found {:?}",
+                                   bt),
                 },
-                _ => cx.sess().span_bug(base.span,
-                                        &format!("index-expr base must be a vector \
-                                                  or string type, found {:?}",
-                                                 bt)),
+                _ => span_bug!(base.span,
+                               "index-expr base must be a vector \
+                                or string type, found {:?}",
+                               bt),
             };
 
             let len = unsafe { llvm::LLVMConstIntGetZExtValue(len) as u64 };
@@ -784,8 +783,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                   llvm::LLVMConstPtrToInt(v, llty.to_ref())
                 },
                 _ => {
-                  cx.sess().impossible_case(e.span,
-                                            "bad combination of types for cast")
+                  span_bug!(e.span, "bad combination of types for cast")
                 },
             } } // unsafe { match ( ... ) {
         },
@@ -845,8 +843,8 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                     (Some(ref f), _) => {
                         const_expr(cx, &f.expr, param_substs, fn_args, trueconst).map(|(l, _)| l)
                     },
-                    (_, Some((bv, _))) => Ok(adt::const_get_field(cx, &repr, bv, discr, ix)),
-                    (_, None) => cx.sess().span_bug(e.span, "missing struct field"),
+                    (_, Some((bv, _))) => Ok(adt::const_get_field(&repr, bv, discr, ix)),
+                    (_, None) => span_bug!(e.span, "missing struct field"),
                 }
             })
             .collect::<Vec<Result<_, ConstEvalFailure>>>()
@@ -900,7 +898,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                     if let Some(val) = fn_args.and_then(|args| args.get(&id).cloned()) {
                         val
                     } else {
-                        cx.sess().span_bug(e.span, "const fn argument not found")
+                        span_bug!(e.span, "const fn argument not found")
                     }
                 }
                 Def::Fn(..) | Def::Method(..) => C_nil(cx),
@@ -917,15 +915,15 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                         }
                         ty::VariantKind::Tuple => C_nil(cx),
                         ty::VariantKind::Struct => {
-                            cx.sess().span_bug(e.span, "path-expr refers to a dict variant!")
+                            span_bug!(e.span, "path-expr refers to a dict variant!")
                         }
                     }
                 }
                 // Unit struct or ctor.
                 Def::Struct(..) => C_null(type_of::type_of(cx, ety)),
                 _ => {
-                    cx.sess().span_bug(e.span, "expected a const, fn, struct, \
-                                                or variant def")
+                    span_bug!(e.span, "expected a const, fn, struct, \
+                                       or variant def")
                 }
             }
         },
@@ -969,7 +967,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                      Disr::from(vinfo.disr_val),
                                      &arg_vals[..])
                 }
-                _ => cx.sess().span_bug(e.span, "expected a struct, variant, or const fn def"),
+                _ => span_bug!(e.span, "expected a struct, variant, or const fn def"),
             }
         },
         hir::ExprMethodCall(_, _, ref args) => {
@@ -1003,14 +1001,14 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                                 substs);
                 }
                 _ =>
-                    cx.sess().span_bug(
+                    span_bug!(
                         e.span,
-                        &format!("bad type for closure expr: {:?}", ety))
+                        "bad type for closure expr: {:?}", ety)
             }
             C_null(type_of::type_of(cx, ety))
         },
-        _ => cx.sess().span_bug(e.span,
-                                "bad constant expression type in consts::const_expr"),
+        _ => span_bug!(e.span,
+                       "bad constant expression type in consts::const_expr"),
     })
 }
 
@@ -1105,7 +1103,7 @@ pub fn get_static<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, def_id: DefId)
                 g
             }
 
-            item => unreachable!("get_static: expected static, found {:?}", item)
+            item => bug!("get_static: expected static, found {:?}", item)
         }
     } else {
         // FIXME(nagisa): perhaps the map of externs could be offloaded to llvm somehow?
diff --git a/src/librustc_trans/context.rs b/src/librustc_trans/context.rs
index dcf96cfa814..3574883c5f5 100644
--- a/src/librustc_trans/context.rs
+++ b/src/librustc_trans/context.rs
@@ -596,7 +596,7 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> {
         }
         match declare_intrinsic(self, key) {
             Some(v) => return v,
-            None => panic!("unknown intrinsic '{}'", key)
+            None => bug!("unknown intrinsic '{}'", key)
         }
     }
 
@@ -785,7 +785,7 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> {
         match &self.sess().target.target.target_pointer_width[..] {
             "32" => 1 << 31,
             "64" => 1 << 47,
-            _ => unreachable!() // error handled by config::build_target_config
+            _ => bug!() // error handled by config::build_target_config
         }
     }
 
diff --git a/src/librustc_trans/controlflow.rs b/src/librustc_trans/controlflow.rs
index 04562087af7..6d4b02f076c 100644
--- a/src/librustc_trans/controlflow.rs
+++ b/src/librustc_trans/controlflow.rs
@@ -322,7 +322,7 @@ pub fn trans_break_cont<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             match bcx.tcx().def_map.borrow().get(&expr.id).map(|d| d.full_def())  {
                 Some(Def::Label(loop_id)) => loop_id,
                 r => {
-                    bcx.tcx().sess.bug(&format!("{:?} in def-map for label", r))
+                    bug!("{:?} in def-map for label", r)
                 }
             }
         }
diff --git a/src/librustc_trans/datum.rs b/src/librustc_trans/datum.rs
index 6f96b5769bf..0ed38f06817 100644
--- a/src/librustc_trans/datum.rs
+++ b/src/librustc_trans/datum.rs
@@ -584,10 +584,10 @@ impl<'tcx> Datum<'tcx, Expr> {
 
     /// Asserts that this datum *is* an lvalue and returns it.
     #[allow(dead_code)] // potentially useful
-    pub fn assert_lvalue(self, bcx: Block) -> Datum<'tcx, Lvalue> {
+    pub fn assert_lvalue(self) -> Datum<'tcx, Lvalue> {
         self.match_kind(
             |d| d,
-            |_| bcx.sess().bug("assert_lvalue given rvalue"))
+            |_| bug!("assert_lvalue given rvalue"))
     }
 
     pub fn store_to_dest<'blk>(self,
diff --git a/src/librustc_trans/debuginfo/create_scope_map.rs b/src/librustc_trans/debuginfo/create_scope_map.rs
index 20e8a3fb0cf..a7f2bf4a5fa 100644
--- a/src/librustc_trans/debuginfo/create_scope_map.rs
+++ b/src/librustc_trans/debuginfo/create_scope_map.rs
@@ -98,7 +98,7 @@ fn with_new_scope<F>(cx: &CrateContext,
     }
 
     if scope_stack.last().unwrap().scope_metadata != scope_metadata {
-        cx.sess().span_bug(scope_span, "debuginfo: Inconsistency in scope management.");
+        span_bug!(scope_span, "debuginfo: Inconsistency in scope management.");
     }
 
     scope_stack.pop();
diff --git a/src/librustc_trans/debuginfo/gdb.rs b/src/librustc_trans/debuginfo/gdb.rs
index 5612f3d1e90..cf312855d75 100644
--- a/src/librustc_trans/debuginfo/gdb.rs
+++ b/src/librustc_trans/debuginfo/gdb.rs
@@ -71,7 +71,7 @@ pub fn get_or_insert_gdb_debug_scripts_section_global(ccx: &CrateContext)
 
             let section_var = declare::define_global(ccx, section_var_name,
                                                      llvm_type).unwrap_or_else(||{
-                ccx.sess().bug(&format!("symbol `{}` is already defined", section_var_name))
+                bug!("symbol `{}` is already defined", section_var_name)
             });
             llvm::LLVMSetSection(section_var, section_name.as_ptr() as *const _);
             llvm::LLVMSetInitializer(section_var, C_bytes(ccx, section_contents));
diff --git a/src/librustc_trans/debuginfo/metadata.rs b/src/librustc_trans/debuginfo/metadata.rs
index af7ccdb6cf5..5690b18bc8e 100644
--- a/src/librustc_trans/debuginfo/metadata.rs
+++ b/src/librustc_trans/debuginfo/metadata.rs
@@ -102,25 +102,22 @@ impl<'tcx> TypeMap<'tcx> {
     // Adds a Ty to metadata mapping to the TypeMap. The method will fail if
     // the mapping already exists.
     fn register_type_with_metadata<'a>(&mut self,
-                                       cx: &CrateContext<'a, 'tcx>,
                                        type_: Ty<'tcx>,
                                        metadata: DIType) {
         if self.type_to_metadata.insert(type_, metadata).is_some() {
-            cx.sess().bug(&format!("Type metadata for Ty '{}' is already in the TypeMap!",
-                                   type_));
+            bug!("Type metadata for Ty '{}' is already in the TypeMap!", type_);
         }
     }
 
     // Adds a UniqueTypeId to metadata mapping to the TypeMap. The method will
     // fail if the mapping already exists.
     fn register_unique_id_with_metadata(&mut self,
-                                        cx: &CrateContext,
                                         unique_type_id: UniqueTypeId,
                                         metadata: DIType) {
         if self.unique_id_to_metadata.insert(unique_type_id, metadata).is_some() {
             let unique_type_id_str = self.get_unique_type_id_as_string(unique_type_id);
-            cx.sess().bug(&format!("Type metadata for unique id '{}' is already in the TypeMap!",
-                                  &unique_type_id_str[..]));
+            bug!("Type metadata for unique id '{}' is already in the TypeMap!",
+                 &unique_type_id_str[..]);
         }
     }
 
@@ -305,8 +302,8 @@ impl<'tcx> TypeMap<'tcx> {
                 }
             },
             _ => {
-                cx.sess().bug(&format!("get_unique_type_id_of_type() - unexpected type: {:?}",
-                                       type_))
+                bug!("get_unique_type_id_of_type() - unexpected type: {:?}",
+                     type_)
             }
         };
 
@@ -415,8 +412,8 @@ fn create_and_register_recursive_type_forward_declaration<'a, 'tcx>(
 
     // Insert the stub into the TypeMap in order to allow for recursive references
     let mut type_map = debug_context(cx).type_map.borrow_mut();
-    type_map.register_unique_id_with_metadata(cx, unique_type_id, metadata_stub);
-    type_map.register_type_with_metadata(cx, unfinished_type, metadata_stub);
+    type_map.register_unique_id_with_metadata(unique_type_id, metadata_stub);
+    type_map.register_type_with_metadata(unfinished_type, metadata_stub);
 
     UnfinishedMetadata {
         unfinished_type: unfinished_type,
@@ -452,10 +449,9 @@ impl<'tcx> RecursiveTypeDescription<'tcx> {
                     let type_map = debug_context(cx).type_map.borrow();
                     if type_map.find_metadata_for_unique_id(unique_type_id).is_none() ||
                        type_map.find_metadata_for_type(unfinished_type).is_none() {
-                        cx.sess().bug(&format!("Forward declaration of potentially recursive type \
-                                              '{:?}' was not found in TypeMap!",
-                                              unfinished_type)
-                                      );
+                        bug!("Forward declaration of potentially recursive type \
+                              '{:?}' was not found in TypeMap!",
+                             unfinished_type);
                     }
                 }
 
@@ -640,9 +636,9 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     let def_id = match trait_type.sty {
         ty::TyTrait(ref data) => data.principal_def_id(),
         _ => {
-            cx.sess().bug(&format!("debuginfo: Unexpected trait-object type in \
-                                   trait_pointer_metadata(): {:?}",
-                                   trait_type));
+            bug!("debuginfo: Unexpected trait-object type in \
+                  trait_pointer_metadata(): {:?}",
+                 trait_type);
         }
     };
 
@@ -688,7 +684,7 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                         // There is already an equivalent type in the TypeMap.
                         // Register this Ty as an alias in the cache and
                         // return the cached metadata.
-                        type_map.register_type_with_metadata(cx, t, metadata);
+                        type_map.register_type_with_metadata(t, metadata);
                         return metadata;
                     },
                     None => {
@@ -803,8 +799,7 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                    usage_site_span).finalize(cx)
         }
         _ => {
-            cx.sess().bug(&format!("debuginfo: unexpected type in type_metadata: {:?}",
-                                  sty))
+            bug!("debuginfo: unexpected type in type_metadata: {:?}", sty)
         }
     };
 
@@ -818,13 +813,13 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 None => {
                     let unique_type_id_str =
                         type_map.get_unique_type_id_as_string(unique_type_id);
-                    let error_message = format!("Expected type metadata for unique \
-                                                 type id '{}' to already be in \
-                                                 the debuginfo::TypeMap but it \
-                                                 was not. (Ty = {})",
-                                                &unique_type_id_str[..],
-                                                t);
-                    cx.sess().span_bug(usage_site_span, &error_message[..]);
+                    span_bug!(usage_site_span,
+                              "Expected type metadata for unique \
+                               type id '{}' to already be in \
+                               the debuginfo::TypeMap but it \
+                               was not. (Ty = {})",
+                              &unique_type_id_str[..],
+                              t);
                 }
             };
 
@@ -833,22 +828,22 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                     if metadata != metadata_for_uid {
                         let unique_type_id_str =
                             type_map.get_unique_type_id_as_string(unique_type_id);
-                        let error_message = format!("Mismatch between Ty and \
-                                                     UniqueTypeId maps in \
-                                                     debuginfo::TypeMap. \
-                                                     UniqueTypeId={}, Ty={}",
-                            &unique_type_id_str[..],
-                            t);
-                        cx.sess().span_bug(usage_site_span, &error_message[..]);
+                        span_bug!(usage_site_span,
+                                  "Mismatch between Ty and \
+                                   UniqueTypeId maps in \
+                                   debuginfo::TypeMap. \
+                                   UniqueTypeId={}, Ty={}",
+                                  &unique_type_id_str[..],
+                                  t);
                     }
                 }
                 None => {
-                    type_map.register_type_with_metadata(cx, t, metadata);
+                    type_map.register_type_with_metadata(t, metadata);
                 }
             }
         } else {
-            type_map.register_type_with_metadata(cx, t, metadata);
-            type_map.register_unique_id_with_metadata(cx, unique_type_id, metadata);
+            type_map.register_type_with_metadata(t, metadata);
+            type_map.register_unique_id_with_metadata(unique_type_id, metadata);
         }
     }
 
@@ -901,16 +896,16 @@ pub fn scope_metadata(fcx: &FunctionContext,
                   error_reporting_span: Span)
                -> DIScope {
     let scope_map = &fcx.debug_context
-                        .get_ref(fcx.ccx, error_reporting_span)
+                        .get_ref(error_reporting_span)
                         .scope_map;
     match scope_map.borrow().get(&node_id).cloned() {
         Some(scope_metadata) => scope_metadata,
         None => {
             let node = fcx.ccx.tcx().map.get(node_id);
 
-            fcx.ccx.sess().span_bug(error_reporting_span,
-                &format!("debuginfo: Could not find scope info for node {:?}",
-                        node));
+            span_bug!(error_reporting_span,
+                      "debuginfo: Could not find scope info for node {:?}",
+                      node);
         }
     }
 }
@@ -945,7 +940,7 @@ fn basic_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         ty::TyFloat(float_ty) => {
             (float_ty.ty_to_string(), DW_ATE_float)
         },
-        _ => cx.sess().bug("debuginfo::basic_type_metadata - t is invalid type")
+        _ => bug!("debuginfo::basic_type_metadata - t is invalid type")
     };
 
     let llvm_type = type_of::type_of(cx, t);
@@ -1162,7 +1157,7 @@ fn prepare_struct_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
     let (variant, substs) = match struct_type.sty {
         ty::TyStruct(def, substs) => (def.struct_variant(), substs),
-        _ => cx.tcx().sess.bug("prepare_struct_metadata on a non-struct")
+        _ => bug!("prepare_struct_metadata on a non-struct")
     };
 
     let (containing_scope, _) = get_namespace_and_span_for_item(cx, variant.did);
@@ -1362,7 +1357,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> {
                         ty::VariantKind::Struct => {
                             non_null_variant.fields[0].name.to_string()
                         }
-                        ty::VariantKind::Unit => unreachable!()
+                        ty::VariantKind::Unit => bug!()
                     },
                     llvm_type: non_null_llvm_type,
                     type_metadata: non_null_type_metadata,
@@ -1452,7 +1447,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> {
                     }
                 ]
             },
-            adt::CEnum(..) => cx.sess().span_bug(self.span, "This should be unreachable.")
+            adt::CEnum(..) => span_bug!(self.span, "This should be unreachable.")
         }
     }
 }
@@ -1747,8 +1742,8 @@ fn set_members_of_composite_type(cx: &CrateContext,
         let mut composite_types_completed =
             debug_context(cx).composite_types_completed.borrow_mut();
         if composite_types_completed.contains(&composite_type_metadata) {
-            cx.sess().bug("debuginfo::set_members_of_composite_type() - \
-                           Already completed forward declaration re-encountered.");
+            bug!("debuginfo::set_members_of_composite_type() - \
+                  Already completed forward declaration re-encountered.");
         } else {
             composite_types_completed.insert(composite_type_metadata);
         }
@@ -1855,20 +1850,19 @@ pub fn create_global_var_metadata(cx: &CrateContext,
                 hir::ItemStatic(..) => (item.name, item.span),
                 hir::ItemConst(..) => (item.name, item.span),
                 _ => {
-                    cx.sess()
-                      .span_bug(item.span,
-                                &format!("debuginfo::\
-                                         create_global_var_metadata() -
-                                         Captured var-id refers to \
-                                         unexpected ast_item variant: {:?}",
-                                        var_item))
+                    span_bug!(item.span,
+                              "debuginfo::\
+                               create_global_var_metadata() -
+                               Captured var-id refers to \
+                               unexpected ast_item variant: {:?}",
+                              var_item)
                 }
             }
         },
-        _ => cx.sess().bug(&format!("debuginfo::create_global_var_metadata() \
-                                    - Captured var-id refers to unexpected \
-                                    hir_map variant: {:?}",
-                                   var_item))
+        _ => bug!("debuginfo::create_global_var_metadata() \
+                   - Captured var-id refers to unexpected \
+                   hir_map variant: {:?}",
+                  var_item)
     };
 
     let (file_metadata, line_number) = if span != codemap::DUMMY_SP {
@@ -1924,15 +1918,15 @@ pub fn create_local_var_metadata(bcx: Block, local: &hir::Local) {
         let datum = match locals.get(&node_id) {
             Some(datum) => datum,
             None => {
-                bcx.sess().span_bug(span,
-                    &format!("no entry in lllocals table for {}",
-                            node_id));
+                span_bug!(span,
+                          "no entry in lllocals table for {}",
+                          node_id);
             }
         };
 
         if unsafe { llvm::LLVMIsAAllocaInst(datum.val) } == ptr::null_mut() {
-            cx.sess().span_bug(span, "debuginfo::create_local_var_metadata() - \
-                                      Referenced variable location is not an alloca!");
+            span_bug!(span, "debuginfo::create_local_var_metadata() - \
+                             Referenced variable location is not an alloca!");
         }
 
         let scope_metadata = scope_metadata(bcx.fcx, node_id, span);
@@ -1968,7 +1962,7 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
     let variable_name = match ast_item {
         None => {
-            cx.sess().span_bug(span, "debuginfo::create_captured_var_metadata: node not found");
+            span_bug!(span, "debuginfo::create_captured_var_metadata: node not found");
         }
         Some(hir_map::NodeLocal(pat)) => {
             match pat.node {
@@ -1976,28 +1970,25 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                     path1.node.name
                 }
                 _ => {
-                    cx.sess()
-                      .span_bug(span,
-                                &format!(
-                                "debuginfo::create_captured_var_metadata() - \
-                                 Captured var-id refers to unexpected \
-                                 hir_map variant: {:?}",
-                                 ast_item));
+                    span_bug!(span,
+                              "debuginfo::create_captured_var_metadata() - \
+                               Captured var-id refers to unexpected \
+                               hir_map variant: {:?}",
+                              ast_item);
                 }
             }
         }
         _ => {
-            cx.sess()
-              .span_bug(span,
-                        &format!("debuginfo::create_captured_var_metadata() - \
-                                 Captured var-id refers to unexpected \
-                                 hir_map variant: {:?}",
-                                ast_item));
+            span_bug!(span,
+                      "debuginfo::create_captured_var_metadata() - \
+                       Captured var-id refers to unexpected \
+                       hir_map variant: {:?}",
+                      ast_item);
         }
     };
 
     let variable_type = common::node_id_type(bcx, node_id);
-    let scope_metadata = bcx.fcx.debug_context.get_ref(cx, span).fn_metadata;
+    let scope_metadata = bcx.fcx.debug_context.get_ref(span).fn_metadata;
 
     // env_pointer is the alloca containing the pointer to the environment,
     // so it's type is **EnvironmentType. In order to find out the type of
@@ -2096,7 +2087,7 @@ pub fn create_argument_metadata(bcx: Block, arg: &hir::Arg) {
     let scope_metadata = bcx
                          .fcx
                          .debug_context
-                         .get_ref(bcx.ccx(), arg.pat.span)
+                         .get_ref(arg.pat.span)
                          .fn_metadata;
     let locals = bcx.fcx.lllocals.borrow();
 
@@ -2104,22 +2095,20 @@ pub fn create_argument_metadata(bcx: Block, arg: &hir::Arg) {
         let datum = match locals.get(&node_id) {
             Some(v) => v,
             None => {
-                bcx.sess().span_bug(span,
-                    &format!("no entry in lllocals table for {}",
-                            node_id));
+                span_bug!(span, "no entry in lllocals table for {}", node_id);
             }
         };
 
         if unsafe { llvm::LLVMIsAAllocaInst(datum.val) } == ptr::null_mut() {
-            bcx.sess().span_bug(span, "debuginfo::create_argument_metadata() - \
-                                       Referenced variable location is not an alloca!");
+            span_bug!(span, "debuginfo::create_argument_metadata() - \
+                             Referenced variable location is not an alloca!");
         }
 
         let argument_index = {
             let counter = &bcx
                           .fcx
                           .debug_context
-                          .get_ref(bcx.ccx(), span)
+                          .get_ref(span)
                           .argument_counter;
             let argument_index = counter.get();
             counter.set(argument_index + 1);
diff --git a/src/librustc_trans/debuginfo/mod.rs b/src/librustc_trans/debuginfo/mod.rs
index 66e33698389..6b92989cf46 100644
--- a/src/librustc_trans/debuginfo/mod.rs
+++ b/src/librustc_trans/debuginfo/mod.rs
@@ -119,18 +119,19 @@ pub enum FunctionDebugContext {
 
 impl FunctionDebugContext {
     fn get_ref<'a>(&'a self,
-                   cx: &CrateContext,
                    span: Span)
                    -> &'a FunctionDebugContextData {
         match *self {
             FunctionDebugContext::RegularContext(box ref data) => data,
             FunctionDebugContext::DebugInfoDisabled => {
-                cx.sess().span_bug(span,
-                                   FunctionDebugContext::debuginfo_disabled_message());
+                span_bug!(span,
+                          "{}",
+                          FunctionDebugContext::debuginfo_disabled_message());
             }
             FunctionDebugContext::FunctionWithoutDebugInfo => {
-                cx.sess().span_bug(span,
-                                   FunctionDebugContext::should_be_ignored_message());
+                span_bug!(span,
+                          "{}",
+                          FunctionDebugContext::should_be_ignored_message());
             }
         }
     }
@@ -253,7 +254,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                     (item.name, fn_decl, generics, top_level_block, item.span, true)
                 }
                 _ => {
-                    cx.sess().span_bug(item.span,
+                    span_bug!(item.span,
                         "create_function_debug_context: item bound to non-function");
                 }
             }
@@ -273,9 +274,9 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                      true)
                 }
                 _ => {
-                    cx.sess().span_bug(impl_item.span,
-                                       "create_function_debug_context() \
-                                        called on non-method impl item?!")
+                    span_bug!(impl_item.span,
+                              "create_function_debug_context() \
+                               called on non-method impl item?!")
                 }
             }
         }
@@ -293,7 +294,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                         // Don't try to lookup the item path:
                         false)
                 }
-                _ => cx.sess().span_bug(expr.span,
+                _ => span_bug!(expr.span,
                         "create_function_debug_context: expected an expr_fn_block here")
             }
         }
@@ -312,10 +313,9 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                      true)
                 }
                 _ => {
-                    cx.sess()
-                      .bug(&format!("create_function_debug_context: \
-                                    unexpected sort of node: {:?}",
-                                    fnitem))
+                    bug!("create_function_debug_context: \
+                          unexpected sort of node: {:?}",
+                         fnitem)
                 }
             }
         }
@@ -324,9 +324,9 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         hir_map::NodeStructCtor(..) => {
             return FunctionDebugContext::FunctionWithoutDebugInfo;
         }
-        _ => cx.sess().bug(&format!("create_function_debug_context: \
-                                    unexpected sort of node: {:?}",
-                                   fnitem))
+        _ => bug!("create_function_debug_context: \
+                   unexpected sort of node: {:?}",
+                  fnitem)
     };
 
     // This can be the case for functions inlined from another crate
@@ -441,7 +441,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 (sig, closure_type.abi)
             }
 
-            _ => cx.sess().bug("get_function_metdata: Expected a function type!")
+            _ => bug!("get_function_metdata: Expected a function type!")
         };
 
         let mut signature = Vec::with_capacity(sig.inputs.len() + 1);
@@ -640,7 +640,7 @@ fn declare_local<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         ArgumentVariable(_) | CapturedVariable => {
             assert!(!bcx.fcx
                         .debug_context
-                        .get_ref(cx, span)
+                        .get_ref(span)
                         .source_locations_enabled
                         .get());
             source_loc::set_debug_location(cx, InternalDebugLocation::UnknownLocation);
diff --git a/src/librustc_trans/debuginfo/namespace.rs b/src/librustc_trans/debuginfo/namespace.rs
index 552188ae2a6..445f85c52fc 100644
--- a/src/librustc_trans/debuginfo/namespace.rs
+++ b/src/librustc_trans/debuginfo/namespace.rs
@@ -126,9 +126,9 @@ pub fn namespace_for_item(cx: &CrateContext, def_id: DefId) -> Rc<NamespaceTreeN
         match parent_node {
             Some(node) => node,
             None => {
-                cx.sess().bug(&format!("debuginfo::namespace_for_item(): \
-                                       path too short for {:?}",
-                                      def_id));
+                bug!("debuginfo::namespace_for_item(): \
+                      path too short for {:?}",
+                     def_id);
             }
         }
     })
diff --git a/src/librustc_trans/debuginfo/type_names.rs b/src/librustc_trans/debuginfo/type_names.rs
index 71dd3e432df..a6aa8df92db 100644
--- a/src/librustc_trans/debuginfo/type_names.rs
+++ b/src/librustc_trans/debuginfo/type_names.rs
@@ -154,8 +154,8 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         ty::TyInfer(_) |
         ty::TyProjection(..) |
         ty::TyParam(_) => {
-            cx.sess().bug(&format!("debuginfo: Trying to create type name for \
-                unexpected type: {:?}", t));
+            bug!("debuginfo: Trying to create type name for \
+                unexpected type: {:?}", t);
         }
     }
 
@@ -178,7 +178,7 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 }
 
                 if path_element_count == 0 {
-                    cx.sess().bug("debuginfo: Encountered empty item path!");
+                    bug!("debuginfo: Encountered empty item path!");
                 }
 
                 output.pop();
diff --git a/src/librustc_trans/debuginfo/utils.rs b/src/librustc_trans/debuginfo/utils.rs
index d2ae74569e7..61dc3dc3f8f 100644
--- a/src/librustc_trans/debuginfo/utils.rs
+++ b/src/librustc_trans/debuginfo/utils.rs
@@ -91,8 +91,8 @@ pub fn assert_type_for_node_id(cx: &CrateContext,
                            node_id: ast::NodeId,
                            error_reporting_span: Span) {
     if !cx.tcx().node_types().contains_key(&node_id) {
-        cx.sess().span_bug(error_reporting_span,
-                           "debuginfo: Could not find type for node id!");
+        span_bug!(error_reporting_span,
+                  "debuginfo: Could not find type for node id!");
     }
 }
 
diff --git a/src/librustc_trans/declare.rs b/src/librustc_trans/declare.rs
index 28a70fd5e0b..f49d303a5a8 100644
--- a/src/librustc_trans/declare.rs
+++ b/src/librustc_trans/declare.rs
@@ -38,7 +38,7 @@ use libc::c_uint;
 pub fn declare_global(ccx: &CrateContext, name: &str, ty: Type) -> llvm::ValueRef {
     debug!("declare_global(name={:?})", name);
     let namebuf = CString::new(name).unwrap_or_else(|_|{
-        ccx.sess().bug(&format!("name {:?} contains an interior null byte", name))
+        bug!("name {:?} contains an interior null byte", name)
     });
     unsafe {
         llvm::LLVMGetOrInsertGlobal(ccx.llmod(), namebuf.as_ptr(), ty.to_ref())
@@ -53,7 +53,7 @@ pub fn declare_global(ccx: &CrateContext, name: &str, ty: Type) -> llvm::ValueRe
 fn declare_raw_fn(ccx: &CrateContext, name: &str, callconv: llvm::CallConv, ty: Type) -> ValueRef {
     debug!("declare_raw_fn(name={:?}, ty={:?})", name, ty);
     let namebuf = CString::new(name).unwrap_or_else(|_|{
-        ccx.sess().bug(&format!("name {:?} contains an interior null byte", name))
+        bug!("name {:?} contains an interior null byte", name)
     });
     let llfn = unsafe {
         llvm::LLVMGetOrInsertFunction(ccx.llmod(), namebuf.as_ptr(), ty.to_ref())
@@ -152,7 +152,7 @@ pub fn define_internal_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 pub fn get_defined_value(ccx: &CrateContext, name: &str) -> Option<ValueRef> {
     debug!("get_defined_value(name={:?})", name);
     let namebuf = CString::new(name).unwrap_or_else(|_|{
-        ccx.sess().bug(&format!("name {:?} contains an interior null byte", name))
+        bug!("name {:?} contains an interior null byte", name)
     });
     let val = unsafe { llvm::LLVMGetNamedValue(ccx.llmod(), namebuf.as_ptr()) };
     if val.is_null() {
diff --git a/src/librustc_trans/expr.rs b/src/librustc_trans/expr.rs
index b2e2e93a2be..5e193b96278 100644
--- a/src/librustc_trans/expr.rs
+++ b/src/librustc_trans/expr.rs
@@ -388,7 +388,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                         .reify(bcx.ccx()).to_expr_datum();
                 }
                 _ => {
-                    unreachable!("{} cannot be reified to a fn ptr", datum.ty)
+                    bug!("{} cannot be reified to a fn ptr", datum.ty)
                 }
             }
         }
@@ -516,16 +516,16 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             let repr_source = adt::represent_type(bcx.ccx(), source.ty);
             let src_fields = match &*repr_source {
                 &adt::Repr::Univariant(ref s, _) => &s.fields,
-                _ => bcx.sess().span_bug(span,
-                                         &format!("Non univariant struct? (repr_source: {:?})",
-                                                  repr_source)),
+                _ => span_bug!(span,
+                               "Non univariant struct? (repr_source: {:?})",
+                               repr_source),
             };
             let repr_target = adt::represent_type(bcx.ccx(), target.ty);
             let target_fields = match &*repr_target {
                 &adt::Repr::Univariant(ref s, _) => &s.fields,
-                _ => bcx.sess().span_bug(span,
-                                         &format!("Non univariant struct? (repr_target: {:?})",
-                                                  repr_target)),
+                _ => span_bug!(span,
+                               "Non univariant struct? (repr_target: {:?})",
+                               repr_target),
             };
 
             let coerce_index = match kind {
@@ -555,9 +555,9 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 }
             }
         }
-        _ => bcx.sess().bug(&format!("coerce_unsized: invalid coercion {:?} -> {:?}",
-                                     source.ty,
-                                     target.ty))
+        _ => bug!("coerce_unsized: invalid coercion {:?} -> {:?}",
+                  source.ty,
+                  target.ty)
     }
     bcx
 }
@@ -671,8 +671,8 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 ty::TyBox(..) => {
                     trans_uniq_expr(bcx, expr, box_ty, &contents, contents_ty)
                 }
-                _ => bcx.sess().span_bug(expr.span,
-                                         "expected unique box")
+                _ => span_bug!(expr.span,
+                               "expected unique box")
             }
 
         }
@@ -708,11 +708,11 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             trans_imm_cast(bcx, &val, expr.id)
         }
         _ => {
-            bcx.tcx().sess.span_bug(
+            span_bug!(
                 expr.span,
-                &format!("trans_rvalue_datum_unadjusted reached \
-                         fall-through case: {:?}",
-                        expr.node));
+                "trans_rvalue_datum_unadjusted reached \
+                 fall-through case: {:?}",
+                expr.node);
         }
     }
 }
@@ -798,9 +798,9 @@ fn trans_index<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 bcx.tcx().no_late_bound_regions(&method_ty.fn_ret()).unwrap().unwrap();
             let elt_ty = match ref_ty.builtin_deref(true, ty::NoPreference) {
                 None => {
-                    bcx.tcx().sess.span_bug(index_expr.span,
-                                            "index method didn't return a \
-                                             dereferenceable type?!")
+                    span_bug!(index_expr.span,
+                              "index method didn't return a \
+                              dereferenceable type?!")
                 }
                 Some(elt_tm) => elt_tm.ty,
             };
@@ -895,9 +895,7 @@ pub fn trans_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, def: Def)
             match bcx.fcx.llupvars.borrow().get(&nid) {
                 Some(&val) => Datum::new(val, local_ty, lval),
                 None => {
-                    bcx.sess().bug(&format!(
-                        "trans_var: no llval for upvar {} found",
-                        nid));
+                    bug!("trans_var: no llval for upvar {} found", nid);
                 }
             }
         }
@@ -905,16 +903,14 @@ pub fn trans_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, def: Def)
             let datum = match bcx.fcx.lllocals.borrow().get(&nid) {
                 Some(&v) => v,
                 None => {
-                    bcx.sess().bug(&format!(
-                        "trans_var: no datum for local/arg {} found",
-                        nid));
+                    bug!("trans_var: no datum for local/arg {} found", nid);
                 }
             };
             debug!("take_local(nid={}, v={:?}, ty={})",
                    nid, Value(datum.val), datum.ty);
             datum
         }
-        _ => unreachable!("{:?} should not reach expr::trans_var", def)
+        _ => bug!("{:?} should not reach expr::trans_var", def)
     }
 }
 
@@ -1051,11 +1047,11 @@ fn trans_rvalue_stmt_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             bcx
         }
         _ => {
-            bcx.tcx().sess.span_bug(
+            span_bug!(
                 expr.span,
-                &format!("trans_rvalue_stmt_unadjusted reached \
-                         fall-through case: {:?}",
-                        expr.node));
+                "trans_rvalue_stmt_unadjusted reached \
+                 fall-through case: {:?}",
+                expr.node);
         }
     }
 }
@@ -1114,11 +1110,9 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                     tvec::trans_lit_str(bcx, expr, (*s).clone(), dest)
                 }
                 _ => {
-                    bcx.tcx()
-                       .sess
-                       .span_bug(expr.span,
-                                 "trans_rvalue_dps_unadjusted shouldn't be \
-                                  translating this type of literal")
+                    span_bug!(expr.span,
+                              "trans_rvalue_dps_unadjusted shouldn't be \
+                              translating this type of literal")
                 }
             }
         }
@@ -1141,9 +1135,9 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             let (def_id, substs) = match expr_ty(bcx, expr).sty {
                 ty::TyClosure(def_id, ref substs) => (def_id, substs),
                 ref t =>
-                    bcx.tcx().sess.span_bug(
+                    span_bug!(
                         expr.span,
-                        &format!("closure expr without closure type: {:?}", t)),
+                        "closure expr without closure type: {:?}", t),
             };
 
             closure::trans_closure_expr(dest,
@@ -1172,8 +1166,8 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                         Callee::ptr(f)
                     }
                     _ => {
-                        bcx.tcx().sess.span_bug(expr.span,
-                            &format!("type of callee is not a fn: {}", f.ty));
+                        span_bug!(expr.span,
+                            "type of callee is not a fn: {}", f.ty);
                     }
                 }, ArgExprs(&args))
             };
@@ -1205,20 +1199,20 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         }
         hir::ExprCast(..) => {
             // Trait casts used to come this way, now they should be coercions.
-            bcx.tcx().sess.span_bug(expr.span, "DPS expr_cast (residual trait cast?)")
+            span_bug!(expr.span, "DPS expr_cast (residual trait cast?)")
         }
         hir::ExprAssignOp(op, _, _) => {
-            bcx.tcx().sess.span_bug(
+            span_bug!(
                 expr.span,
-                &format!("augmented assignment `{}=` should always be a rvalue_stmt",
-                         rustc_front::util::binop_to_string(op.node)))
+                "augmented assignment `{}=` should always be a rvalue_stmt",
+                rustc_front::util::binop_to_string(op.node))
         }
         _ => {
-            bcx.tcx().sess.span_bug(
+            span_bug!(
                 expr.span,
-                &format!("trans_rvalue_dps_unadjusted reached fall-through \
-                         case: {:?}",
-                        expr.node));
+                "trans_rvalue_dps_unadjusted reached fall-through \
+                 case: {:?}",
+                expr.node);
         }
     }
 }
@@ -1261,9 +1255,9 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             bcx
         }
         _ => {
-            bcx.tcx().sess.span_bug(ref_expr.span, &format!(
-                "Non-DPS def {:?} referened by {}",
-                def, bcx.node_id_to_string(ref_expr.id)));
+            span_bug!(ref_expr.span,
+                      "Non-DPS def {:?} referened by {}",
+                      def, bcx.node_id_to_string(ref_expr.id));
         }
     }
 }
@@ -1301,7 +1295,7 @@ fn trans_struct<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         }
         None => {
             if need_base.iter().any(|b| *b) {
-                tcx.sess.span_bug(expr_span, "missing fields and no base expr")
+                span_bug!(expr_span, "missing fields and no base expr")
             }
             None
         }
@@ -1415,7 +1409,7 @@ pub fn trans_adt<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                 bcx = trans_into(bcx, &base.expr, SaveIn(addr.value));
             },
             ExprKind::RvalueStmt => {
-                bcx.tcx().sess.bug("unexpected expr kind for struct base expr")
+                bug!("unexpected expr kind for struct base expr")
             }
             _ => {
                 let base_datum = unpack_datum!(bcx, trans_to_lvalue(bcx, &base.expr, "base"));
@@ -1728,7 +1722,7 @@ fn trans_scalar_binop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
           base::compare_scalar_types(bcx, lhs, rhs, lhs_t, op.node, binop_debug_loc)
       }
       _ => {
-        bcx.tcx().sess.span_bug(binop_expr.span, "unexpected binop");
+        span_bug!(binop_expr.span, "unexpected binop");
       }
     };
 
@@ -1968,12 +1962,11 @@ fn trans_imm_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         (Float, Int(I)) => FPToSI(bcx, llexpr, ll_t_out),
         (Float, Int(_)) => FPToUI(bcx, llexpr, ll_t_out),
 
-        _ => ccx.sess().span_bug(expr.span,
-                                  &format!("translating unsupported cast: \
-                                            {:?} -> {:?}",
-                                           t_in,
-                                           t_out)
-                                 )
+        _ => span_bug!(expr.span,
+                       "translating unsupported cast: \
+                        {:?} -> {:?}",
+                       t_in,
+                       t_out)
     };
     return immediate_rvalue_bcx(bcx, newval, t_out).to_expr_datumblock();
 }
@@ -2140,10 +2133,10 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         }
 
         _ => {
-            bcx.tcx().sess.span_bug(
+            span_bug!(
                 expr.span,
-                &format!("deref invoked on expr of invalid type {:?}",
-                        datum.ty));
+                "deref invoked on expr of invalid type {:?}",
+                datum.ty);
         }
     };
 
@@ -2200,16 +2193,16 @@ impl OverflowOpViaIntrinsic {
             TyInt(Is) => match &tcx.sess.target.target.target_pointer_width[..] {
                 "32" => TyInt(I32),
                 "64" => TyInt(I64),
-                _ => panic!("unsupported target word size")
+                _ => bug!("unsupported target word size")
             },
             TyUint(Us) => match &tcx.sess.target.target.target_pointer_width[..] {
                 "32" => TyUint(U32),
                 "64" => TyUint(U64),
-                _ => panic!("unsupported target word size")
+                _ => bug!("unsupported target word size")
             },
             ref t @ TyUint(_) | ref t @ TyInt(_) => t.clone(),
-            _ => panic!("tried to get overflow intrinsic for {:?} applied to non-int type",
-                        *self)
+            _ => bug!("tried to get overflow intrinsic for {:?} applied to non-int type",
+                      *self)
         };
 
         match *self {
@@ -2224,7 +2217,7 @@ impl OverflowOpViaIntrinsic {
                 TyUint(U32) => "llvm.uadd.with.overflow.i32",
                 TyUint(U64) => "llvm.uadd.with.overflow.i64",
 
-                _ => unreachable!(),
+                _ => bug!(),
             },
             OverflowOpViaIntrinsic::Sub => match new_sty {
                 TyInt(I8) => "llvm.ssub.with.overflow.i8",
@@ -2237,7 +2230,7 @@ impl OverflowOpViaIntrinsic {
                 TyUint(U32) => "llvm.usub.with.overflow.i32",
                 TyUint(U64) => "llvm.usub.with.overflow.i64",
 
-                _ => unreachable!(),
+                _ => bug!(),
             },
             OverflowOpViaIntrinsic::Mul => match new_sty {
                 TyInt(I8) => "llvm.smul.with.overflow.i8",
@@ -2250,7 +2243,7 @@ impl OverflowOpViaIntrinsic {
                 TyUint(U32) => "llvm.umul.with.overflow.i32",
                 TyUint(U64) => "llvm.umul.with.overflow.i64",
 
-                _ => unreachable!(),
+                _ => bug!(),
             },
         }
     }
@@ -2337,7 +2330,7 @@ fn build_nonzero_check<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             let int_value = BitCast(bcx, value, Type::ix(bcx.ccx(), width));
             build_nonzero_check(bcx, int_value, binop_debug_loc)
         },
-        _ => panic!("build_nonzero_check: expected Integer or Vector, found {:?}", kind),
+        _ => bug!("build_nonzero_check: expected Integer or Vector, found {:?}", kind),
     }
 }
 
@@ -2423,11 +2416,11 @@ fn expr_kind(tcx: &TyCtxt, expr: &hir::Expr) -> ExprKind {
                 Def::AssociatedConst(..) => ExprKind::RvalueDatum,
 
                 def => {
-                    tcx.sess.span_bug(
+                    span_bug!(
                         expr.span,
-                        &format!("uncategorized def for expr {}: {:?}",
-                                expr.id,
-                                def));
+                        "uncategorized def for expr {}: {:?}",
+                        expr.id,
+                        def);
                 }
             }
         }
diff --git a/src/librustc_trans/glue.rs b/src/librustc_trans/glue.rs
index 1af816845b0..6ef4ed4b87e 100644
--- a/src/librustc_trans/glue.rs
+++ b/src/librustc_trans/glue.rs
@@ -367,7 +367,7 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     });
     let vtbl = match fulfill_obligation(bcx.ccx(), DUMMY_SP, trait_ref) {
         traits::VtableImpl(data) => data,
-        _ => tcx.sess.bug(&format!("dtor for {:?} is not an impl???", t))
+        _ => bug!("dtor for {:?} is not an impl???", t)
     };
     let dtor_did = def.destructor().unwrap();
     bcx = Callee::def(bcx.ccx(), dtor_did, vtbl.substs)
@@ -482,7 +482,7 @@ pub fn size_and_align_of_dst<'blk, 'tcx>(bcx: &BlockAndBuilder<'blk, 'tcx>,
             (bcx.mul(info, C_uint(bcx.ccx(), unit_size)),
              C_uint(bcx.ccx(), unit_align))
         }
-        _ => bcx.sess().bug(&format!("Unexpected unsized type, found {}", t))
+        _ => bug!("Unexpected unsized type, found {}", t)
     }
 }
 
diff --git a/src/librustc_trans/inline.rs b/src/librustc_trans/inline.rs
index cf1542b7b03..4d18e3bd495 100644
--- a/src/librustc_trans/inline.rs
+++ b/src/librustc_trans/inline.rs
@@ -102,16 +102,16 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId) -> Option<DefId> {
                 }
                 hir::ItemStruct(ref struct_def, _) => {
                     if struct_def.is_struct() {
-                        ccx.sess().bug("instantiate_inline: called on a \
-                                                                 non-tuple struct")
+                        bug!("instantiate_inline: called on a \
+                              non-tuple struct")
                     } else {
                         ccx.external().borrow_mut().insert(fn_id, Some(struct_def.id()));
                         ccx.external_srcs().borrow_mut().insert(struct_def.id(), fn_id);
                         my_id = struct_def.id();
                     }
                 }
-                _ => ccx.sess().bug("instantiate_inline: item has a \
-                                 non-enum, non-struct parent")
+                _ => bug!("instantiate_inline: item has a \
+                           non-enum, non-struct parent")
             }
             my_id
         }
diff --git a/src/librustc_trans/intrinsic.rs b/src/librustc_trans/intrinsic.rs
index 130a864f5e6..219f970835a 100644
--- a/src/librustc_trans/intrinsic.rs
+++ b/src/librustc_trans/intrinsic.rs
@@ -188,7 +188,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
             let sig = tcx.erase_late_bound_regions(&fty.sig);
             (def_id, substs, infer::normalize_associated_type(tcx, &sig))
         }
-        _ => unreachable!("expected fn item type, found {}", callee_ty)
+        _ => bug!("expected fn item type, found {}", callee_ty)
     };
     let arg_tys = sig.inputs;
     let ret_ty = sig.output;
@@ -311,7 +311,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
             }
 
             _ => {
-                ccx.sess().bug("expected expr as argument for transmute");
+                bug!("expected expr as argument for transmute");
             }
         }
     }
@@ -323,7 +323,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
     if name == "move_val_init" {
         if let callee::ArgExprs(ref exprs) = args {
             let (dest_expr, source_expr) = if exprs.len() != 2 {
-                ccx.sess().bug("expected two exprs as arguments for `move_val_init` intrinsic");
+                bug!("expected two exprs as arguments for `move_val_init` intrinsic");
             } else {
                 (&exprs[0], &exprs[1])
             };
@@ -350,7 +350,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
 
             return Result::new(bcx, llresult);
         } else {
-            ccx.sess().bug("expected two exprs as arguments for `move_val_init` intrinsic");
+            bug!("expected two exprs as arguments for `move_val_init` intrinsic");
         }
     }
 
@@ -388,7 +388,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
 
     let ret_ty = match ret_ty {
         ty::FnConverging(ret_ty) => ret_ty,
-        ty::FnDiverging => unreachable!()
+        ty::FnDiverging => bug!()
     };
 
     let llret_ty = type_of::type_of(ccx, ret_ty);
@@ -651,7 +651,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                             } else {
                                 URem(bcx, llargs[0], llargs[1], call_debug_location)
                             },
-                        _ => unreachable!(),
+                        _ => bug!(),
                     },
                 None => {
                     span_invalid_monomorphization_error(
@@ -674,7 +674,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                         "fmul_fast" => FMulFast(bcx, llargs[0], llargs[1], call_debug_location),
                         "fdiv_fast" => FDivFast(bcx, llargs[0], llargs[1], call_debug_location),
                         "frem_fast" => FRemFast(bcx, llargs[0], llargs[1], call_debug_location),
-                        _ => unreachable!(),
+                        _ => bug!(),
                     },
                 None => {
                     span_invalid_monomorphization_error(
@@ -820,7 +820,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
         (_, _) => {
             let intr = match Intrinsic::find(&name) {
                 Some(intr) => intr,
-                None => unreachable!("unknown intrinsic '{}'", name),
+                None => bug!("unknown intrinsic '{}'", name),
             };
             fn one<T>(x: Vec<T>) -> T {
                 assert_eq!(x.len(), 1);
@@ -839,7 +839,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                         match x {
                             32 => vec![Type::f32(ccx)],
                             64 => vec![Type::f64(ccx)],
-                            _ => unreachable!()
+                            _ => bug!()
                         }
                     }
                     Pointer(ref t, ref llvm_elem, _const) => {
@@ -1242,7 +1242,7 @@ fn trans_gnu_try<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             Some(did) => {
                 Callee::def(ccx, did, tcx.mk_substs(Substs::empty())).reify(ccx).val
             }
-            None => ccx.sess().bug("eh_personality_catch not defined"),
+            None => bug!("eh_personality_catch not defined"),
         };
 
         let then = bcx.fcx.new_temp_block("then");
@@ -1357,7 +1357,7 @@ fn generate_filter_fn<'a, 'tcx>(fcx: &FunctionContext<'a, 'tcx>,
         Some(did) => {
             Callee::def(ccx, did, tcx.mk_substs(Substs::empty())).reify(ccx).val
         }
-        None => ccx.sess().bug("msvc_try_filter not defined"),
+        None => bug!("msvc_try_filter not defined"),
     };
 
     let output = ty::FnOutput::FnConverging(tcx.types.i32);
@@ -1417,7 +1417,7 @@ fn generate_filter_fn<'a, 'tcx>(fcx: &FunctionContext<'a, 'tcx>,
             do_trans(bcx, exn, rbp);
         })
     } else {
-        panic!("unknown target to generate a filter function")
+        bug!("unknown target to generate a filter function")
     }
 }
 
@@ -1513,8 +1513,8 @@ fn generic_simd_intrinsic<'blk, 'tcx, 'a>
     if name.starts_with("simd_shuffle") {
         let n: usize = match name["simd_shuffle".len()..].parse() {
             Ok(n) => n,
-            Err(_) => tcx.sess.span_bug(span,
-                                        "bad `simd_shuffle` instruction only caught in trans?")
+            Err(_) => span_bug!(span,
+                                "bad `simd_shuffle` instruction only caught in trans?")
         };
 
         require_simd!(ret_ty, "return");
@@ -1687,7 +1687,7 @@ fn generic_simd_intrinsic<'blk, 'tcx, 'a>
         simd_or: TyUint, TyInt => Or;
         simd_xor: TyUint, TyInt => Xor;
     }
-    bcx.sess().span_bug(span, "unknown SIMD intrinsic");
+    span_bug!(span, "unknown SIMD intrinsic");
 }
 
 // Returns the width of an int TypeVariant, and if it's signed or not
@@ -1701,7 +1701,7 @@ fn int_type_width_signed<'tcx>(sty: &ty::TypeVariants<'tcx>, ccx: &CrateContext)
                 match &ccx.tcx().sess.target.target.target_pointer_width[..] {
                     "32" => 32,
                     "64" => 64,
-                    tws => panic!("Unsupported target word size for isize: {}", tws),
+                    tws => bug!("Unsupported target word size for isize: {}", tws),
                 }
             },
             ast::IntTy::I8 => 8,
@@ -1714,7 +1714,7 @@ fn int_type_width_signed<'tcx>(sty: &ty::TypeVariants<'tcx>, ccx: &CrateContext)
                 match &ccx.tcx().sess.target.target.target_pointer_width[..] {
                     "32" => 32,
                     "64" => 64,
-                    tws => panic!("Unsupported target word size for usize: {}", tws),
+                    tws => bug!("Unsupported target word size for usize: {}", tws),
                 }
             },
             ast::UintTy::U8 => 8,
diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs
index e9687935538..8c6a68cfcf1 100644
--- a/src/librustc_trans/lib.rs
+++ b/src/librustc_trans/lib.rs
@@ -43,7 +43,7 @@ extern crate flate;
 extern crate getopts;
 extern crate graphviz;
 extern crate libc;
-extern crate rustc;
+#[macro_use] extern crate rustc;
 extern crate rustc_back;
 extern crate rustc_data_structures;
 extern crate rustc_front;
diff --git a/src/librustc_trans/meth.rs b/src/librustc_trans/meth.rs
index 65f52fd0799..82b61e15f2b 100644
--- a/src/librustc_trans/meth.rs
+++ b/src/librustc_trans/meth.rs
@@ -186,15 +186,13 @@ pub fn get_vtable<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                 // this would imply that the Self type being erased is
                 // an object type; this cannot happen because we
                 // cannot cast an unsized type into a trait object
-                tcx.sess.bug(
-                    &format!("cannot get vtable for an object type: {:?}",
-                            data));
+                bug!("cannot get vtable for an object type: {:?}",
+                     data);
             }
             traits::VtableParam(..) => {
-                tcx.sess.bug(
-                    &format!("resolved vtable for {:?} to bad vtable {:?} in trans",
-                            trait_ref,
-                            vtable));
+                bug!("resolved vtable for {:?} to bad vtable {:?} in trans",
+                     trait_ref,
+                     vtable);
             }
         }
     });
@@ -229,8 +227,8 @@ pub fn get_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 
     let trt_id = match tcx.impl_trait_ref(impl_id) {
         Some(t_id) => t_id.def_id,
-        None       => ccx.sess().bug("make_impl_vtable: don't know how to \
-                                      make a vtable for a type impl!")
+        None       => bug!("make_impl_vtable: don't know how to \
+                            make a vtable for a type impl!")
     };
 
     tcx.populate_implementations_for_trait_if_necessary(trt_id);
@@ -256,7 +254,7 @@ pub fn get_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 
             let trait_method_type = match tcx.impl_or_trait_item(trait_method_def_id) {
                 ty::MethodTraitItem(m) => m,
-                _ => ccx.sess().bug("should be a method, not other assoc item"),
+                _ => bug!("should be a method, not other assoc item"),
             };
             let name = trait_method_type.name;
 
@@ -330,7 +328,7 @@ pub fn get_impl_method<'tcx>(tcx: &TyCtxt<'tcx>,
             }
         }
         None => {
-            tcx.sess.bug(&format!("method {:?} not found in {:?}", name, impl_def_id))
+            bug!("method {:?} not found in {:?}", name, impl_def_id)
         }
     }
 }
diff --git a/src/librustc_trans/mir/block.rs b/src/librustc_trans/mir/block.rs
index a60b03dd724..cbe21664d28 100644
--- a/src/librustc_trans/mir/block.rs
+++ b/src/librustc_trans/mir/block.rs
@@ -166,7 +166,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                             ty: callee.ty
                         }, f.abi, &f.sig)
                     }
-                    _ => unreachable!("{} is not callable", callee.ty)
+                    _ => bug!("{} is not callable", callee.ty)
                 };
 
                 // Handle intrinsics old trans wants Expr's for, ourselves.
@@ -295,7 +295,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                         return;
                     }
                     Fn(f) => f,
-                    Virtual(_) => unreachable!("Virtual fn ptr not extracted")
+                    Virtual(_) => bug!("Virtual fn ptr not extracted")
                 };
 
                 // Many different ways to call a function handled here
@@ -417,7 +417,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
             }
             Immediate(llval) => (llval, false),
             Ref(llval) => (llval, true),
-            FatPtr(_, _) => unreachable!("fat pointers handled above")
+            FatPtr(_, _) => bug!("fat pointers handled above")
         };
 
         if by_ref && !arg.is_indirect() {
@@ -470,9 +470,9 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
         let lv_ty = lv.ty.to_ty(bcx.tcx());
         let result_types = match lv_ty.sty {
             ty::TyTuple(ref tys) => tys,
-            _ => bcx.tcx().sess.span_bug(
+            _ => span_bug!(
                 self.mir.span,
-                &format!("bad final argument to \"rust-call\" fn {:?}", lv_ty))
+                "bad final argument to \"rust-call\" fn {:?}", lv_ty)
         };
 
         let base_repr = adt::represent_type(bcx.ccx(), lv_ty);
diff --git a/src/librustc_trans/mir/constant.rs b/src/librustc_trans/mir/constant.rs
index 2e154c40875..cf85595c08e 100644
--- a/src/librustc_trans/mir/constant.rs
+++ b/src/librustc_trans/mir/constant.rs
@@ -89,10 +89,10 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
             ConstVal::Struct(_) | ConstVal::Tuple(_) |
             ConstVal::Array(..) | ConstVal::Repeat(..) |
             ConstVal::Function(_) => {
-                unreachable!("MIR must not use {:?} (which refers to a local ID)", cv)
+                bug!("MIR must not use {:?} (which refers to a local ID)", cv)
             }
             ConstVal::Char(c) => C_integral(Type::char(ccx), c as u64, false),
-            ConstVal::Dummy => unreachable!(),
+            ConstVal::Dummy => bug!(),
         }
     }
 
diff --git a/src/librustc_trans/mir/lvalue.rs b/src/librustc_trans/mir/lvalue.rs
index f5f8c23a982..c9087181f9d 100644
--- a/src/librustc_trans/mir/lvalue.rs
+++ b/src/librustc_trans/mir/lvalue.rs
@@ -81,7 +81,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                 assert!(lvalue.llextra != ptr::null_mut());
                 lvalue.llextra
             }
-            _ => bcx.sess().bug("unexpected type in lvalue_len"),
+            _ => bug!("unexpected type in lvalue_len"),
         }
     }
 
@@ -100,7 +100,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                 TempRef::Lvalue(lvalue) =>
                     lvalue,
                 TempRef::Operand(..) =>
-                    tcx.sess.bug(&format!("using operand temp {:?} as lvalue", lvalue)),
+                    bug!("using operand temp {:?} as lvalue", lvalue),
             },
             mir::Lvalue::Arg(index) => self.args[index as usize],
             mir::Lvalue::Static(def_id) => {
diff --git a/src/librustc_trans/mir/mod.rs b/src/librustc_trans/mir/mod.rs
index 61536f3ecae..a7e57fc714b 100644
--- a/src/librustc_trans/mir/mod.rs
+++ b/src/librustc_trans/mir/mod.rs
@@ -180,7 +180,7 @@ fn arg_value_refs<'bcx, 'tcx>(bcx: &BlockAndBuilder<'bcx, 'tcx>,
 
             let tupled_arg_tys = match arg_ty.sty {
                 ty::TyTuple(ref tys) => tys,
-                _ => unreachable!("spread argument isn't a tuple?!")
+                _ => bug!("spread argument isn't a tuple?!")
             };
 
             let lltemp = bcx.with_block(|bcx| {
diff --git a/src/librustc_trans/mir/operand.rs b/src/librustc_trans/mir/operand.rs
index 3b909353f73..c15d6cd5b24 100644
--- a/src/librustc_trans/mir/operand.rs
+++ b/src/librustc_trans/mir/operand.rs
@@ -79,7 +79,7 @@ impl<'tcx> OperandRef<'tcx> {
     pub fn immediate(self) -> ValueRef {
         match self.val {
             OperandValue::Immediate(s) => s,
-            _ => unreachable!()
+            _ => bug!()
         }
     }
 }
@@ -124,8 +124,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                             return o;
                         }
                         TempRef::Operand(None) => {
-                            bcx.tcx().sess.bug(
-                                &format!("use of {:?} before def", lvalue));
+                            bug!("use of {:?} before def", lvalue);
                         }
                         TempRef::Lvalue(..) => {
                             // use path below
diff --git a/src/librustc_trans/mir/rvalue.rs b/src/librustc_trans/mir/rvalue.rs
index 1396883120b..3f7a6c5f180 100644
--- a/src/librustc_trans/mir/rvalue.rs
+++ b/src/librustc_trans/mir/rvalue.rs
@@ -70,7 +70,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                 let operand = self.trans_operand(&bcx, source);
                 bcx.with_block(|bcx| {
                     match operand.val {
-                        OperandValue::FatPtr(..) => unreachable!(),
+                        OperandValue::FatPtr(..) => bug!(),
                         OperandValue::Immediate(llval) => {
                             // unsize from an immediate structure. We don't
                             // really need a temporary alloca here, but
@@ -185,7 +185,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                     ty::TySlice(_) | ty::TyStr => {
                         (bcx.gepi(input.llval, &[from_start]), input.llextra)
                     }
-                    _ => unreachable!("cannot slice {}", ty)
+                    _ => bug!("cannot slice {}", ty)
                 };
                 let adj = C_uint(ccx, from_start + from_end);
                 let lllen1 = bcx.sub(lllen, adj);
@@ -246,7 +246,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                                         .reify(bcx.ccx()).val)
                             }
                             _ => {
-                                unreachable!("{} cannot be reified to a fn ptr", operand.ty)
+                                bug!("{} cannot be reified to a fn ptr", operand.ty)
                             }
                         }
                     }
@@ -279,9 +279,8 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                                 OperandValue::FatPtr(lldata, llextra)
                             }
                             OperandValue::Ref(_) => {
-                                bcx.sess().bug(
-                                    &format!("by-ref operand {:?} in trans_rvalue_operand",
-                                             operand));
+                                bug!("by-ref operand {:?} in trans_rvalue_operand",
+                                     operand);
                             }
                         }
                     }
@@ -341,9 +340,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                                 bcx.fptosi(llval, ll_t_out),
                             (CastTy::Float, CastTy::Int(_)) =>
                                 bcx.fptoui(llval, ll_t_out),
-                            _ => bcx.ccx().sess().bug(
-                                &format!("unsupported cast: {:?} to {:?}", operand.ty, cast_ty)
-                            )
+                            _ => bug!("unsupported cast: {:?} to {:?}", operand.ty, cast_ty)
                         };
                         OperandValue::Immediate(newval)
                     }
@@ -364,7 +361,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                                 OperandValue::Immediate(llval)
                             }
                         } else {
-                            panic!("Unexpected non-FatPtr operand")
+                            bug!("Unexpected non-FatPtr operand")
                         }
                     }
                 };
@@ -425,7 +422,7 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                                                        DebugLoc::None)
                             })
                         }
-                        _ => unreachable!()
+                        _ => bug!()
                     }
 
                 } else {
@@ -489,7 +486,8 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
             mir::Rvalue::Aggregate(..) |
             mir::Rvalue::Slice { .. } |
             mir::Rvalue::InlineAsm { .. } => {
-                bcx.tcx().sess.bug(&format!("cannot generate operand from rvalue {:?}", rvalue));
+                bug!("cannot generate operand from rvalue {:?}", rvalue);
+
             }
         }
     }
diff --git a/src/librustc_trans/mir/statement.rs b/src/librustc_trans/mir/statement.rs
index d291bc19db5..1d85ac6fb79 100644
--- a/src/librustc_trans/mir/statement.rs
+++ b/src/librustc_trans/mir/statement.rs
@@ -36,9 +36,9 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                                 bcx
                             }
                             TempRef::Operand(Some(_)) => {
-                                bcx.tcx().sess.span_bug(
-                                    statement.span,
-                                    &format!("operand {:?} already assigned", rvalue));
+                                span_bug!(statement.span,
+                                          "operand {:?} already assigned",
+                                          rvalue);
                             }
                         }
                     }
diff --git a/src/librustc_trans/monomorphize.rs b/src/librustc_trans/monomorphize.rs
index 04a07bdf1ce..554e1948fe9 100644
--- a/src/librustc_trans/monomorphize.rs
+++ b/src/librustc_trans/monomorphize.rs
@@ -149,13 +149,13 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                     Disr::from(inlined_variant_def(ccx, fn_node_id).disr_val)
                 }
                 hir_map::NodeStructCtor(_) => Disr(0),
-                _ => unreachable!()
+                _ => bug!()
             };
             attributes::inline(lldecl, attributes::InlineAttr::Hint);
             base::trans_ctor_shim(ccx, fn_node_id, disr, psubsts, lldecl);
         }
 
-        _ => unreachable!("can't monomorphize a {:?}", map_node)
+        _ => bug!("can't monomorphize a {:?}", map_node)
     };
 
     ccx.monomorphizing().borrow_mut().insert(fn_id, depth);
diff --git a/src/librustc_trans/tvec.rs b/src/librustc_trans/tvec.rs
index 56ba1b02426..b9af02ac529 100644
--- a/src/librustc_trans/tvec.rs
+++ b/src/librustc_trans/tvec.rs
@@ -183,8 +183,7 @@ fn write_content<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                     }
                 }
                 _ => {
-                    bcx.tcx().sess.span_bug(content_expr.span,
-                                            "unexpected evec content");
+                    span_bug!(content_expr.span, "unexpected evec content");
                 }
             }
         }
@@ -236,8 +235,7 @@ fn write_content<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             }
         }
         _ => {
-            bcx.tcx().sess.span_bug(content_expr.span,
-                                    "unexpected vec content");
+            span_bug!(content_expr.span, "unexpected vec content");
         }
     }
 }
@@ -264,8 +262,7 @@ fn elements_required(bcx: Block, content_expr: &hir::Expr) -> usize {
             match lit.node {
                 ast::LitKind::Str(ref s, _) => s.len(),
                 _ => {
-                    bcx.tcx().sess.span_bug(content_expr.span,
-                                            "unexpected evec content")
+                    span_bug!(content_expr.span, "unexpected evec content")
                 }
             }
         },
@@ -273,8 +270,7 @@ fn elements_required(bcx: Block, content_expr: &hir::Expr) -> usize {
         hir::ExprRepeat(_, ref count_expr) => {
             eval_repeat_count(bcx.tcx(), &count_expr)
         }
-        _ => bcx.tcx().sess.span_bug(content_expr.span,
-                                     "unexpected vec content")
+        _ => span_bug!(content_expr.span, "unexpected vec content")
     }
 }
 
@@ -298,8 +294,6 @@ pub fn get_base_and_len<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                     llval: ValueRef,
                                     vec_ty: Ty<'tcx>)
                                     -> (ValueRef, ValueRef) {
-    let ccx = bcx.ccx();
-
     match vec_ty.sty {
         ty::TyArray(_, n) => get_fixed_base_and_len(bcx, llval, n),
         ty::TySlice(_) | ty::TyStr => {
@@ -317,7 +311,7 @@ pub fn get_base_and_len<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             };
             get_base_and_len(bcx, inner, ty)
         },
-        _ => ccx.sess().bug("unexpected type in get_base_and_len"),
+        _ => bug!("unexpected type in get_base_and_len"),
     }
 }
 
diff --git a/src/librustc_trans/type_.rs b/src/librustc_trans/type_.rs
index 910a1c7f729..35a60cd5422 100644
--- a/src/librustc_trans/type_.rs
+++ b/src/librustc_trans/type_.rs
@@ -124,7 +124,7 @@ impl Type {
         match &ccx.tcx().sess.target.target.target_pointer_width[..] {
             "32" => Type::i32(ccx),
             "64" => Type::i64(ccx),
-            tws => panic!("Unsupported target word size for int: {}", tws),
+            tws => bug!("Unsupported target word size for int: {}", tws),
         }
     }
 
@@ -288,7 +288,7 @@ impl Type {
             Double => 64,
             X86_FP80 => 80,
             FP128 | PPC_FP128 => 128,
-            _ => panic!("llvm_float_width called on a non-float type")
+            _ => bug!("llvm_float_width called on a non-float type")
         }
     }
 
diff --git a/src/librustc_trans/type_of.rs b/src/librustc_trans/type_of.rs
index 02f659fdc2e..8b1aaafab58 100644
--- a/src/librustc_trans/type_of.rs
+++ b/src/librustc_trans/type_of.rs
@@ -113,10 +113,9 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ
         }
 
         ty::TyProjection(..) | ty::TyInfer(..) | ty::TyParam(..) | ty::TyError => {
-            cx.sess().bug(&format!("fictitious type {:?} in sizing_type_of()",
-                                   t))
+            bug!("fictitious type {:?} in sizing_type_of()", t)
         }
-        ty::TySlice(_) | ty::TyTrait(..) | ty::TyStr => unreachable!()
+        ty::TySlice(_) | ty::TyTrait(..) | ty::TyStr => bug!()
     };
 
     debug!("--> mapped t={:?} to llsizingty={:?}", t, llsizingty);
@@ -132,7 +131,7 @@ fn unsized_info_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> Type
             Type::uint_from_ty(ccx, ast::UintTy::Us)
         }
         ty::TyTrait(_) => Type::vtable_ptr(ccx),
-        _ => unreachable!("Unexpected tail in unsized_info_ty: {:?} for ty={:?}",
+        _ => bug!("Unexpected tail in unsized_info_ty: {:?} for ty={:?}",
                           unsized_part, ty)
     }
 }
@@ -296,10 +295,10 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) ->
           }
       }
 
-      ty::TyInfer(..) => cx.sess().bug("type_of with TyInfer"),
-      ty::TyProjection(..) => cx.sess().bug("type_of with TyProjection"),
-      ty::TyParam(..) => cx.sess().bug("type_of with ty_param"),
-      ty::TyError => cx.sess().bug("type_of with TyError"),
+      ty::TyInfer(..) => bug!("type_of with TyInfer"),
+      ty::TyProjection(..) => bug!("type_of with TyProjection"),
+      ty::TyParam(..) => bug!("type_of with ty_param"),
+      ty::TyError => bug!("type_of with TyError"),
     };
 
     debug!("--> mapped t={:?} to llty={:?}", t, llty);