compiler/rustc_codegen_cranelift/src/allocator.rs

   1 //! Allocator shim
   2 // Adapted from rustc
   3
   4 use crate::prelude::*;
   5
   6 use rustc_ast::expand::allocator::{AllocatorKind, AllocatorTy, ALLOCATOR_METHODS};
   7 use rustc_session::config::OomStrategy;
   8 use rustc_span::symbol::sym;
   9
  10 /// Returns whether an allocator shim was created
  11 pub(crate) fn codegen(
  12     tcx: TyCtxt<'_>,
  13     module: &mut impl Module,
  14     unwind_context: &mut UnwindContext,
  15 ) -> bool {
  16     let any_dynamic_crate = tcx.dependency_formats(()).iter().any(|(_, list)| {
  17         use rustc_middle::middle::dependency_format::Linkage;
  18         list.iter().any(|&linkage| linkage == Linkage::Dynamic)
  19     });
  20     if any_dynamic_crate {
  21         false
  22     } else if let Some(kind) = tcx.allocator_kind(()) {
  23         codegen_inner(
  24             module,
  25             unwind_context,
  26             kind,
  27             tcx.alloc_error_handler_kind(()).unwrap(),
  28             tcx.sess.opts.unstable_opts.oom,
  29         );
  30         true
  31     } else {
  32         false
  33     }
  34 }
  35
  36 fn codegen_inner(
  37     module: &mut impl Module,
  38     unwind_context: &mut UnwindContext,
  39     kind: AllocatorKind,
  40     alloc_error_handler_kind: AllocatorKind,
  41     oom_strategy: OomStrategy,
  42 ) {
  43     let usize_ty = module.target_config().pointer_type();
  44
  45     for method in ALLOCATOR_METHODS {
  46         let mut arg_tys = Vec::with_capacity(method.inputs.len());
  47         for ty in method.inputs.iter() {
  48             match *ty {
  49                 AllocatorTy::Layout => {
  50                     arg_tys.push(usize_ty); // size
  51                     arg_tys.push(usize_ty); // align
  52                 }
  53                 AllocatorTy::Ptr => arg_tys.push(usize_ty),
  54                 AllocatorTy::Usize => arg_tys.push(usize_ty),
  55
  56                 AllocatorTy::ResultPtr | AllocatorTy::Unit => panic!("invalid allocator arg"),
  57             }
  58         }
  59         let output = match method.output {
  60             AllocatorTy::ResultPtr => Some(usize_ty),
  61             AllocatorTy::Unit => None,
  62
  63             AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => {
  64                 panic!("invalid allocator output")
  65             }
  66         };
  67
  68         let sig = Signature {
  69             call_conv: module.target_config().default_call_conv,
  70             params: arg_tys.iter().cloned().map(AbiParam::new).collect(),
  71             returns: output.into_iter().map(AbiParam::new).collect(),
  72         };
  73
  74         let caller_name = format!("__rust_{}", method.name);
  75         let callee_name = kind.fn_name(method.name);
  76
  77         let func_id = module.declare_function(&caller_name, Linkage::Export, &sig).unwrap();
  78
  79         let callee_func_id = module.declare_function(&callee_name, Linkage::Import, &sig).unwrap();
  80
  81         let mut ctx = Context::new();
  82         ctx.func.signature = sig.clone();
  83         {
  84             let mut func_ctx = FunctionBuilderContext::new();
  85             let mut bcx = FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
  86
  87             let block = bcx.create_block();
  88             bcx.switch_to_block(block);
  89             let args = arg_tys
  90                 .into_iter()
  91                 .map(|ty| bcx.append_block_param(block, ty))
  92                 .collect::<Vec<Value>>();
  93
  94             let callee_func_ref = module.declare_func_in_func(callee_func_id, &mut bcx.func);
  95             let call_inst = bcx.ins().call(callee_func_ref, &args);
  96             let results = bcx.inst_results(call_inst).to_vec(); // Clone to prevent borrow error
  97
  98             bcx.ins().return_(&results);
  99             bcx.seal_all_blocks();
 100             bcx.finalize();
 101         }
 102         module.define_function(func_id, &mut ctx).unwrap();
 103         unwind_context.add_function(func_id, &ctx, module.isa());
 104     }
 105
 106     let sig = Signature {
 107         call_conv: module.target_config().default_call_conv,
 108         params: vec![AbiParam::new(usize_ty), AbiParam::new(usize_ty)],
 109         returns: vec![],
 110     };
 111
 112     let callee_name = alloc_error_handler_kind.fn_name(sym::oom);
 113
 114     let func_id =
 115         module.declare_function("__rust_alloc_error_handler", Linkage::Export, &sig).unwrap();
 116
 117     let callee_func_id = module.declare_function(&callee_name, Linkage::Import, &sig).unwrap();
 118
 119     let mut ctx = Context::new();
 120     ctx.func.signature = sig;
 121     {
 122         let mut func_ctx = FunctionBuilderContext::new();
 123         let mut bcx = FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
 124
 125         let block = bcx.create_block();
 126         bcx.switch_to_block(block);
 127         let args = (&[usize_ty, usize_ty])
 128             .iter()
 129             .map(|&ty| bcx.append_block_param(block, ty))
 130             .collect::<Vec<Value>>();
 131
 132         let callee_func_ref = module.declare_func_in_func(callee_func_id, &mut bcx.func);
 133         bcx.ins().call(callee_func_ref, &args);
 134
 135         bcx.ins().trap(TrapCode::UnreachableCodeReached);
 136         bcx.seal_all_blocks();
 137         bcx.finalize();
 138     }
 139     module.define_function(func_id, &mut ctx).unwrap();
 140     unwind_context.add_function(func_id, &ctx, module.isa());
 141
 142     let data_id = module.declare_data(OomStrategy::SYMBOL, Linkage::Export, false, false).unwrap();
 143     let mut data_ctx = DataContext::new();
 144     data_ctx.set_align(1);
 145     let val = oom_strategy.should_panic();
 146     data_ctx.define(Box::new([val]));
 147     module.define_data(data_id, &data_ctx).unwrap();
 148 }