src/allocator.rs

   1 // Copyright 2017 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use crate::prelude::*;
  12
  13 use crate::rustc::middle::allocator::AllocatorKind;
  14 use crate::rustc_allocator::{ALLOCATOR_METHODS, AllocatorTy};
  15
  16 pub fn codegen(tcx: TyCtxt, module: &mut Module<impl Backend + 'static>, kind: AllocatorKind) {
  17     let usize_ty = module.target_config().pointer_type();
  18
  19     for method in ALLOCATOR_METHODS {
  20         let mut arg_tys = Vec::with_capacity(method.inputs.len());
  21         for ty in method.inputs.iter() {
  22             match *ty {
  23                 AllocatorTy::Layout => {
  24                     arg_tys.push(usize_ty); // size
  25                     arg_tys.push(usize_ty); // align
  26                 }
  27                 AllocatorTy::Ptr => arg_tys.push(usize_ty),
  28                 AllocatorTy::Usize => arg_tys.push(usize_ty),
  29
  30                 AllocatorTy::ResultPtr |
  31                 AllocatorTy::Unit => panic!("invalid allocator arg"),
  32             }
  33         }
  34         let output = match method.output {
  35             AllocatorTy::ResultPtr => Some(usize_ty),
  36             AllocatorTy::Unit => None,
  37
  38             AllocatorTy::Layout |
  39             AllocatorTy::Usize |
  40             AllocatorTy::Ptr => panic!("invalid allocator output"),
  41         };
  42
  43         let sig = Signature {
  44             call_conv: CallConv::Fast,
  45             params: arg_tys.iter().cloned().map(AbiParam::new).collect(),
  46             returns: output.into_iter().map(AbiParam::new).collect(),
  47         };
  48
  49         let func_id = module
  50             .declare_function(&format!("__rust_{}", method.name), Linkage::Export, &sig)
  51             .unwrap();
  52
  53         let callee_func_id = module
  54             .declare_function(&kind.fn_name(method.name), Linkage::Import, &sig)
  55             .unwrap();
  56
  57         let mut ctx = Context::new();
  58         ctx.func = Function::with_name_signature(ExternalName::user(0, 0), sig.clone());
  59         {
  60             let mut func_ctx = FunctionBuilderContext::new();
  61             let mut bcx: FunctionBuilder = FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
  62
  63             let ebb = bcx.create_ebb();
  64             bcx.switch_to_block(ebb);
  65             let args = arg_tys
  66                 .into_iter()
  67                 .map(|ty| bcx.append_ebb_param(ebb, ty))
  68                 .collect::<Vec<Value>>();
  69
  70             let callee_func_ref = module.declare_func_in_func(callee_func_id, &mut bcx.func);
  71
  72             let call_inst = bcx.ins().call(callee_func_ref, &args);
  73
  74             let results = bcx.inst_results(call_inst).to_vec(); // Clone to prevent borrow error
  75             bcx.ins().return_(&results);
  76             bcx.seal_all_blocks();
  77             bcx.finalize();
  78         }
  79         module.define_function(func_id, &mut ctx).unwrap();
  80     }
  81 }