src/abi/mod.rs

   1 //! Handling of everything related to the calling convention. Also fills `fx.local_map`.
   2
   3 mod comments;
   4 mod pass_mode;
   5 mod returning;
   6
   7 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
   8 use rustc_middle::ty::layout::FnAbiExt;
   9 use rustc_target::abi::call::{Conv, FnAbi};
  10 use rustc_target::spec::abi::Abi;
  11
  12 use cranelift_codegen::ir::AbiParam;
  13 use smallvec::smallvec;
  14
  15 use self::pass_mode::*;
  16 use crate::prelude::*;
  17
  18 pub(crate) use self::returning::{can_return_to_ssa_var, codegen_return};
  19
  20 fn clif_sig_from_fn_abi<'tcx>(
  21     tcx: TyCtxt<'tcx>,
  22     triple: &target_lexicon::Triple,
  23     fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
  24 ) -> Signature {
  25     let call_conv = match fn_abi.conv {
  26         Conv::Rust | Conv::C => CallConv::triple_default(triple),
  27         Conv::X86_64SysV => CallConv::SystemV,
  28         Conv::X86_64Win64 => CallConv::WindowsFastcall,
  29         Conv::ArmAapcs
  30         | Conv::CCmseNonSecureCall
  31         | Conv::Msp430Intr
  32         | Conv::PtxKernel
  33         | Conv::X86Fastcall
  34         | Conv::X86Intr
  35         | Conv::X86Stdcall
  36         | Conv::X86ThisCall
  37         | Conv::X86VectorCall
  38         | Conv::AmdGpuKernel
  39         | Conv::AvrInterrupt
  40         | Conv::AvrNonBlockingInterrupt => todo!("{:?}", fn_abi.conv),
  41     };
  42     let inputs = fn_abi.args.iter().map(|arg_abi| arg_abi.get_abi_param(tcx).into_iter()).flatten();
  43
  44     let (return_ptr, returns) = fn_abi.ret.get_abi_return(tcx);
  45     // Sometimes the first param is an pointer to the place where the return value needs to be stored.
  46     let params: Vec<_> = return_ptr.into_iter().chain(inputs).collect();
  47
  48     Signature { params, returns, call_conv }
  49 }
  50
  51 pub(crate) fn get_function_sig<'tcx>(
  52     tcx: TyCtxt<'tcx>,
  53     triple: &target_lexicon::Triple,
  54     inst: Instance<'tcx>,
  55 ) -> Signature {
  56     assert!(!inst.substs.needs_infer());
  57     clif_sig_from_fn_abi(tcx, triple, &FnAbi::of_instance(&RevealAllLayoutCx(tcx), inst, &[]))
  58 }
  59
  60 /// Instance must be monomorphized
  61 pub(crate) fn import_function<'tcx>(
  62     tcx: TyCtxt<'tcx>,
  63     module: &mut dyn Module,
  64     inst: Instance<'tcx>,
  65 ) -> FuncId {
  66     let name = tcx.symbol_name(inst).name.to_string();
  67     let sig = get_function_sig(tcx, module.isa().triple(), inst);
  68     module.declare_function(&name, Linkage::Import, &sig).unwrap()
  69 }
  70
  71 impl<'tcx> FunctionCx<'_, '_, 'tcx> {
  72     /// Instance must be monomorphized
  73     pub(crate) fn get_function_ref(&mut self, inst: Instance<'tcx>) -> FuncRef {
  74         let func_id = import_function(self.tcx, self.module, inst);
  75         let func_ref = self.module.declare_func_in_func(func_id, &mut self.bcx.func);
  76
  77         if self.clif_comments.enabled() {
  78             self.add_comment(func_ref, format!("{:?}", inst));
  79         }
  80
  81         func_ref
  82     }
  83
  84     pub(crate) fn lib_call(
  85         &mut self,
  86         name: &str,
  87         params: Vec<AbiParam>,
  88         returns: Vec<AbiParam>,
  89         args: &[Value],
  90     ) -> &[Value] {
  91         let sig = Signature { params, returns, call_conv: CallConv::triple_default(self.triple()) };
  92         let func_id = self.module.declare_function(&name, Linkage::Import, &sig).unwrap();
  93         let func_ref = self.module.declare_func_in_func(func_id, &mut self.bcx.func);
  94         let call_inst = self.bcx.ins().call(func_ref, args);
  95         if self.clif_comments.enabled() {
  96             self.add_comment(call_inst, format!("easy_call {}", name));
  97         }
  98         let results = self.bcx.inst_results(call_inst);
  99         assert!(results.len() <= 2, "{}", results.len());
 100         results
 101     }
 102
 103     pub(crate) fn easy_call(
 104         &mut self,
 105         name: &str,
 106         args: &[CValue<'tcx>],
 107         return_ty: Ty<'tcx>,
 108     ) -> CValue<'tcx> {
 109         let (input_tys, args): (Vec<_>, Vec<_>) = args
 110             .iter()
 111             .map(|arg| {
 112                 (AbiParam::new(self.clif_type(arg.layout().ty).unwrap()), arg.load_scalar(self))
 113             })
 114             .unzip();
 115         let return_layout = self.layout_of(return_ty);
 116         let return_tys = if let ty::Tuple(tup) = return_ty.kind() {
 117             tup.types().map(|ty| AbiParam::new(self.clif_type(ty).unwrap())).collect()
 118         } else {
 119             vec![AbiParam::new(self.clif_type(return_ty).unwrap())]
 120         };
 121         let ret_vals = self.lib_call(name, input_tys, return_tys, &args);
 122         match *ret_vals {
 123             [] => CValue::by_ref(
 124                 Pointer::const_addr(self, i64::from(self.pointer_type.bytes())),
 125                 return_layout,
 126             ),
 127             [val] => CValue::by_val(val, return_layout),
 128             [val, extra] => CValue::by_val_pair(val, extra, return_layout),
 129             _ => unreachable!(),
 130         }
 131     }
 132 }
 133
 134 /// Make a [`CPlace`] capable of holding value of the specified type.
 135 fn make_local_place<'tcx>(
 136     fx: &mut FunctionCx<'_, '_, 'tcx>,
 137     local: Local,
 138     layout: TyAndLayout<'tcx>,
 139     is_ssa: bool,
 140 ) -> CPlace<'tcx> {
 141     let place = if is_ssa {
 142         if let rustc_target::abi::Abi::ScalarPair(_, _) = layout.abi {
 143             CPlace::new_var_pair(fx, local, layout)
 144         } else {
 145             CPlace::new_var(fx, local, layout)
 146         }
 147     } else {
 148         CPlace::new_stack_slot(fx, layout)
 149     };
 150
 151     self::comments::add_local_place_comments(fx, place, local);
 152
 153     place
 154 }
 155
 156 pub(crate) fn codegen_fn_prelude<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, start_block: Block) {
 157     fx.bcx.append_block_params_for_function_params(start_block);
 158
 159     fx.bcx.switch_to_block(start_block);
 160     fx.bcx.ins().nop();
 161
 162     let ssa_analyzed = crate::analyze::analyze(fx);
 163
 164     self::comments::add_args_header_comment(fx);
 165
 166     let mut block_params_iter = fx.bcx.func.dfg.block_params(start_block).to_vec().into_iter();
 167     let ret_place =
 168         self::returning::codegen_return_param(fx, &ssa_analyzed, &mut block_params_iter);
 169     assert_eq!(fx.local_map.push(ret_place), RETURN_PLACE);
 170
 171     // None means pass_mode == NoPass
 172     enum ArgKind<'tcx> {
 173         Normal(Option<CValue<'tcx>>),
 174         Spread(Vec<Option<CValue<'tcx>>>),
 175     }
 176
 177     let fn_abi = fx.fn_abi.take().unwrap();
 178     let mut arg_abis_iter = fn_abi.args.iter();
 179
 180     let func_params = fx
 181         .mir
 182         .args_iter()
 183         .map(|local| {
 184             let arg_ty = fx.monomorphize(fx.mir.local_decls[local].ty);
 185
 186             // Adapted from https://github.com/rust-lang/rust/blob/145155dc96757002c7b2e9de8489416e2fdbbd57/src/librustc_codegen_llvm/mir/mod.rs#L442-L482
 187             if Some(local) == fx.mir.spread_arg {
 188                 // This argument (e.g. the last argument in the "rust-call" ABI)
 189                 // is a tuple that was spread at the ABI level and now we have
 190                 // to reconstruct it into a tuple local variable, from multiple
 191                 // individual function arguments.
 192
 193                 let tupled_arg_tys = match arg_ty.kind() {
 194                     ty::Tuple(ref tys) => tys,
 195                     _ => bug!("spread argument isn't a tuple?! but {:?}", arg_ty),
 196                 };
 197
 198                 let mut params = Vec::new();
 199                 for (i, _arg_ty) in tupled_arg_tys.types().enumerate() {
 200                     let arg_abi = arg_abis_iter.next().unwrap();
 201                     let param =
 202                         cvalue_for_param(fx, Some(local), Some(i), arg_abi, &mut block_params_iter);
 203                     params.push(param);
 204                 }
 205
 206                 (local, ArgKind::Spread(params), arg_ty)
 207             } else {
 208                 let arg_abi = arg_abis_iter.next().unwrap();
 209                 let param =
 210                     cvalue_for_param(fx, Some(local), None, arg_abi, &mut block_params_iter);
 211                 (local, ArgKind::Normal(param), arg_ty)
 212             }
 213         })
 214         .collect::<Vec<(Local, ArgKind<'tcx>, Ty<'tcx>)>>();
 215
 216     assert!(fx.caller_location.is_none());
 217     if fx.instance.def.requires_caller_location(fx.tcx) {
 218         // Store caller location for `#[track_caller]`.
 219         let arg_abi = arg_abis_iter.next().unwrap();
 220         fx.caller_location =
 221             Some(cvalue_for_param(fx, None, None, arg_abi, &mut block_params_iter).unwrap());
 222     }
 223
 224     assert!(arg_abis_iter.next().is_none(), "ArgAbi left behind");
 225     fx.fn_abi = Some(fn_abi);
 226     assert!(block_params_iter.next().is_none(), "arg_value left behind");
 227
 228     self::comments::add_locals_header_comment(fx);
 229
 230     for (local, arg_kind, ty) in func_params {
 231         let layout = fx.layout_of(ty);
 232
 233         let is_ssa = ssa_analyzed[local] == crate::analyze::SsaKind::Ssa;
 234
 235         // While this is normally an optimization to prevent an unnecessary copy when an argument is
 236         // not mutated by the current function, this is necessary to support unsized arguments.
 237         if let ArgKind::Normal(Some(val)) = arg_kind {
 238             if let Some((addr, meta)) = val.try_to_ptr() {
 239                 let local_decl = &fx.mir.local_decls[local];
 240                 //                       v this ! is important
 241                 let internally_mutable = !val
 242                     .layout()
 243                     .ty
 244                     .is_freeze(fx.tcx.at(local_decl.source_info.span), ParamEnv::reveal_all());
 245                 if local_decl.mutability == mir::Mutability::Not && !internally_mutable {
 246                     // We wont mutate this argument, so it is fine to borrow the backing storage
 247                     // of this argument, to prevent a copy.
 248
 249                     let place = if let Some(meta) = meta {
 250                         CPlace::for_ptr_with_extra(addr, meta, val.layout())
 251                     } else {
 252                         CPlace::for_ptr(addr, val.layout())
 253                     };
 254
 255                     self::comments::add_local_place_comments(fx, place, local);
 256
 257                     assert_eq!(fx.local_map.push(place), local);
 258                     continue;
 259                 }
 260             }
 261         }
 262
 263         let place = make_local_place(fx, local, layout, is_ssa);
 264         assert_eq!(fx.local_map.push(place), local);
 265
 266         match arg_kind {
 267             ArgKind::Normal(param) => {
 268                 if let Some(param) = param {
 269                     place.write_cvalue(fx, param);
 270                 }
 271             }
 272             ArgKind::Spread(params) => {
 273                 for (i, param) in params.into_iter().enumerate() {
 274                     if let Some(param) = param {
 275                         place.place_field(fx, mir::Field::new(i)).write_cvalue(fx, param);
 276                     }
 277                 }
 278             }
 279         }
 280     }
 281
 282     for local in fx.mir.vars_and_temps_iter() {
 283         let ty = fx.monomorphize(fx.mir.local_decls[local].ty);
 284         let layout = fx.layout_of(ty);
 285
 286         let is_ssa = ssa_analyzed[local] == crate::analyze::SsaKind::Ssa;
 287
 288         let place = make_local_place(fx, local, layout, is_ssa);
 289         assert_eq!(fx.local_map.push(place), local);
 290     }
 291
 292     fx.bcx.ins().jump(*fx.block_map.get(START_BLOCK).unwrap(), &[]);
 293 }
 294
 295 pub(crate) fn codegen_terminator_call<'tcx>(
 296     fx: &mut FunctionCx<'_, '_, 'tcx>,
 297     span: Span,
 298     func: &Operand<'tcx>,
 299     args: &[Operand<'tcx>],
 300     destination: Option<(Place<'tcx>, BasicBlock)>,
 301 ) {
 302     let fn_ty = fx.monomorphize(func.ty(fx.mir, fx.tcx));
 303     let fn_sig =
 304         fx.tcx.normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), fn_ty.fn_sig(fx.tcx));
 305
 306     let destination = destination.map(|(place, bb)| (codegen_place(fx, place), bb));
 307
 308     // Handle special calls like instrinsics and empty drop glue.
 309     let instance = if let ty::FnDef(def_id, substs) = *fn_ty.kind() {
 310         let instance = ty::Instance::resolve(fx.tcx, ty::ParamEnv::reveal_all(), def_id, substs)
 311             .unwrap()
 312             .unwrap()
 313             .polymorphize(fx.tcx);
 314
 315         if fx.tcx.symbol_name(instance).name.starts_with("llvm.") {
 316             crate::intrinsics::codegen_llvm_intrinsic_call(
 317                 fx,
 318                 &fx.tcx.symbol_name(instance).name,
 319                 substs,
 320                 args,
 321                 destination,
 322             );
 323             return;
 324         }
 325
 326         match instance.def {
 327             InstanceDef::Intrinsic(_) => {
 328                 crate::intrinsics::codegen_intrinsic_call(fx, instance, args, destination, span);
 329                 return;
 330             }
 331             InstanceDef::DropGlue(_, None) => {
 332                 // empty drop glue - a nop.
 333                 let (_, dest) = destination.expect("Non terminating drop_in_place_real???");
 334                 let ret_block = fx.get_block(dest);
 335                 fx.bcx.ins().jump(ret_block, &[]);
 336                 return;
 337             }
 338             _ => Some(instance),
 339         }
 340     } else {
 341         None
 342     };
 343
 344     let extra_args = &args[fn_sig.inputs().len()..];
 345     let extra_args = extra_args
 346         .iter()
 347         .map(|op_arg| fx.monomorphize(op_arg.ty(fx.mir, fx.tcx)))
 348         .collect::<Vec<_>>();
 349     let fn_abi = if let Some(instance) = instance {
 350         FnAbi::of_instance(&RevealAllLayoutCx(fx.tcx), instance, &extra_args)
 351     } else {
 352         FnAbi::of_fn_ptr(&RevealAllLayoutCx(fx.tcx), fn_ty.fn_sig(fx.tcx), &extra_args)
 353     };
 354
 355     let is_cold = instance
 356         .map(|inst| fx.tcx.codegen_fn_attrs(inst.def_id()).flags.contains(CodegenFnAttrFlags::COLD))
 357         .unwrap_or(false);
 358     if is_cold {
 359         // FIXME Mark current_block block as cold once Cranelift supports it
 360     }
 361
 362     // Unpack arguments tuple for closures
 363     let args = if fn_sig.abi == Abi::RustCall {
 364         assert_eq!(args.len(), 2, "rust-call abi requires two arguments");
 365         let self_arg = codegen_operand(fx, &args[0]);
 366         let pack_arg = codegen_operand(fx, &args[1]);
 367
 368         let tupled_arguments = match pack_arg.layout().ty.kind() {
 369             ty::Tuple(ref tupled_arguments) => tupled_arguments,
 370             _ => bug!("argument to function with \"rust-call\" ABI is not a tuple"),
 371         };
 372
 373         let mut args = Vec::with_capacity(1 + tupled_arguments.len());
 374         args.push(self_arg);
 375         for i in 0..tupled_arguments.len() {
 376             args.push(pack_arg.value_field(fx, mir::Field::new(i)));
 377         }
 378         args
 379     } else {
 380         args.iter().map(|arg| codegen_operand(fx, arg)).collect::<Vec<_>>()
 381     };
 382
 383     //   | indirect call target
 384     //   |         | the first argument to be passed
 385     //   v         v
 386     let (func_ref, first_arg) = match instance {
 387         // Trait object call
 388         Some(Instance { def: InstanceDef::Virtual(_, idx), .. }) => {
 389             if fx.clif_comments.enabled() {
 390                 let nop_inst = fx.bcx.ins().nop();
 391                 fx.add_comment(
 392                     nop_inst,
 393                     format!("virtual call; self arg pass mode: {:?}", &fn_abi.args[0],),
 394                 );
 395             }
 396             let (ptr, method) = crate::vtable::get_ptr_and_method_ref(fx, args[0], idx);
 397             (Some(method), smallvec![ptr])
 398         }
 399
 400         // Normal call
 401         Some(_) => (
 402             None,
 403             args.get(0)
 404                 .map(|arg| adjust_arg_for_abi(fx, *arg, &fn_abi.args[0]))
 405                 .unwrap_or(smallvec![]),
 406         ),
 407
 408         // Indirect call
 409         None => {
 410             if fx.clif_comments.enabled() {
 411                 let nop_inst = fx.bcx.ins().nop();
 412                 fx.add_comment(nop_inst, "indirect call");
 413             }
 414             let func = codegen_operand(fx, func).load_scalar(fx);
 415             (
 416                 Some(func),
 417                 args.get(0)
 418                     .map(|arg| adjust_arg_for_abi(fx, *arg, &fn_abi.args[0]))
 419                     .unwrap_or(smallvec![]),
 420             )
 421         }
 422     };
 423
 424     let ret_place = destination.map(|(place, _)| place);
 425     let (call_inst, call_args) = self::returning::codegen_with_call_return_arg(
 426         fx,
 427         &fn_abi.ret,
 428         ret_place,
 429         |fx, return_ptr| {
 430             let regular_args_count = args.len();
 431             let mut call_args: Vec<Value> = return_ptr
 432                 .into_iter()
 433                 .chain(first_arg.into_iter())
 434                 .chain(
 435                     args.into_iter()
 436                         .enumerate()
 437                         .skip(1)
 438                         .map(|(i, arg)| adjust_arg_for_abi(fx, arg, &fn_abi.args[i]).into_iter())
 439                         .flatten(),
 440                 )
 441                 .collect::<Vec<_>>();
 442
 443             if instance.map(|inst| inst.def.requires_caller_location(fx.tcx)).unwrap_or(false) {
 444                 // Pass the caller location for `#[track_caller]`.
 445                 let caller_location = fx.get_caller_location(span);
 446                 call_args.extend(
 447                     adjust_arg_for_abi(fx, caller_location, &fn_abi.args[regular_args_count])
 448                         .into_iter(),
 449                 );
 450                 assert_eq!(fn_abi.args.len(), regular_args_count + 1);
 451             } else {
 452                 assert_eq!(fn_abi.args.len(), regular_args_count);
 453             }
 454
 455             let call_inst = if let Some(func_ref) = func_ref {
 456                 let sig = clif_sig_from_fn_abi(fx.tcx, fx.triple(), &fn_abi);
 457                 let sig = fx.bcx.import_signature(sig);
 458                 fx.bcx.ins().call_indirect(sig, func_ref, &call_args)
 459             } else {
 460                 let func_ref =
 461                     fx.get_function_ref(instance.expect("non-indirect call on non-FnDef type"));
 462                 fx.bcx.ins().call(func_ref, &call_args)
 463             };
 464
 465             (call_inst, call_args)
 466         },
 467     );
 468
 469     // FIXME find a cleaner way to support varargs
 470     if fn_sig.c_variadic {
 471         if !matches!(fn_sig.abi, Abi::C { .. }) {
 472             fx.tcx.sess.span_fatal(span, &format!("Variadic call for non-C abi {:?}", fn_sig.abi));
 473         }
 474         let sig_ref = fx.bcx.func.dfg.call_signature(call_inst).unwrap();
 475         let abi_params = call_args
 476             .into_iter()
 477             .map(|arg| {
 478                 let ty = fx.bcx.func.dfg.value_type(arg);
 479                 if !ty.is_int() {
 480                     // FIXME set %al to upperbound on float args once floats are supported
 481                     fx.tcx.sess.span_fatal(span, &format!("Non int ty {:?} for variadic call", ty));
 482                 }
 483                 AbiParam::new(ty)
 484             })
 485             .collect::<Vec<AbiParam>>();
 486         fx.bcx.func.dfg.signatures[sig_ref].params = abi_params;
 487     }
 488
 489     if let Some((_, dest)) = destination {
 490         let ret_block = fx.get_block(dest);
 491         fx.bcx.ins().jump(ret_block, &[]);
 492     } else {
 493         trap_unreachable(fx, "[corruption] Diverging function returned");
 494     }
 495 }
 496
 497 pub(crate) fn codegen_drop<'tcx>(
 498     fx: &mut FunctionCx<'_, '_, 'tcx>,
 499     span: Span,
 500     drop_place: CPlace<'tcx>,
 501 ) {
 502     let ty = drop_place.layout().ty;
 503     let drop_instance = Instance::resolve_drop_in_place(fx.tcx, ty).polymorphize(fx.tcx);
 504
 505     if let ty::InstanceDef::DropGlue(_, None) = drop_instance.def {
 506         // we don't actually need to drop anything
 507     } else {
 508         match ty.kind() {
 509             ty::Dynamic(..) => {
 510                 let (ptr, vtable) = drop_place.to_ptr_maybe_unsized();
 511                 let ptr = ptr.get_addr(fx);
 512                 let drop_fn = crate::vtable::drop_fn_of_obj(fx, vtable.unwrap());
 513
 514                 // FIXME(eddyb) perhaps move some of this logic into
 515                 // `Instance::resolve_drop_in_place`?
 516                 let virtual_drop = Instance {
 517                     def: ty::InstanceDef::Virtual(drop_instance.def_id(), 0),
 518                     substs: drop_instance.substs,
 519                 };
 520                 let fn_abi = FnAbi::of_instance(&RevealAllLayoutCx(fx.tcx), virtual_drop, &[]);
 521
 522                 let sig = clif_sig_from_fn_abi(fx.tcx, fx.triple(), &fn_abi);
 523                 let sig = fx.bcx.import_signature(sig);
 524                 fx.bcx.ins().call_indirect(sig, drop_fn, &[ptr]);
 525             }
 526             _ => {
 527                 assert!(!matches!(drop_instance.def, InstanceDef::Virtual(_, _)));
 528
 529                 let fn_abi = FnAbi::of_instance(&RevealAllLayoutCx(fx.tcx), drop_instance, &[]);
 530
 531                 let arg_value = drop_place.place_ref(
 532                     fx,
 533                     fx.layout_of(fx.tcx.mk_ref(
 534                         &ty::RegionKind::ReErased,
 535                         TypeAndMut { ty, mutbl: crate::rustc_hir::Mutability::Mut },
 536                     )),
 537                 );
 538                 let arg_value = adjust_arg_for_abi(fx, arg_value, &fn_abi.args[0]);
 539
 540                 let mut call_args: Vec<Value> = arg_value.into_iter().collect::<Vec<_>>();
 541
 542                 if drop_instance.def.requires_caller_location(fx.tcx) {
 543                     // Pass the caller location for `#[track_caller]`.
 544                     let caller_location = fx.get_caller_location(span);
 545                     call_args.extend(
 546                         adjust_arg_for_abi(fx, caller_location, &fn_abi.args[1]).into_iter(),
 547                     );
 548                 }
 549
 550                 let func_ref = fx.get_function_ref(drop_instance);
 551                 fx.bcx.ins().call(func_ref, &call_args);
 552             }
 553         }
 554     }
 555 }