From f02490d960ecff8fc17272453f4eb8a6837b5a18 Mon Sep 17 00:00:00 2001 From: bjorn3 Date: Thu, 21 Feb 2019 15:06:09 +0100 Subject: [PATCH] Rustfmt --- src/abi.rs | 167 +++++++++++++++++++++++++++++++-------------- src/allocator.rs | 12 ++-- src/base.rs | 50 ++++++++------ src/common.rs | 65 ++++++++++-------- src/constant.rs | 17 ++--- src/debuginfo.rs | 83 ++++++++++++---------- src/lib.rs | 61 ++++++++++------- src/pretty_clif.rs | 27 +++++--- src/unsize.rs | 79 ++++++++++++--------- 9 files changed, 341 insertions(+), 220 deletions(-) diff --git a/src/abi.rs b/src/abi.rs index 97f539d3a68c..b4de8aeea196 100644 --- a/src/abi.rs +++ b/src/abi.rs @@ -2,7 +2,7 @@ use std::borrow::Cow; use std::iter; use rustc::hir; -use rustc::ty::layout::{Scalar, Primitive, Integer, FloatTy}; +use rustc::ty::layout::{FloatTy, Integer, Primitive, Scalar}; use rustc_target::spec::abi::Abi; use crate::prelude::*; @@ -32,11 +32,11 @@ pub fn scalar_to_clif_type(tcx: TyCtxt, scalar: Scalar) -> Type { Integer::I32 => types::I32, Integer::I64 => types::I64, Integer::I128 => unimpl!("u/i128"), - } + }, Primitive::Float(flt) => match flt { FloatTy::F32 => types::F32, FloatTy::F64 => types::F64, - } + }, Primitive::Pointer => pointer_ty(tcx), } } @@ -46,9 +46,7 @@ fn get_pass_mode<'a, 'tcx: 'a>( ty: Ty<'tcx>, is_return: bool, ) -> PassMode { - let layout = tcx - .layout_of(ParamEnv::reveal_all().and(ty)) - .unwrap(); + let layout = tcx.layout_of(ParamEnv::reveal_all().and(ty)).unwrap(); assert!(!layout.is_unsized()); if layout.size.bytes() == 0 { @@ -66,7 +64,9 @@ fn get_pass_mode<'a, 'tcx: 'a>( PassMode::ByRef } } - layout::Abi::Scalar(scalar) => PassMode::ByVal(scalar_to_clif_type(tcx, scalar.clone())), + layout::Abi::Scalar(scalar) => { + PassMode::ByVal(scalar_to_clif_type(tcx, scalar.clone())) + } // FIXME implement ScalarPair and Vector Abi in a cg_llvm compatible way layout::Abi::ScalarPair(_, _) => PassMode::ByRef, @@ -88,10 +88,7 @@ fn adjust_arg_for_abi<'a, 'tcx: 'a>( } } -fn clif_sig_from_fn_sig<'a, 'tcx: 'a>( - tcx: TyCtxt<'a, 'tcx, 'tcx>, - sig: FnSig<'tcx>, -) -> Signature { +fn clif_sig_from_fn_sig<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sig: FnSig<'tcx>) -> Signature { let (call_conv, inputs, output): (CallConv, Vec, Ty) = match sig.abi { Abi::Rust => (CallConv::SystemV, sig.inputs().to_vec(), sig.output()), Abi::C => (CallConv::SystemV, sig.inputs().to_vec(), sig.output()), @@ -191,7 +188,7 @@ pub fn ty_fn_sig<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> ty::FnS pub fn get_function_name_and_sig<'a, 'tcx>( tcx: TyCtxt<'a, 'tcx, 'tcx>, inst: Instance<'tcx>, - support_vararg: bool + support_vararg: bool, ) -> (String, Signature) { assert!(!inst.substs.needs_infer() && !inst.substs.has_param_types()); let fn_ty = inst.ty(tcx); @@ -219,7 +216,8 @@ impl<'a, 'tcx: 'a, B: Backend + 'a> FunctionCx<'a, 'tcx, B> { /// Instance must be monomorphized pub fn get_function_ref(&mut self, inst: Instance<'tcx>) -> FuncRef { let func_id = import_function(self.tcx, self.module, inst); - let func_ref = self.module + let func_ref = self + .module .declare_func_in_func(func_id, &mut self.bcx.func); #[cfg(debug_assertions)] @@ -285,7 +283,12 @@ impl<'a, 'tcx: 'a, B: Backend + 'a> FunctionCx<'a, 'tcx, B> { if let Some(val) = self.lib_call(name, input_tys, return_ty, &args) { CValue::ByVal(val, return_layout) } else { - CValue::ByRef(self.bcx.ins().iconst(self.pointer_type, self.pointer_type.bytes() as i64), return_layout) + CValue::ByRef( + self.bcx + .ins() + .iconst(self.pointer_type, self.pointer_type.bytes() as i64), + return_layout, + ) } } @@ -322,13 +325,21 @@ fn add_arg_comment<'a, 'tcx: 'a>( let pass_mode = format!("{:?}", pass_mode); fx.add_global_comment(format!( "{msg:5} {local:>3}{local_field:<5} {param:10} {pass_mode:20} {ssa:10} {ty:?}", - msg=msg, local=format!("{:?}", local), local_field=local_field, param=param, pass_mode=pass_mode, ssa=format!("{:?}", ssa), ty=ty, + msg = msg, + local = format!("{:?}", local), + local_field = local_field, + param = param, + pass_mode = pass_mode, + ssa = format!("{:?}", ssa), + ty = ty, )); } #[cfg(debug_assertions)] fn add_local_header_comment(fx: &mut FunctionCx) { - fx.add_global_comment(format!("msg loc.idx param pass mode ssa flags ty")); + fx.add_global_comment(format!( + "msg loc.idx param pass mode ssa flags ty" + )); } fn local_place<'a, 'tcx: 'a>( @@ -338,7 +349,8 @@ fn local_place<'a, 'tcx: 'a>( is_ssa: bool, ) -> CPlace<'tcx> { let place = if is_ssa { - fx.bcx.declare_var(mir_var(local), fx.clif_type(layout.ty).unwrap()); + fx.bcx + .declare_var(mir_var(local), fx.clif_type(layout.ty).unwrap()); CPlace::Var(local, layout) } else { let place = CPlace::new_stack_slot(fx, layout.ty); @@ -346,15 +358,32 @@ fn local_place<'a, 'tcx: 'a>( #[cfg(debug_assertions)] { let TyLayout { ty, details } = layout; - let ty::layout::LayoutDetails { size, align, abi: _, variants: _, fields: _ } = details; + let ty::layout::LayoutDetails { + size, + align, + abi: _, + variants: _, + fields: _, + } = details; match place { - CPlace::Stack(stack_slot, _) => fx.add_entity_comment(stack_slot, format!( - "{:?}: {:?} size={} align={},{}", - local, ty, size.bytes(), align.abi.bytes(), align.pref.bytes(), - )), + CPlace::Stack(stack_slot, _) => fx.add_entity_comment( + stack_slot, + format!( + "{:?}: {:?} size={} align={},{}", + local, + ty, + size.bytes(), + align.abi.bytes(), + align.pref.bytes(), + ), + ), CPlace::NoPlace(_) => fx.add_global_comment(format!( "zst {:?}: {:?} size={} align={}, {}", - local, ty, size.bytes(), align.abi.bytes(), align.pref.bytes(), + local, + ty, + size.bytes(), + align.abi.bytes(), + align.pref.bytes(), )), _ => unreachable!(), } @@ -383,7 +412,16 @@ fn cvalue_for_param<'a, 'tcx: 'a>( let ebb_param = fx.bcx.append_ebb_param(start_ebb, clif_type); #[cfg(debug_assertions)] - add_arg_comment(fx, "arg", local, local_field, Some(ebb_param), pass_mode, ssa_flags, arg_ty); + add_arg_comment( + fx, + "arg", + local, + local_field, + Some(ebb_param), + pass_mode, + ssa_flags, + arg_ty, + ); match pass_mode { PassMode::NoPass => unimplemented!("pass mode nopass"), @@ -412,7 +450,16 @@ pub fn codegen_fn_prelude<'a, 'tcx: 'a>( #[cfg(debug_assertions)] { add_local_header_comment(fx); - add_arg_comment(fx, "ret", RETURN_PLACE, None, ret_param, output_pass_mode, ssa_analyzed[&RETURN_PLACE], ret_layout.ty); + add_arg_comment( + fx, + "ret", + RETURN_PLACE, + None, + ret_param, + output_pass_mode, + ssa_analyzed[&RETURN_PLACE], + ret_layout.ty, + ); } enum ArgKind<'tcx> { @@ -440,18 +487,22 @@ pub fn codegen_fn_prelude<'a, 'tcx: 'a>( let mut params = Vec::new(); for (i, arg_ty) in tupled_arg_tys.iter().enumerate() { - let param = cvalue_for_param(fx, start_ebb, local, Some(i), arg_ty, ssa_analyzed[&local]); + let param = cvalue_for_param( + fx, + start_ebb, + local, + Some(i), + arg_ty, + ssa_analyzed[&local], + ); params.push(param); } (local, ArgKind::Spread(params), arg_ty) } else { - let param = cvalue_for_param(fx, start_ebb, local, None, arg_ty, ssa_analyzed[&local]); - ( - local, - ArgKind::Normal(param), - arg_ty, - ) + let param = + cvalue_for_param(fx, start_ebb, local, None, arg_ty, ssa_analyzed[&local]); + (local, ArgKind::Normal(param), arg_ty) } }) .collect::>(); @@ -460,7 +511,8 @@ pub fn codegen_fn_prelude<'a, 'tcx: 'a>( match output_pass_mode { PassMode::NoPass => { - fx.local_map.insert(RETURN_PLACE, CPlace::NoPlace(ret_layout)); + fx.local_map + .insert(RETURN_PLACE, CPlace::NoPlace(ret_layout)); } PassMode::ByVal(_) => { let is_ssa = !ssa_analyzed @@ -494,7 +546,9 @@ pub fn codegen_fn_prelude<'a, 'tcx: 'a>( } ArgKind::Spread(params) => { for (i, param) in params.into_iter().enumerate() { - place.place_field(fx, mir::Field::new(i)).write_cvalue(fx, param); + place + .place_field(fx, mir::Field::new(i)) + .write_cvalue(fx, param); } } } @@ -553,12 +607,8 @@ pub fn codegen_terminator_call<'a, 'tcx: 'a>( .map(|&(ref place, bb)| (trans_place(fx, place), bb)); if let ty::FnDef(def_id, substs) = fn_ty.sty { - let instance = ty::Instance::resolve( - fx.tcx, - ty::ParamEnv::reveal_all(), - def_id, - substs, - ).unwrap(); + let instance = + ty::Instance::resolve(fx.tcx, ty::ParamEnv::reveal_all(), def_id, substs).unwrap(); match instance.def { InstanceDef::Intrinsic(_) => { @@ -637,8 +687,12 @@ pub fn codegen_call_inner<'a, 'tcx: 'a>( // Indirect call None => { - let func = trans_operand(fx, func.expect("indirect call without func Operand")).load_scalar(fx); - (Some(func), args.get(0).map(|arg| adjust_arg_for_abi(fx, *arg))) + let func = trans_operand(fx, func.expect("indirect call without func Operand")) + .load_scalar(fx); + ( + Some(func), + args.get(0).map(|arg| adjust_arg_for_abi(fx, *arg)), + ) } }; @@ -653,7 +707,9 @@ pub fn codegen_call_inner<'a, 'tcx: 'a>( .collect::>(); let call_inst = if let Some(func_ref) = func_ref { - let sig = fx.bcx.import_signature(clif_sig_from_fn_sig(fx.tcx, fn_sig)); + let sig = fx + .bcx + .import_signature(clif_sig_from_fn_sig(fx.tcx, fn_sig)); fx.bcx.ins().call_indirect(sig, func_ref, &call_args) } else { let func_ref = fx.get_function_ref(instance.expect("non-indirect call on non-FnDef type")); @@ -666,14 +722,17 @@ pub fn codegen_call_inner<'a, 'tcx: 'a>( unimpl!("Variadic call for non-C abi {:?}", fn_sig.abi); } let sig_ref = fx.bcx.func.dfg.call_signature(call_inst).unwrap(); - let abi_params = call_args.into_iter().map(|arg| { - let ty = fx.bcx.func.dfg.value_type(arg); - if !ty.is_int() { - // FIXME set %al to upperbound on float args once floats are supported - unimpl!("Non int ty {:?} for variadic call", ty); - } - AbiParam::new(ty) - }).collect::>(); + let abi_params = call_args + .into_iter() + .map(|arg| { + let ty = fx.bcx.func.dfg.value_type(arg); + if !ty.is_int() { + // FIXME set %al to upperbound on float args once floats are supported + unimpl!("Non int ty {:?} for variadic call", ty); + } + AbiParam::new(ty) + }) + .collect::>(); fx.bcx.func.dfg.signatures[sig_ref].params = abi_params; } @@ -700,11 +759,13 @@ pub fn codegen_drop<'a, 'tcx: 'a>( let fn_sig = ty_fn_sig(fx.tcx, drop_fn_ty); match get_pass_mode(fx.tcx, fn_sig.output(), true) { - PassMode::NoPass => {}, + PassMode::NoPass => {} _ => unreachable!(), }; - let sig = fx.bcx.import_signature(clif_sig_from_fn_sig(fx.tcx, fn_sig)); + let sig = fx + .bcx + .import_signature(clif_sig_from_fn_sig(fx.tcx, fn_sig)); fx.bcx.ins().call_indirect(sig, drop_fn, &[ptr]); } diff --git a/src/allocator.rs b/src/allocator.rs index 1cc45a7d93bb..cfc071612e71 100644 --- a/src/allocator.rs +++ b/src/allocator.rs @@ -15,14 +15,10 @@ use rustc_allocator::{AllocatorTy, ALLOCATOR_METHODS}; /// Returns whether an allocator shim was created pub fn codegen(sess: &Session, module: &mut Module) -> bool { - let any_dynamic_crate = sess - .dependency_formats - .borrow() - .iter() - .any(|(_, list)| { - use rustc::middle::dependency_format::Linkage; - list.iter().any(|&linkage| linkage == Linkage::Dynamic) - }); + let any_dynamic_crate = sess.dependency_formats.borrow().iter().any(|(_, list)| { + use rustc::middle::dependency_format::Linkage; + list.iter().any(|&linkage| linkage == Linkage::Dynamic) + }); if any_dynamic_crate { false } else if let Some(kind) = *sess.allocator_kind.get() { diff --git a/src/base.rs b/src/base.rs index f76b3cd8593d..62b0bf1ac043 100644 --- a/src/base.rs +++ b/src/base.rs @@ -66,16 +66,11 @@ fn trans_fn<'a, 'clif, 'tcx: 'a, B: Backend + 'static>( // Step 2. Declare function let (name, sig) = get_function_name_and_sig(tcx, instance, false); - let func_id = cx.module - .declare_function(&name, linkage, &sig) - .unwrap(); - let mut debug_context = cx.debug_context.as_mut().map(|debug_context| FunctionDebugContext::new( - tcx, - debug_context, - mir, - &name, - &sig, - )); + let func_id = cx.module.declare_function(&name, linkage, &sig).unwrap(); + let mut debug_context = cx + .debug_context + .as_mut() + .map(|debug_context| FunctionDebugContext::new(tcx, debug_context, mir, &name, &sig)); // Step 3. Make FunctionBuilder let mut func = Function::with_name_signature(ExternalName::user(0, 0), sig); @@ -127,12 +122,16 @@ fn trans_fn<'a, 'clif, 'tcx: 'a, B: Backend + 'static>( // Step 9. Define function cx.caches.context.func = func; - cx.module.define_function(func_id, &mut cx.caches.context).unwrap(); + cx.module + .define_function(func_id, &mut cx.caches.context) + .unwrap(); // Step 10. Define debuginfo for function let context = &cx.caches.context; let isa = cx.module.isa(); - debug_context.as_mut().map(|x| x.define(tcx, context, isa, &source_info_set)); + debug_context + .as_mut() + .map(|x| x.define(tcx, context, isa, &source_info_set)); // Step 11. Clear context to make it usable for the next function cx.caches.context.clear(); @@ -444,10 +443,14 @@ fn trans_stmt<'a, 'tcx: 'a>( } Rvalue::Cast(CastKind::ReifyFnPointer, operand, ty) => { let layout = fx.layout_of(ty); - match fx.monomorphize(&operand.ty(&fx.mir.local_decls, fx.tcx)).sty { + match fx + .monomorphize(&operand.ty(&fx.mir.local_decls, fx.tcx)) + .sty + { ty::FnDef(def_id, substs) => { let func_ref = fx.get_function_ref( - Instance::resolve(fx.tcx, ParamEnv::reveal_all(), def_id, substs).unwrap(), + Instance::resolve(fx.tcx, ParamEnv::reveal_all(), def_id, substs) + .unwrap(), ); let func_addr = fx.bcx.ins().func_addr(fx.pointer_type, func_ref); lval.write_cvalue(fx, CValue::ByVal(func_addr, layout)); @@ -570,9 +573,13 @@ fn trans_stmt<'a, 'tcx: 'a>( }; lval.write_cvalue(fx, CValue::ByVal(res, dest_layout)); } - (ty::Adt(adt_def, _substs), ty::Uint(_)) | (ty::Adt(adt_def, _substs), ty::Int(_)) if adt_def.is_enum() => { + (ty::Adt(adt_def, _substs), ty::Uint(_)) + | (ty::Adt(adt_def, _substs), ty::Int(_)) + if adt_def.is_enum() => + { // FIXME avoid forcing to stack - let place = CPlace::Addr(operand.force_stack(fx), None, operand.layout()); + let place = + CPlace::Addr(operand.force_stack(fx), None, operand.layout()); let discr = trans_get_discriminant(fx, place, fx.layout_of(to_ty)); lval.write_cvalue(fx, discr); } @@ -674,9 +681,10 @@ fn codegen_array_len<'a, 'tcx: 'a>( let len = crate::constant::force_eval_const(fx, len).unwrap_usize(fx.tcx) as i64; fx.bcx.ins().iconst(fx.pointer_type, len) } - ty::Slice(_elem_ty) => { - place.to_addr_maybe_unsized(fx).1.expect("Length metadata for slice place") - } + ty::Slice(_elem_ty) => place + .to_addr_maybe_unsized(fx) + .1 + .expect("Length metadata for slice place"), _ => bug!("Rvalue::Len({:?})", place), } } @@ -1012,7 +1020,9 @@ fn trans_ptr_binop<'a, 'tcx: 'a>( ret_ty: Ty<'tcx>, ) -> CValue<'tcx> { let not_fat = match lhs.layout().ty.sty { - ty::RawPtr(TypeAndMut { ty, mutbl: _ }) => ty.is_sized(fx.tcx.at(DUMMY_SP), ParamEnv::reveal_all()), + ty::RawPtr(TypeAndMut { ty, mutbl: _ }) => { + ty.is_sized(fx.tcx.at(DUMMY_SP), ParamEnv::reveal_all()) + } ty::FnPtr(..) => true, _ => bug!("trans_ptr_binop on non ptr"), }; diff --git a/src/common.rs b/src/common.rs index 00d5aab1722a..1faa6a8514c9 100644 --- a/src/common.rs +++ b/src/common.rs @@ -246,7 +246,7 @@ pub enum CPlace<'tcx> { Var(Local, TyLayout<'tcx>), Addr(Value, Option, TyLayout<'tcx>), Stack(StackSlot, TyLayout<'tcx>), - NoPlace(TyLayout<'tcx>) + NoPlace(TyLayout<'tcx>), } impl<'a, 'tcx: 'a> CPlace<'tcx> { @@ -255,11 +255,14 @@ impl<'a, 'tcx: 'a> CPlace<'tcx> { CPlace::Var(_, layout) | CPlace::Addr(_, _, layout) | CPlace::Stack(_, layout) - | CPlace::NoPlace(layout) => layout, + | CPlace::NoPlace(layout) => layout, } } - pub fn new_stack_slot(fx: &mut FunctionCx<'a, 'tcx, impl Backend>, ty: Ty<'tcx>) -> CPlace<'tcx> { + pub fn new_stack_slot( + fx: &mut FunctionCx<'a, 'tcx, impl Backend>, + ty: Ty<'tcx>, + ) -> CPlace<'tcx> { let layout = fx.layout_of(ty); assert!(!layout.is_unsized()); if layout.size.bytes() == 0 { @@ -281,12 +284,16 @@ impl<'a, 'tcx: 'a> CPlace<'tcx> { assert!(extra.is_none(), "unsized values are not yet supported"); CValue::ByRef(addr, layout) } - CPlace::Stack(stack_slot, layout) => { - CValue::ByRef(fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, 0), layout) - } - CPlace::NoPlace(layout) => { - CValue::ByRef(fx.bcx.ins().iconst(fx.pointer_type, fx.pointer_type.bytes() as i64), layout) - } + CPlace::Stack(stack_slot, layout) => CValue::ByRef( + fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, 0), + layout, + ), + CPlace::NoPlace(layout) => CValue::ByRef( + fx.bcx + .ins() + .iconst(fx.pointer_type, fx.pointer_type.bytes() as i64), + layout, + ), } } @@ -303,9 +310,10 @@ impl<'a, 'tcx: 'a> CPlace<'tcx> { ) -> (Value, Option) { match self { CPlace::Addr(addr, extra, _layout) => (addr, extra), - CPlace::Stack(stack_slot, _layout) => { - (fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, 0), None) - } + CPlace::Stack(stack_slot, _layout) => ( + fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, 0), + None, + ), CPlace::NoPlace(_) => (fx.bcx.ins().iconst(fx.pointer_type, 45), None), CPlace::Var(_, _) => bug!("Expected CPlace::Addr, found CPlace::Var"), } @@ -364,9 +372,10 @@ impl<'a, 'tcx: 'a> CPlace<'tcx> { return; } CPlace::Addr(addr, None, dst_layout) => (addr, dst_layout), - CPlace::Stack(stack_slot, dst_layout) => { - (fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, 0), dst_layout) - } + CPlace::Stack(stack_slot, dst_layout) => ( + fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, 0), + dst_layout, + ), CPlace::NoPlace(layout) => { assert!(layout.size.bytes() == 0); assert!(from.layout().size.bytes() == 0); @@ -389,7 +398,14 @@ impl<'a, 'tcx: 'a> CPlace<'tcx> { let size = dst_layout.size.bytes(); let src_align = src_layout.align.abi.bytes() as u8; let dst_align = dst_layout.align.abi.bytes() as u8; - fx.bcx.emit_small_memcpy(fx.module.target_config(), addr, from, size, dst_align, src_align); + fx.bcx.emit_small_memcpy( + fx.module.target_config(), + addr, + from, + size, + dst_align, + src_align, + ); } } } @@ -419,10 +435,7 @@ impl<'a, 'tcx: 'a> CPlace<'tcx> { ) -> CPlace<'tcx> { let (elem_layout, addr) = match self.layout().ty.sty { ty::Array(elem_ty, _) => (fx.layout_of(elem_ty), self.to_addr(fx)), - ty::Slice(elem_ty) => ( - fx.layout_of(elem_ty), - self.to_addr_maybe_unsized(fx).0, - ), + ty::Slice(elem_ty) => (fx.layout_of(elem_ty), self.to_addr_maybe_unsized(fx).0), _ => bug!("place_index({:?})", self.layout().ty), }; @@ -472,9 +485,7 @@ impl<'a, 'tcx: 'a> CPlace<'tcx> { match dest.layout().abi { Abi::ScalarPair(ref a, _) => { let dest_addr = dest.to_addr(fx); - fx.bcx - .ins() - .store(MemFlags::new(), value, dest_addr, 0); + fx.bcx.ins().store(MemFlags::new(), value, dest_addr, 0); fx.bcx.ins().store( MemFlags::new(), extra.expect("unsized type without metadata"), @@ -494,12 +505,8 @@ impl<'a, 'tcx: 'a> CPlace<'tcx> { assert!(!self.layout().is_unsized()); match self { CPlace::Var(var, _) => CPlace::Var(var, layout), - CPlace::Addr(addr, extra, _) => { - CPlace::Addr(addr, extra, layout) - } - CPlace::Stack(stack_slot, _) => { - CPlace::Stack(stack_slot, layout) - } + CPlace::Addr(addr, extra, _) => CPlace::Addr(addr, extra, layout), + CPlace::Stack(stack_slot, _) => CPlace::Stack(stack_slot, layout), CPlace::NoPlace(_) => { assert!(layout.size.bytes() == 0); CPlace::NoPlace(layout) diff --git a/src/constant.rs b/src/constant.rs index 29c5a0f38e45..0216eb80a53f 100644 --- a/src/constant.rs +++ b/src/constant.rs @@ -5,7 +5,8 @@ use rustc::mir::interpret::{ }; use rustc::ty::{Const, LazyConst}; use rustc_mir::interpret::{ - EvalContext, MPlaceTy, Machine, Memory, MemoryKind, OpTy, PlaceTy, Pointer, StackPopCleanup, ImmTy, + EvalContext, ImmTy, MPlaceTy, Machine, Memory, MemoryKind, OpTy, PlaceTy, Pointer, + StackPopCleanup, }; use cranelift_module::*; @@ -110,12 +111,12 @@ fn trans_const_value<'a, 'tcx: 'a>( let bits = const_.val.try_to_bits(layout.size).unwrap(); CValue::const_val(fx, ty, bits as i128 as i64) } - ty::FnDef(_def_id, _substs) => { - CValue::ByRef( - fx.bcx.ins().iconst(fx.pointer_type, fx.pointer_type.bytes() as i64), - layout - ) - } + ty::FnDef(_def_id, _substs) => CValue::ByRef( + fx.bcx + .ins() + .iconst(fx.pointer_type, fx.pointer_type.bytes() as i64), + layout, + ), _ => trans_const_place(fx, const_).to_cvalue(fx), } } @@ -370,7 +371,7 @@ impl<'a, 'mir, 'tcx> Machine<'a, 'mir, 'tcx> for TransPlaceInterpreter { ptr } - fn stack_push(_: &mut EvalContext<'a, 'mir, 'tcx, Self>) -> EvalResult<'tcx>{ + fn stack_push(_: &mut EvalContext<'a, 'mir, 'tcx, Self>) -> EvalResult<'tcx> { Ok(()) } diff --git a/src/debuginfo.rs b/src/debuginfo.rs index bb350cc988af..35b8369d8a5c 100644 --- a/src/debuginfo.rs +++ b/src/debuginfo.rs @@ -5,11 +5,10 @@ use std::marker::PhantomData; use syntax::source_map::FileName; use gimli::write::{ - Address, AttributeValue, DwarfUnit, EndianVec, LineProgram, Range, - RangeList, Result, SectionId, UnitEntryId, - Writer, FileId, LineStringTable, LineString, Sections, + Address, AttributeValue, DwarfUnit, EndianVec, FileId, LineProgram, LineString, + LineStringTable, Range, RangeList, Result, SectionId, Sections, UnitEntryId, Writer, }; -use gimli::{Encoding, Format, RunTimeEndian, LineEncoding}; +use gimli::{Encoding, Format, LineEncoding, RunTimeEndian}; use faerie::*; @@ -22,28 +21,35 @@ fn target_endian(tcx: TyCtxt) -> RunTimeEndian { } } -fn line_program_add_file(line_program: &mut LineProgram, line_strings: &mut LineStringTable, file: &FileName) -> FileId { +fn line_program_add_file( + line_program: &mut LineProgram, + line_strings: &mut LineStringTable, + file: &FileName, +) -> FileId { match file { FileName::Real(path) => { - let dir_name = LineString::new(path.parent().unwrap().to_str().unwrap().as_bytes(), line_program.encoding(), line_strings); - let dir_id = - line_program.add_directory(dir_name); - let file_name = LineString::new(path.file_name().unwrap().to_str().unwrap().as_bytes(), line_program.encoding(), line_strings); - line_program.add_file( - file_name, - dir_id, - None, - ) + let dir_name = LineString::new( + path.parent().unwrap().to_str().unwrap().as_bytes(), + line_program.encoding(), + line_strings, + ); + let dir_id = line_program.add_directory(dir_name); + let file_name = LineString::new( + path.file_name().unwrap().to_str().unwrap().as_bytes(), + line_program.encoding(), + line_strings, + ); + line_program.add_file(file_name, dir_id, None) } // FIXME give more appropriate file names _ => { let dir_id = line_program.default_directory(); - let dummy_file_name = LineString::new(file.to_string().into_bytes(), line_program.encoding(), line_strings); - line_program.add_file( - dummy_file_name, - dir_id, - None, - ) + let dummy_file_name = LineString::new( + file.to_string().into_bytes(), + line_program.encoding(), + line_strings, + ); + line_program.add_file(dummy_file_name, dir_id, None) } } } @@ -133,7 +139,7 @@ impl<'a, 'tcx: 'a> DebugContext<'tcx> { ); } - DebugContext { + DebugContext { endian: target_endian(tcx), symbols: indexmap::IndexSet::new(), @@ -155,7 +161,10 @@ impl<'a, 'tcx: 'a> DebugContext<'tcx> { let entry = self.dwarf.unit.get_mut(entry_id); - entry.set(gimli::DW_AT_decl_file, AttributeValue::FileIndex(Some(file_id))); + entry.set( + gimli::DW_AT_decl_file, + AttributeValue::FileIndex(Some(file_id)), + ); entry.set( gimli::DW_AT_decl_line, AttributeValue::Udata(loc.line as u64), @@ -182,11 +191,7 @@ impl<'a, 'tcx: 'a> DebugContext<'tcx> { let _: Result<()> = sections.for_each_mut(|id, section| { if !section.writer.slice().is_empty() { artifact - .declare_with( - id.name(), - Decl::DebugSection, - section.writer.take(), - ) + .declare_with(id.name(), Decl::DebugSection, section.writer.take()) .unwrap(); } Ok(()) @@ -233,7 +238,10 @@ impl<'a, 'b, 'tcx: 'b> FunctionDebugContext<'a, 'tcx> { // FIXME: add to appropriate scope intead of root let scope = debug_context.dwarf.unit.root(); - let entry_id = debug_context.dwarf.unit.add(scope, gimli::DW_TAG_subprogram); + let entry_id = debug_context + .dwarf + .unit + .add(scope, gimli::DW_TAG_subprogram); let entry = debug_context.dwarf.unit.get_mut(entry_id); let name_id = debug_context.dwarf.strings.add(name); entry.set( @@ -314,13 +322,16 @@ impl<'a, 'b, 'tcx: 'b> FunctionDebugContext<'a, 'tcx> { let entry = self.debug_context.dwarf.unit.get_mut(self.entry_id); entry.set(gimli::DW_AT_high_pc, AttributeValue::Udata(end as u64)); - self.debug_context.unit_range_list.0.push(Range::StartLength { - begin: Address::Relative { - symbol: self.symbol, - addend: 0, - }, - length: end as u64, - }); + self.debug_context + .unit_range_list + .0 + .push(Range::StartLength { + begin: Address::Relative { + symbol: self.symbol, + addend: 0, + }, + length: end as u64, + }); } } @@ -331,7 +342,7 @@ struct WriterRelocate { } impl WriterRelocate { - fn new(ctx: & DebugContext) -> Self { + fn new(ctx: &DebugContext) -> Self { WriterRelocate { relocs: Vec::new(), writer: EndianVec::new(ctx.endian), diff --git a/src/lib.rs b/src/lib.rs index ead24921652d..483bcb51c646 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -14,19 +14,19 @@ extern crate rustc_target; extern crate syntax; use std::any::Any; -use std::fs::File; -use std::sync::mpsc; -use std::os::raw::{c_char, c_int}; use std::ffi::CString; +use std::fs::File; +use std::os::raw::{c_char, c_int}; +use std::sync::mpsc; use rustc::dep_graph::DepGraph; use rustc::middle::cstore::MetadataLoader; +use rustc::mir::mono::{Linkage as RLinkage, Visibility}; use rustc::session::{ config::{DebugInfo, OutputFilenames, OutputType}, CompileIncomplete, }; use rustc::ty::query::Providers; -use rustc::mir::mono::{Linkage as RLinkage, Visibility}; use rustc_codegen_ssa::back::linker::LinkerInfo; use rustc_codegen_ssa::CrateInfo; use rustc_codegen_utils::codegen_backend::CodegenBackend; @@ -62,7 +62,7 @@ mod prelude { pub use std::collections::{HashMap, HashSet}; pub use syntax::ast::{FloatTy, IntTy, UintTy}; - pub use syntax::source_map::{DUMMY_SP, Span, Pos}; + pub use syntax::source_map::{Pos, Span, DUMMY_SP}; pub use rustc::bug; pub use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; @@ -84,18 +84,17 @@ mod prelude { pub use rustc_mir::monomorphize::{collector, MonoItem}; pub use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue}; - pub use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleKind}; pub use rustc_codegen_ssa::traits::*; + pub use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleKind}; pub use cranelift::codegen::ir::{ - condcodes::IntCC, function::Function, ExternalName, FuncRef, Inst, StackSlot, SourceLoc, + condcodes::IntCC, function::Function, ExternalName, FuncRef, Inst, SourceLoc, StackSlot, }; pub use cranelift::codegen::isa::CallConv; pub use cranelift::codegen::Context; pub use cranelift::prelude::*; pub use cranelift_module::{ - self, Backend, DataContext, DataId, FuncId, FuncOrDataId, Linkage, - Module, + self, Backend, DataContext, DataId, FuncId, FuncOrDataId, Linkage, Module, }; pub use cranelift_simplejit::{SimpleJITBackend, SimpleJITBuilder}; @@ -251,11 +250,12 @@ impl CodegenBackend for CraneliftCodegenBackend { let f: extern "C" fn(c_int, *const *const c_char) -> c_int = unsafe { ::std::mem::transmute(finalized_main) }; - let args = ::std::env::var("JIT_ARGS").unwrap_or_else(|_|String::new()); + let args = ::std::env::var("JIT_ARGS").unwrap_or_else(|_| String::new()); let args = args .split(" ") .chain(Some(&*tcx.crate_name(LOCAL_CRATE).as_str().to_string())) - .map(|arg| CString::new(arg).unwrap()).collect::>(); + .map(|arg| CString::new(arg).unwrap()) + .collect::>(); let argv = args.iter().map(|arg| arg.as_ptr()).collect::>(); // TODO: Rust doesn't care, but POSIX argv has a NULL sentinel at the end @@ -274,14 +274,14 @@ impl CodegenBackend for CraneliftCodegenBackend { ) .unwrap(), ); - assert_eq!( - pointer_ty(tcx), - module.target_config().pointer_type() - ); + assert_eq!(pointer_ty(tcx), module.target_config().pointer_type()); module }; - let emit_module = |name: &str, kind: ModuleKind, mut module: Module, debug: Option| { + let emit_module = |name: &str, + kind: ModuleKind, + mut module: Module, + debug: Option| { module.finalize_definitions(); let mut artifact = module.finish().artifact; @@ -306,9 +306,13 @@ impl CodegenBackend for CraneliftCodegenBackend { let mut faerie_module = new_module("some_file".to_string()); let mut debug = if tcx.sess.opts.debuginfo != DebugInfo::None - && !tcx.sess.target.target.options.is_like_osx // macOS debuginfo doesn't work yet (see #303) + // macOS debuginfo doesn't work yet (see #303) + && !tcx.sess.target.target.options.is_like_osx { - let debug = DebugContext::new(tcx, faerie_module.target_config().pointer_type().bytes() as u8); + let debug = DebugContext::new( + tcx, + faerie_module.target_config().pointer_type().bytes() as u8, + ); Some(debug) } else { None @@ -319,14 +323,23 @@ impl CodegenBackend for CraneliftCodegenBackend { tcx.sess.abort_if_errors(); let mut allocator_module = new_module("allocator_shim.o".to_string()); - let created_alloc_shim = - crate::allocator::codegen(tcx.sess, &mut allocator_module); + let created_alloc_shim = crate::allocator::codegen(tcx.sess, &mut allocator_module); return Box::new(CodegenResults { crate_name: tcx.crate_name(LOCAL_CRATE), - modules: vec![emit_module("dummy_name", ModuleKind::Regular, faerie_module, debug)], + modules: vec![emit_module( + "dummy_name", + ModuleKind::Regular, + faerie_module, + debug, + )], allocator_module: if created_alloc_shim { - Some(emit_module("allocator_shim", ModuleKind::Allocator, allocator_module, None)) + Some(emit_module( + "allocator_shim", + ModuleKind::Allocator, + allocator_module, + None, + )) } else { None }, @@ -377,7 +390,7 @@ fn build_isa(sess: &Session) -> Box { let mut flags_builder = settings::builder(); flags_builder.enable("is_pic").unwrap(); flags_builder.set("probestack_enabled", "false").unwrap(); // ___cranelift_probestack is not provided - flags_builder.set("enable_verifier", if cfg!(debug_assertions) { + flags_builder.set("enable_verifier", if cfg!(debug_assertions) { "true" } else { "false" @@ -438,7 +451,7 @@ fn codegen_mono_items<'a, 'tcx: 'a>( (RLinkage::Internal, Visibility::Default) => Linkage::Local, // FIXME this should get external linkage, but hidden visibility, // not internal linkage and default visibility - | (RLinkage::External, Visibility::Hidden) => Linkage::Export, + (RLinkage::External, Visibility::Hidden) => Linkage::Export, _ => panic!("{:?} = {:?} {:?}", mono_item, linkage, vis), }; base::trans_mono_item(&mut cx, mono_item, linkage); diff --git a/src/pretty_clif.rs b/src/pretty_clif.rs index a7a9c7a3306b..aab6e341a09a 100644 --- a/src/pretty_clif.rs +++ b/src/pretty_clif.rs @@ -70,10 +70,7 @@ pub struct CommentWriter { } impl CommentWriter { - pub fn new<'a, 'tcx: 'a>( - tcx: TyCtxt<'a, 'tcx, 'tcx>, - instance: Instance<'tcx>, - ) -> Self { + pub fn new<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: Instance<'tcx>) -> Self { CommentWriter { global_comments: vec![ format!("symbol {}", tcx.symbol_name(instance).as_str()), @@ -158,7 +155,11 @@ impl<'a, 'tcx: 'a, B: Backend + 'a> FunctionCx<'a, 'tcx, B> { self.clif_comments.global_comments.push(comment.into()); } - pub fn add_entity_comment<'s, S: Into>, E: Into>(&mut self, entity: E, comment: S) { + pub fn add_entity_comment<'s, S: Into>, E: Into>( + &mut self, + entity: E, + comment: S, + ) { use std::collections::hash_map::Entry; match self.clif_comments.entity_comments.entry(entity.into()) { Entry::Occupied(mut occ) => { @@ -196,12 +197,18 @@ impl<'a, 'tcx: 'a, B: Backend + 'a> FunctionCx<'a, 'tcx, B> { ); let mut clif = String::new(); - ::cranelift::codegen::write::decorate_function(&mut &self.clif_comments, &mut clif, &self.bcx.func, None) - .unwrap(); + ::cranelift::codegen::write::decorate_function( + &mut &self.clif_comments, + &mut clif, + &self.bcx.func, + None, + ) + .unwrap(); match ::std::fs::File::create(clif_file_name) { Ok(mut file) => { - let target_triple: ::target_lexicon::Triple = self.tcx.sess.target.target.llvm_target.parse().unwrap(); + let target_triple: ::target_lexicon::Triple = + self.tcx.sess.target.target.llvm_target.parse().unwrap(); writeln!(file, "test compile").unwrap(); writeln!(file, "set is_pic").unwrap(); writeln!(file, "target {}", target_triple).unwrap(); @@ -209,7 +216,9 @@ impl<'a, 'tcx: 'a, B: Backend + 'a> FunctionCx<'a, 'tcx, B> { file.write(clif.as_bytes()).unwrap(); } Err(e) => { - self.tcx.sess.warn(&format!("err opening clif file: {:?}", e)); + self.tcx + .sess + .warn(&format!("err opening clif file: {:?}", e)); } } } diff --git a/src/unsize.rs b/src/unsize.rs index 6837754a5524..09dead7e85e8 100644 --- a/src/unsize.rs +++ b/src/unsize.rs @@ -16,21 +16,22 @@ pub fn unsized_info<'a, 'tcx: 'a>( ) -> Value { let (source, target) = fx.tcx.struct_lockstep_tails(source, target); match (&source.sty, &target.sty) { - (&ty::Array(_, len), &ty::Slice(_)) => { - fx.bcx.ins().iconst(fx.pointer_type, len.unwrap_usize(fx.tcx) as i64) - } + (&ty::Array(_, len), &ty::Slice(_)) => fx + .bcx + .ins() + .iconst(fx.pointer_type, len.unwrap_usize(fx.tcx) as i64), (&ty::Dynamic(..), &ty::Dynamic(..)) => { // For now, upcasts are limited to changes in marker // traits, and hence never actually require an actual // change to the vtable. old_info.expect("unsized_info: missing old info for trait upcast") } - (_, &ty::Dynamic(ref data, ..)) => { - crate::vtable::get_vtable(fx, source, data.principal()) - } - _ => bug!("unsized_info: invalid unsizing {:?} -> {:?}", - source, - target), + (_, &ty::Dynamic(ref data, ..)) => crate::vtable::get_vtable(fx, source, data.principal()), + _ => bug!( + "unsized_info: invalid unsizing {:?} -> {:?}", + source, + target + ), } } @@ -39,15 +40,12 @@ pub fn unsize_thin_ptr<'a, 'tcx: 'a>( fx: &mut FunctionCx<'a, 'tcx, impl Backend>, src: Value, src_ty: Ty<'tcx>, - dst_ty: Ty<'tcx> + dst_ty: Ty<'tcx>, ) -> (Value, Value) { match (&src_ty.sty, &dst_ty.sty) { - (&ty::Ref(_, a, _), - &ty::Ref(_, b, _)) | - (&ty::Ref(_, a, _), - &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) | - (&ty::RawPtr(ty::TypeAndMut { ty: a, .. }), - &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) => { + (&ty::Ref(_, a, _), &ty::Ref(_, b, _)) + | (&ty::Ref(_, a, _), &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) + | (&ty::RawPtr(ty::TypeAndMut { ty: a, .. }), &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) => { assert!(!fx.layout_of(a).is_unsized()); (src, unsized_info(fx, a, b, None)) } @@ -88,11 +86,14 @@ pub fn coerce_unsized_into<'a, 'tcx: 'a>( fx: &mut FunctionCx<'a, 'tcx, impl Backend>, src: CValue<'tcx>, dst: CPlace<'tcx>, -) { +) { let src_ty = src.layout().ty; let dst_ty = dst.layout().ty; let mut coerce_ptr = || { - let (base, info) = if fx.layout_of(src.layout().ty.builtin_deref(true).unwrap().ty).is_unsized() { + let (base, info) = if fx + .layout_of(src.layout().ty.builtin_deref(true).unwrap().ty) + .is_unsized() + { // fat-ptr to fat-ptr unsize preserves the vtable // i.e., &'a fmt::Debug+Send => &'a fmt::Debug src.load_value_pair(fx) @@ -103,11 +104,9 @@ pub fn coerce_unsized_into<'a, 'tcx: 'a>( dst.write_cvalue(fx, CValue::ByValPair(base, info, dst.layout())); }; match (&src_ty.sty, &dst_ty.sty) { - (&ty::Ref(..), &ty::Ref(..)) | - (&ty::Ref(..), &ty::RawPtr(..)) | - (&ty::RawPtr(..), &ty::RawPtr(..)) => { - coerce_ptr() - } + (&ty::Ref(..), &ty::Ref(..)) + | (&ty::Ref(..), &ty::RawPtr(..)) + | (&ty::RawPtr(..), &ty::RawPtr(..)) => coerce_ptr(), (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => { assert_eq!(def_a, def_b); @@ -126,13 +125,14 @@ pub fn coerce_unsized_into<'a, 'tcx: 'a>( } } } - _ => bug!("coerce_unsized_into: invalid coercion {:?} -> {:?}", - src_ty, - dst_ty), + _ => bug!( + "coerce_unsized_into: invalid coercion {:?} -> {:?}", + src_ty, + dst_ty + ), } } - // Adapted from https://github.com/rust-lang/rust/blob/2a663555ddf36f6b041445894a8c175cd1bc718c/src/librustc_codegen_ssa/glue.rs pub fn size_and_align_of_dst<'a, 'tcx: 'a>( @@ -142,8 +142,14 @@ pub fn size_and_align_of_dst<'a, 'tcx: 'a>( ) -> (Value, Value) { let layout = fx.layout_of(ty); if !layout.is_unsized() { - let size = fx.bcx.ins().iconst(fx.pointer_type, layout.size.bytes() as i64); - let align = fx.bcx.ins().iconst(fx.pointer_type, layout.align.abi.bytes() as i64); + let size = fx + .bcx + .ins() + .iconst(fx.pointer_type, layout.size.bytes() as i64); + let align = fx + .bcx + .ins() + .iconst(fx.pointer_type, layout.align.abi.bytes() as i64); return (size, align); } match ty.sty { @@ -158,8 +164,12 @@ pub fn size_and_align_of_dst<'a, 'tcx: 'a>( let unit = layout.field(fx, 0); // The info in this case is the length of the str, so the size is that // times the unit size. - (fx.bcx.ins().imul_imm(info, unit.size.bytes() as i64), - fx.bcx.ins().iconst(fx.pointer_type, unit.align.abi.bytes() as i64)) + ( + fx.bcx.ins().imul_imm(info, unit.size.bytes() as i64), + fx.bcx + .ins() + .iconst(fx.pointer_type, unit.align.abi.bytes() as i64), + ) } _ => { // First get the size of all statically known fields. @@ -196,7 +206,10 @@ pub fn size_and_align_of_dst<'a, 'tcx: 'a>( // Choose max of two known alignments (combined value must // be aligned according to more restrictive of the two). - let cmp = fx.bcx.ins().icmp(IntCC::UnsignedGreaterThan, sized_align, unsized_align); + let cmp = fx + .bcx + .ins() + .icmp(IntCC::UnsignedGreaterThan, sized_align, unsized_align); let align = fx.bcx.ins().select(cmp, sized_align, unsized_align); // Issue #27023: must add any necessary padding to `size` @@ -212,7 +225,7 @@ pub fn size_and_align_of_dst<'a, 'tcx: 'a>( let addend = fx.bcx.ins().iadd_imm(align, -1); let add = fx.bcx.ins().iadd(size, addend); let zero = fx.bcx.ins().iconst(fx.pointer_type, 0); - let neg = fx.bcx.ins().isub(zero, align); + let neg = fx.bcx.ins().isub(zero, align); let size = fx.bcx.ins().band(add, neg); (size, align)