abi => abi,
};
let (call_conv, inputs, output): (CallConv, Vec<Ty>, Ty) = match abi {
- Abi::Rust => (CallConv::SystemV, sig.inputs().to_vec(), sig.output()),
- Abi::C => (CallConv::SystemV, sig.inputs().to_vec(), sig.output()),
+ Abi::Rust => (crate::default_call_conv(tcx.sess), sig.inputs().to_vec(), sig.output()),
+ Abi::C => (crate::default_call_conv(tcx.sess), sig.inputs().to_vec(), sig.output()),
Abi::RustCall => {
assert_eq!(sig.inputs().len(), 2);
- let extra_args = match sig.inputs().last().unwrap().sty {
+ let extra_args = match sig.inputs().last().unwrap().kind {
ty::Tuple(ref tupled_arguments) => tupled_arguments,
_ => bug!("argument to function with \"rust-call\" ABI is not a tuple"),
};
let mut inputs: Vec<Ty> = vec![sig.inputs()[0]];
inputs.extend(extra_args.types());
- (CallConv::SystemV, inputs, sig.output())
+ (crate::default_call_conv(tcx.sess), inputs, sig.output())
}
Abi::System => unreachable!(),
- Abi::RustIntrinsic => (CallConv::SystemV, sig.inputs().to_vec(), sig.output()),
+ Abi::RustIntrinsic => (crate::default_call_conv(tcx.sess), sig.inputs().to_vec(), sig.output()),
_ => unimplemented!("unsupported abi {:?}", sig.abi),
};
let sig = Signature {
params: input_tys.iter().cloned().map(AbiParam::new).collect(),
returns: output_tys.iter().cloned().map(AbiParam::new).collect(),
- call_conv: CallConv::SystemV,
+ call_conv: crate::default_call_conv(self.tcx.sess),
};
let func_id = self
.module
})
.unzip();
let return_layout = self.layout_of(return_ty);
- let return_tys = if let ty::Tuple(tup) = return_ty.sty {
+ let return_tys = if let ty::Tuple(tup) = return_ty.kind {
tup.types().map(|ty| self.clif_type(ty).unwrap()).collect()
} else {
vec![self.clif_type(return_ty).unwrap()]
// to reconstruct it into a tuple local variable, from multiple
// individual function arguments.
- let tupled_arg_tys = match arg_ty.sty {
+ let tupled_arg_tys = match arg_ty.kind {
ty::Tuple(ref tys) => tys,
_ => bug!("spread argument isn't a tuple?! but {:?}", arg_ty),
};
for (local, arg_kind, ty) in func_params {
let layout = fx.layout_of(ty);
- let is_ssa = !ssa_analyzed
- .get(&local)
- .unwrap()
- .contains(crate::analyze::Flags::NOT_SSA);
+ let is_ssa = *ssa_analyzed.get(&local).unwrap() == crate::analyze::SsaKind::Ssa;
match arg_kind {
ArgKind::Normal(Some(val)) => {
let ty = fx.mir.local_decls[local].ty;
let layout = fx.layout_of(ty);
- let is_ssa = !ssa_analyzed
- .get(&local)
- .unwrap()
- .contains(crate::analyze::Flags::NOT_SSA);
+ let is_ssa = *ssa_analyzed.get(&local).unwrap() == crate::analyze::SsaKind::Ssa;
local_place(fx, local, layout, is_ssa);
}
func: &Operand<'tcx>,
args: &[Operand<'tcx>],
destination: &Option<(Place<'tcx>, BasicBlock)>,
+ span: Span,
) {
let fn_ty = fx.monomorphize(&func.ty(fx.mir, fx.tcx));
let sig = fx
.as_ref()
.map(|&(ref place, bb)| (trans_place(fx, place), bb));
- if let ty::FnDef(def_id, substs) = fn_ty.sty {
+ if let ty::FnDef(def_id, substs) = fn_ty.kind {
let instance =
ty::Instance::resolve(fx.tcx, ty::ParamEnv::reveal_all(), def_id, substs).unwrap();
match instance.def {
InstanceDef::Intrinsic(_) => {
- crate::intrinsics::codegen_intrinsic_call(fx, def_id, substs, args, destination);
+ crate::intrinsics::codegen_intrinsic_call(fx, instance, args, destination, span);
return;
}
InstanceDef::DropGlue(_, None) => {
let pack_arg = trans_operand(fx, &args[1]);
let mut args = Vec::new();
args.push(self_arg);
- match pack_arg.layout().ty.sty {
+ match pack_arg.layout().ty.kind {
ty::Tuple(ref tupled_arguments) => {
for (i, _) in tupled_arguments.iter().enumerate() {
args.push(pack_arg.value_field(fx, mir::Field::new(i)));
.tcx
.normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), &fn_ty.fn_sig(fx.tcx));
- let instance = match fn_ty.sty {
+ let instance = match fn_ty.kind {
ty::FnDef(def_id, substs) => {
Some(Instance::resolve(fx.tcx, ParamEnv::reveal_all(), def_id, substs).unwrap())
}
// we don't actually need to drop anything
} else {
let drop_fn_ty = drop_fn.ty(fx.tcx);
- match ty.sty {
+ match ty.kind {
ty::Dynamic(..) => {
let (ptr, vtable) = drop_place.to_addr_maybe_unsized(fx);
let drop_fn = crate::vtable::drop_fn_of_obj(fx, vtable.unwrap());