2 use rustc::middle::allocator::AllocatorKind;
3 use smallvec::{smallvec, SmallVec};
6 self, Arg, Attribute, Crate, Expr, FnHeader, Generics, Ident, Item, ItemKind,
7 Mac, Mod, Mutability, Ty, TyKind, Unsafety, VisibilityKind,
11 respan, ExpnInfo, MacroAttribute,
14 base::{ExtCtxt, Resolver},
16 expand::ExpansionConfig,
17 hygiene::{self, Mark, SyntaxContext},
19 mut_visit::{self, MutVisitor},
22 symbol::{keywords, Symbol, sym}
26 use crate::{AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS};
30 resolver: &mut dyn Resolver,
33 handler: &rustc_errors::Handler,
35 ExpandAllocatorDirectives {
40 crate_name: Some(crate_name),
41 in_submod: -1, // -1 to account for the "root" module
45 struct ExpandAllocatorDirectives<'a> {
47 handler: &'a rustc_errors::Handler,
49 resolver: &'a mut dyn Resolver,
50 crate_name: Option<String>,
52 // For now, we disallow `global_allocator` in submodules because hygiene is hard. Keep track of
53 // whether we are in a submodule or not. If `in_submod > 0` we are in a submodule.
57 impl MutVisitor for ExpandAllocatorDirectives<'_> {
58 fn flat_map_item(&mut self, item: P<Item>) -> SmallVec<[P<Item>; 1]> {
59 debug!("in submodule {}", self.in_submod);
61 let name = if attr::contains_name(&item.attrs, sym::global_allocator) {
64 return mut_visit::noop_flat_map_item(item, self);
67 ItemKind::Static(..) => {}
70 .span_err(item.span, "allocators must be statics");
71 return smallvec![item];
75 if self.in_submod > 0 {
77 .span_err(item.span, "`global_allocator` cannot be used in submodules");
78 return smallvec![item];
83 .span_err(item.span, "cannot define more than one #[global_allocator]");
84 return smallvec![item];
88 // Create a fresh Mark for the new macro expansion we are about to do
89 let mark = Mark::fresh(Mark::root());
90 mark.set_expn_info(ExpnInfo {
91 call_site: item.span, // use the call site of the static
93 format: MacroAttribute(Symbol::intern(name)),
94 allow_internal_unstable: Some(vec![
95 Symbol::intern("rustc_attrs"),
97 allow_internal_unsafe: false,
98 local_inner_macros: false,
99 edition: hygiene::default_edition(),
102 // Tie the span to the macro expansion info we just created
103 let span = item.span.with_ctxt(SyntaxContext::empty().apply_mark(mark));
105 // Create an expansion config
106 let ecfg = ExpansionConfig::default(self.crate_name.take().unwrap());
108 // Generate a bunch of new items using the AllocFnFactory
109 let mut f = AllocFnFactory {
111 kind: AllocatorKind::Global,
113 core: Ident::with_empty_ctxt(sym::core),
114 cx: ExtCtxt::new(self.sess, ecfg, self.resolver),
117 // We will generate a new submodule. To `use` the static from that module, we need to get
118 // the `super::...` path.
120 f.cx.path(f.span, vec![Ident::with_empty_ctxt(keywords::Super.name()), f.global]);
122 // Generate the items in the submodule
123 let mut items = vec![
124 // import `core` to use allocators
125 f.cx.item_extern_crate(f.span, f.core),
126 // `use` the `global_allocator` in `super`
127 f.cx.item_use_simple(
129 respan(f.span.shrink_to_lo(), VisibilityKind::Inherited),
134 // Add the allocator methods to the submodule
138 .map(|method| f.allocator_fn(method)),
141 // Generate the submodule itself
142 let name = f.kind.fn_name("allocator_abi");
143 let allocator_abi = Ident::with_empty_ctxt(Symbol::gensym(&name));
144 let module = f.cx.item_mod(span, span, allocator_abi, Vec::new(), items);
145 let module = f.cx.monotonic_expander().flat_map_item(module).pop().unwrap();
147 // Return the item and new submodule
148 smallvec![item, module]
151 // If we enter a submodule, take note.
152 fn visit_mod(&mut self, m: &mut Mod) {
153 debug!("enter submodule");
155 mut_visit::noop_visit_mod(m, self);
157 debug!("exit submodule");
160 // `visit_mac` is disabled by default. Enable it here.
161 fn visit_mac(&mut self, mac: &mut Mac) {
162 mut_visit::noop_visit_mac(mac, self)
166 struct AllocFnFactory<'a> {
174 impl AllocFnFactory<'_> {
175 fn allocator_fn(&self, method: &AllocatorMethod) -> P<Item> {
176 let mut abi_args = Vec::new();
178 let ref mut mk = || {
179 let name = Ident::from_str(&format!("arg{}", i));
186 .map(|ty| self.arg_ty(ty, &mut abi_args, mk))
188 let result = self.call_allocator(method.name, args);
189 let (output_ty, output_expr) = self.ret_ty(&method.output, result);
190 let kind = ItemKind::Fn(
191 self.cx.fn_decl(abi_args, ast::FunctionRetTy::Ty(output_ty)),
193 unsafety: Unsafety::Unsafe,
194 ..FnHeader::default()
197 self.cx.block_expr(output_expr),
201 Ident::from_str(&self.kind.fn_name(method.name)),
207 fn call_allocator(&self, method: &str, mut args: Vec<P<Expr>>) -> P<Expr> {
208 let method = self.cx.path(
212 Ident::from_str("alloc"),
213 Ident::from_str("GlobalAlloc"),
214 Ident::from_str(method),
217 let method = self.cx.expr_path(method);
218 let allocator = self.cx.path_ident(self.span, self.global);
219 let allocator = self.cx.expr_path(allocator);
220 let allocator = self.cx.expr_addr_of(self.span, allocator);
221 args.insert(0, allocator);
223 self.cx.expr_call(self.span, method, args)
226 fn attrs(&self) -> Vec<Attribute> {
227 let special = Symbol::intern("rustc_std_internal_symbol");
228 let special = self.cx.meta_word(self.span, special);
229 vec![self.cx.attribute(self.span, special)]
236 ident: &mut dyn FnMut() -> Ident,
239 AllocatorTy::Layout => {
240 let usize = self.cx.path_ident(self.span, Ident::with_empty_ctxt(sym::usize));
241 let ty_usize = self.cx.ty_path(usize);
244 args.push(self.cx.arg(self.span, size, ty_usize.clone()));
245 args.push(self.cx.arg(self.span, align, ty_usize));
247 let layout_new = self.cx.path(
251 Ident::from_str("alloc"),
252 Ident::from_str("Layout"),
253 Ident::from_str("from_size_align_unchecked"),
256 let layout_new = self.cx.expr_path(layout_new);
257 let size = self.cx.expr_ident(self.span, size);
258 let align = self.cx.expr_ident(self.span, align);
259 let layout = self.cx.expr_call(self.span, layout_new, vec![size, align]);
263 AllocatorTy::Ptr => {
265 args.push(self.cx.arg(self.span, ident, self.ptr_u8()));
266 let arg = self.cx.expr_ident(self.span, ident);
267 self.cx.expr_cast(self.span, arg, self.ptr_u8())
270 AllocatorTy::Usize => {
272 args.push(self.cx.arg(self.span, ident, self.usize()));
273 self.cx.expr_ident(self.span, ident)
276 AllocatorTy::ResultPtr | AllocatorTy::Unit => {
277 panic!("can't convert AllocatorTy to an argument")
282 fn ret_ty(&self, ty: &AllocatorTy, expr: P<Expr>) -> (P<Ty>, P<Expr>) {
284 AllocatorTy::ResultPtr => {
289 let expr = self.cx.expr_cast(self.span, expr, self.ptr_u8());
290 (self.ptr_u8(), expr)
293 AllocatorTy::Unit => (self.cx.ty(self.span, TyKind::Tup(Vec::new())), expr),
295 AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => {
296 panic!("can't convert AllocatorTy to an output")
301 fn usize(&self) -> P<Ty> {
302 let usize = self.cx.path_ident(self.span, Ident::with_empty_ctxt(sym::usize));
303 self.cx.ty_path(usize)
306 fn ptr_u8(&self) -> P<Ty> {
307 let u8 = self.cx.path_ident(self.span, Ident::with_empty_ctxt(sym::u8));
308 let ty_u8 = self.cx.ty_path(u8);
309 self.cx.ty_ptr(self.span, ty_u8, Mutability::Mutable)