1 // Copyright 2012-2013 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 //!
12 //
13 // Code relating to taking, dropping, etc as well as type descriptors.
14
15
16 use back::abi;
17 use back::link::*;
18 use lib::llvm::{llvm, ValueRef, True};
19 use lib;
20 use middle::lang_items::{FreeFnLangItem, ExchangeFreeFnLangItem};
21 use middle::trans::adt;
22 use middle::trans::base::*;
23 use middle::trans::build::*;
24 use middle::trans::callee;
25 use middle::trans::cleanup;
26 use middle::trans::cleanup::CleanupMethods;
27 use middle::trans::common::*;
28 use middle::trans::expr;
29 use middle::trans::machine::*;
30 use middle::trans::reflect;
31 use middle::trans::tvec;
32 use middle::trans::type_::Type;
33 use middle::trans::type_of::{type_of, sizing_type_of};
34 use middle::ty;
35 use util::ppaux::ty_to_short_str;
36 use util::ppaux;
37
38 use arena::TypedArena;
39 use std::c_str::ToCStr;
40 use std::cell::Cell;
41 use libc::c_uint;
42 use syntax::ast;
43 use syntax::parse::token;
44
45 pub fn trans_free<'a>(cx: &'a Block<'a>, v: ValueRef) -> &'a Block<'a> {
46 let _icx = push_ctxt("trans_free");
47 callee::trans_lang_call(cx,
48 langcall(cx, None, "", FreeFnLangItem),
49 [PointerCast(cx, v, Type::i8p(cx.ccx()))],
50 Some(expr::Ignore)).bcx
51 }
52
53 pub fn trans_exchange_free<'a>(cx: &'a Block<'a>, v: ValueRef)
54 -> &'a Block<'a> {
55 let _icx = push_ctxt("trans_exchange_free");
56 callee::trans_lang_call(cx,
57 langcall(cx, None, "", ExchangeFreeFnLangItem),
58 [PointerCast(cx, v, Type::i8p(cx.ccx()))],
59 Some(expr::Ignore)).bcx
60 }
61
62 pub fn take_ty<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t)
63 -> &'a Block<'a> {
64 // NB: v is an *alias* of type t here, not a direct value.
65 let _icx = push_ctxt("take_ty");
66 match ty::get(t).sty {
67 ty::ty_box(_) => incr_refcnt_of_boxed(bcx, v),
68 _ if ty::type_is_structural(t)
69 && ty::type_needs_drop(bcx.tcx(), t) => {
70 iter_structural_ty(bcx, v, t, take_ty)
71 }
72 _ => bcx
73 }
74 }
75
76 fn get_drop_glue_type(ccx: &CrateContext, t: ty::t) -> ty::t {
77 let tcx = ccx.tcx();
78 if !ty::type_needs_drop(tcx, t) {
79 return ty::mk_i8();
80 }
81 match ty::get(t).sty {
82 ty::ty_box(typ) if !ty::type_needs_drop(tcx, typ) =>
83 ty::mk_box(tcx, ty::mk_i8()),
84
85 ty::ty_uniq(typ) if !ty::type_needs_drop(tcx, typ) => {
86 match ty::get(typ).sty {
87 ty::ty_vec(_, None) | ty::ty_str => t,
88 _ => {
89 let llty = sizing_type_of(ccx, typ);
90 // Unique boxes do not allocate for zero-size types. The standard
91 // library may assume that `free` is never called on the pointer
92 // returned for `Box<ZeroSizeType>`.
93 if llsize_of_alloc(ccx, llty) == 0 {
94 ty::mk_i8()
95 } else {
96 ty::mk_uniq(tcx, ty::mk_i8())
97 }
98 }
99 }
100 }
101 _ => t
102 }
103 }
104
105 pub fn drop_ty<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t)
106 -> &'a Block<'a> {
107 // NB: v is an *alias* of type t here, not a direct value.
108 let _icx = push_ctxt("drop_ty");
109 let ccx = bcx.ccx();
110 if ty::type_needs_drop(bcx.tcx(), t) {
111 let glue = get_drop_glue(ccx, t);
112 let glue_type = get_drop_glue_type(ccx, t);
113 let ptr = if glue_type != t {
114 PointerCast(bcx, v, type_of(ccx, glue_type).ptr_to())
115 } else {
116 v
117 };
118 Call(bcx, glue, [ptr], []);
119 }
120 bcx
121 }
122
123 pub fn drop_ty_immediate<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t)
124 -> &'a Block<'a> {
125 let _icx = push_ctxt("drop_ty_immediate");
126 let vp = alloca(bcx, type_of(bcx.ccx(), t), "");
127 Store(bcx, v, vp);
128 drop_ty(bcx, vp, t)
129 }
130
131 pub fn get_drop_glue(ccx: &CrateContext, t: ty::t) -> ValueRef {
132 let t = get_drop_glue_type(ccx, t);
133 match ccx.drop_glues.borrow().find(&t) {
134 Some(&glue) => return glue,
135 _ => { }
136 }
137
138 let llfnty = Type::glue_fn(ccx, type_of(ccx, t).ptr_to());
139 let glue = declare_generic_glue(ccx, t, llfnty, "drop");
140
141 ccx.drop_glues.borrow_mut().insert(t, glue);
142
143 make_generic_glue(ccx, t, glue, make_drop_glue, "drop");
144
145 glue
146 }
147
148 pub fn lazily_emit_visit_glue(ccx: &CrateContext, ti: &tydesc_info) -> ValueRef {
149 let _icx = push_ctxt("lazily_emit_visit_glue");
150
151 let llfnty = Type::glue_fn(ccx, type_of(ccx, ti.ty).ptr_to());
152
153 match ti.visit_glue.get() {
154 Some(visit_glue) => visit_glue,
155 None => {
156 debug!("+++ lazily_emit_tydesc_glue VISIT {}", ppaux::ty_to_str(ccx.tcx(), ti.ty));
157 let glue_fn = declare_generic_glue(ccx, ti.ty, llfnty, "visit");
158 ti.visit_glue.set(Some(glue_fn));
159 make_generic_glue(ccx, ti.ty, glue_fn, make_visit_glue, "visit");
160 debug!("--- lazily_emit_tydesc_glue VISIT {}", ppaux::ty_to_str(ccx.tcx(), ti.ty));
161 glue_fn
162 }
163 }
164 }
165
166 // See [Note-arg-mode]
167 pub fn call_visit_glue(bcx: &Block, v: ValueRef, tydesc: ValueRef,
168 static_ti: Option<&tydesc_info>) {
169 let _icx = push_ctxt("call_tydesc_glue_full");
170 let ccx = bcx.ccx();
171 // NB: Don't short-circuit even if this block is unreachable because
172 // GC-based cleanup needs to the see that the roots are live.
173 if bcx.unreachable.get() && !ccx.sess().no_landing_pads() { return; }
174
175 let static_glue_fn = static_ti.map(|sti| lazily_emit_visit_glue(ccx, sti));
176
177 // When static type info is available, avoid casting to a generic pointer.
178 let llrawptr = if static_glue_fn.is_none() {
179 PointerCast(bcx, v, Type::i8p(ccx))
180 } else {
181 v
182 };
183
184 let llfn = {
185 match static_glue_fn {
186 None => {
187 // Select out the glue function to call from the tydesc
188 let llfnptr = GEPi(bcx, tydesc, [0u, abi::tydesc_field_visit_glue]);
189 Load(bcx, llfnptr)
190 }
191 Some(sgf) => sgf
192 }
193 };
194
195 Call(bcx, llfn, [llrawptr], []);
196 }
197
198 fn make_visit_glue<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t)
199 -> &'a Block<'a> {
200 let _icx = push_ctxt("make_visit_glue");
201 let mut bcx = bcx;
202 let (visitor_trait, object_ty) = match ty::visitor_object_ty(bcx.tcx(),
203 ty::ReStatic) {
204 Ok(pair) => pair,
205 Err(s) => {
206 bcx.tcx().sess.fatal(s);
207 }
208 };
209 let v = PointerCast(bcx, v, type_of(bcx.ccx(), object_ty).ptr_to());
210 bcx = reflect::emit_calls_to_trait_visit_ty(bcx, t, v, visitor_trait.def_id);
211 bcx
212 }
213
214 fn trans_struct_drop_flag<'a>(bcx: &'a Block<'a>,
215 t: ty::t,
216 v0: ValueRef,
217 dtor_did: ast::DefId,
218 class_did: ast::DefId,
219 substs: &ty::substs)
220 -> &'a Block<'a> {
221 let repr = adt::represent_type(bcx.ccx(), t);
222 let drop_flag = adt::trans_drop_flag_ptr(bcx, &*repr, v0);
223 with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag)), |cx| {
224 trans_struct_drop(cx, t, v0, dtor_did, class_did, substs)
225 })
226 }
227
228 fn trans_struct_drop<'a>(bcx: &'a Block<'a>,
229 t: ty::t,
230 v0: ValueRef,
231 dtor_did: ast::DefId,
232 class_did: ast::DefId,
233 substs: &ty::substs)
234 -> &'a Block<'a> {
235 let repr = adt::represent_type(bcx.ccx(), t);
236
237 // Find and call the actual destructor
238 let dtor_addr = get_res_dtor(bcx.ccx(), dtor_did,
239 class_did, substs.tps.as_slice());
240
241 // The second argument is the "self" argument for drop
242 let params = unsafe {
243 let ty = Type::from_ref(llvm::LLVMTypeOf(dtor_addr));
244 ty.element_type().func_params()
245 };
246
247 // Class dtors have no explicit args, so the params should
248 // just consist of the environment (self)
249 assert_eq!(params.len(), 1);
250
251 // Be sure to put all of the fields into a scope so we can use an invoke
252 // instruction to call the user destructor but still call the field
253 // destructors if the user destructor fails.
254 let field_scope = bcx.fcx.push_custom_cleanup_scope();
255
256 let self_arg = PointerCast(bcx, v0, *params.get(0));
257 let args = vec!(self_arg);
258
259 // Add all the fields as a value which needs to be cleaned at the end of
260 // this scope.
261 let field_tys = ty::struct_fields(bcx.tcx(), class_did, substs);
262 for (i, fld) in field_tys.iter().enumerate() {
263 let llfld_a = adt::trans_field_ptr(bcx, &*repr, v0, 0, i);
264 bcx.fcx.schedule_drop_mem(cleanup::CustomScope(field_scope),
265 llfld_a,
266 fld.mt.ty);
267 }
268
269 let (_, bcx) = invoke(bcx, dtor_addr, args, [], None);
270
271 bcx.fcx.pop_and_trans_custom_cleanup_scope(bcx, field_scope)
272 }
273
274 fn make_drop_glue<'a>(bcx: &'a Block<'a>, v0: ValueRef, t: ty::t) -> &'a Block<'a> {
275 // NB: v0 is an *alias* of type t here, not a direct value.
276 let _icx = push_ctxt("make_drop_glue");
277 match ty::get(t).sty {
278 ty::ty_box(body_ty) => {
279 decr_refcnt_maybe_free(bcx, v0, body_ty)
280 }
281 ty::ty_uniq(content_ty) => {
282 let llbox = Load(bcx, v0);
283 let not_null = IsNotNull(bcx, llbox);
284 match ty::get(content_ty).sty {
285 ty::ty_vec(mt, None) => {
286 with_cond(bcx, not_null, |bcx| {
287 let bcx = tvec::make_drop_glue_unboxed(bcx, llbox, mt.ty);
288 trans_exchange_free(bcx, llbox)
289 })
290 }
291 ty::ty_str => {
292 with_cond(bcx, not_null, |bcx| {
293 let unit_ty = ty::sequence_element_type(bcx.tcx(), t);
294 let bcx = tvec::make_drop_glue_unboxed(bcx, llbox, unit_ty);
295 trans_exchange_free(bcx, llbox)
296 })
297 }
298 _ => {
299 with_cond(bcx, not_null, |bcx| {
300 let bcx = drop_ty(bcx, llbox, content_ty);
301 trans_exchange_free(bcx, llbox)
302 })
303 }
304 }
305 }
306 ty::ty_struct(did, ref substs) => {
307 let tcx = bcx.tcx();
308 match ty::ty_dtor(tcx, did) {
309 ty::TraitDtor(dtor, true) => {
310 trans_struct_drop_flag(bcx, t, v0, dtor, did, substs)
311 }
312 ty::TraitDtor(dtor, false) => {
313 trans_struct_drop(bcx, t, v0, dtor, did, substs)
314 }
315 ty::NoDtor => {
316 // No dtor? Just the default case
317 iter_structural_ty(bcx, v0, t, drop_ty)
318 }
319 }
320 }
321 ty::ty_trait(box ty::TyTrait { store: ty::UniqTraitStore, .. }) => {
322 let lluniquevalue = GEPi(bcx, v0, [0, abi::trt_field_box]);
323 // Only drop the value when it is non-null
324 with_cond(bcx, IsNotNull(bcx, Load(bcx, lluniquevalue)), |bcx| {
325 let dtor_ptr = Load(bcx, GEPi(bcx, v0, [0, abi::trt_field_vtable]));
326 let dtor = Load(bcx, dtor_ptr);
327 Call(bcx, dtor, [PointerCast(bcx, lluniquevalue, Type::i8p(bcx.ccx()))], []);
328 bcx
329 })
330 }
331 ty::ty_closure(ref f) if f.store == ty::UniqTraitStore => {
332 let box_cell_v = GEPi(bcx, v0, [0u, abi::fn_field_box]);
333 let env = Load(bcx, box_cell_v);
334 let env_ptr_ty = Type::at_box(bcx.ccx(), Type::i8(bcx.ccx())).ptr_to();
335 let env = PointerCast(bcx, env, env_ptr_ty);
336 with_cond(bcx, IsNotNull(bcx, env), |bcx| {
337 let dtor_ptr = GEPi(bcx, env, [0u, abi::box_field_tydesc]);
338 let dtor = Load(bcx, dtor_ptr);
339 let cdata = GEPi(bcx, env, [0u, abi::box_field_body]);
340 Call(bcx, dtor, [PointerCast(bcx, cdata, Type::i8p(bcx.ccx()))], []);
341
342 // Free the environment itself
343 trans_exchange_free(bcx, env)
344 })
345 }
346 _ => {
347 if ty::type_needs_drop(bcx.tcx(), t) &&
348 ty::type_is_structural(t) {
349 iter_structural_ty(bcx, v0, t, drop_ty)
350 } else {
351 bcx
352 }
353 }
354 }
355 }
356
357 fn decr_refcnt_maybe_free<'a>(bcx: &'a Block<'a>,
358 box_ptr_ptr: ValueRef,
359 t: ty::t) -> &'a Block<'a> {
360 let _icx = push_ctxt("decr_refcnt_maybe_free");
361 let fcx = bcx.fcx;
362 let ccx = bcx.ccx();
363
364 let decr_bcx = fcx.new_temp_block("decr");
365 let free_bcx = fcx.new_temp_block("free");
366 let next_bcx = fcx.new_temp_block("next");
367
368 let box_ptr = Load(bcx, box_ptr_ptr);
369 let llnotnull = IsNotNull(bcx, box_ptr);
370 CondBr(bcx, llnotnull, decr_bcx.llbb, next_bcx.llbb);
371
372 let rc_ptr = GEPi(decr_bcx, box_ptr, [0u, abi::box_field_refcnt]);
373 let rc = Sub(decr_bcx, Load(decr_bcx, rc_ptr), C_int(ccx, 1));
374 Store(decr_bcx, rc, rc_ptr);
375 CondBr(decr_bcx, IsNull(decr_bcx, rc), free_bcx.llbb, next_bcx.llbb);
376
377 let v = Load(free_bcx, box_ptr_ptr);
378 let body = GEPi(free_bcx, v, [0u, abi::box_field_body]);
379 let free_bcx = drop_ty(free_bcx, body, t);
380 let free_bcx = trans_free(free_bcx, v);
381 Br(free_bcx, next_bcx.llbb);
382
383 next_bcx
384 }
385
386 fn incr_refcnt_of_boxed<'a>(bcx: &'a Block<'a>,
387 box_ptr_ptr: ValueRef) -> &'a Block<'a> {
388 let _icx = push_ctxt("incr_refcnt_of_boxed");
389 let ccx = bcx.ccx();
390 let box_ptr = Load(bcx, box_ptr_ptr);
391 let rc_ptr = GEPi(bcx, box_ptr, [0u, abi::box_field_refcnt]);
392 let rc = Load(bcx, rc_ptr);
393 let rc = Add(bcx, rc, C_int(ccx, 1));
394 Store(bcx, rc, rc_ptr);
395 bcx
396 }
397
398
399 // Generates the declaration for (but doesn't emit) a type descriptor.
400 pub fn declare_tydesc(ccx: &CrateContext, t: ty::t) -> tydesc_info {
401 // If emit_tydescs already ran, then we shouldn't be creating any new
402 // tydescs.
403 assert!(!ccx.finished_tydescs.get());
404
405 let llty = type_of(ccx, t);
406
407 if ccx.sess().count_type_sizes() {
408 println!("{}\t{}", llsize_of_real(ccx, llty),
409 ppaux::ty_to_str(ccx.tcx(), t));
410 }
411
412 let llsize = llsize_of(ccx, llty);
413 let llalign = llalign_of(ccx, llty);
414 let name = mangle_internal_name_by_type_and_seq(ccx, t, "tydesc");
415 debug!("+++ declare_tydesc {} {}", ppaux::ty_to_str(ccx.tcx(), t), name);
416 let gvar = name.with_c_str(|buf| {
417 unsafe {
418 llvm::LLVMAddGlobal(ccx.llmod, ccx.tydesc_type().to_ref(), buf)
419 }
420 });
421 note_unique_llvm_symbol(ccx, name);
422
423 let ty_name = token::intern_and_get_ident(ppaux::ty_to_str(ccx.tcx(), t));
424 let ty_name = C_str_slice(ccx, ty_name);
425
426 debug!("--- declare_tydesc {}", ppaux::ty_to_str(ccx.tcx(), t));
427 tydesc_info {
428 ty: t,
429 tydesc: gvar,
430 size: llsize,
431 align: llalign,
432 name: ty_name,
433 visit_glue: Cell::new(None),
434 }
435 }
436
437 fn declare_generic_glue(ccx: &CrateContext, t: ty::t, llfnty: Type,
438 name: &str) -> ValueRef {
439 let _icx = push_ctxt("declare_generic_glue");
440 let fn_nm = mangle_internal_name_by_type_and_seq(ccx, t, "glue_".to_owned() + name);
441 debug!("{} is for type {}", fn_nm, ppaux::ty_to_str(ccx.tcx(), t));
442 let llfn = decl_cdecl_fn(ccx.llmod, fn_nm, llfnty, ty::mk_nil());
443 note_unique_llvm_symbol(ccx, fn_nm);
444 return llfn;
445 }
446
447 fn make_generic_glue(ccx: &CrateContext,
448 t: ty::t,
449 llfn: ValueRef,
450 helper: <'a> |&'a Block<'a>, ValueRef, ty::t|
451 -> &'a Block<'a>,
452 name: &str)
453 -> ValueRef {
454 let _icx = push_ctxt("make_generic_glue");
455 let glue_name = format!("glue {} {}", name, ty_to_short_str(ccx.tcx(), t));
456 let _s = StatRecorder::new(ccx, glue_name);
457
458 let arena = TypedArena::new();
459 let fcx = new_fn_ctxt(ccx, llfn, -1, false, ty::mk_nil(), None, None, &arena);
460
461 init_function(&fcx, false, ty::mk_nil());
462
463 lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
464 ccx.stats.n_glues_created.set(ccx.stats.n_glues_created.get() + 1u);
465 // All glue functions take values passed *by alias*; this is a
466 // requirement since in many contexts glue is invoked indirectly and
467 // the caller has no idea if it's dealing with something that can be
468 // passed by value.
469 //
470 // llfn is expected be declared to take a parameter of the appropriate
471 // type, so we don't need to explicitly cast the function parameter.
472
473 let bcx = fcx.entry_bcx.borrow().clone().unwrap();
474 let llrawptr0 = unsafe { llvm::LLVMGetParam(llfn, fcx.arg_pos(0) as c_uint) };
475 let bcx = helper(bcx, llrawptr0, t);
476 finish_fn(&fcx, bcx);
477
478 llfn
479 }
480
481 pub fn emit_tydescs(ccx: &CrateContext) {
482 let _icx = push_ctxt("emit_tydescs");
483 // As of this point, allow no more tydescs to be created.
484 ccx.finished_tydescs.set(true);
485 let glue_fn_ty = Type::generic_glue_fn(ccx).ptr_to();
486 for (_, ti) in ccx.tydescs.borrow().iter() {
487 // Each of the glue functions needs to be cast to a generic type
488 // before being put into the tydesc because we only have a singleton
489 // tydesc type. Then we'll recast each function to its real type when
490 // calling it.
491 let drop_glue = unsafe {
492 llvm::LLVMConstPointerCast(get_drop_glue(ccx, ti.ty), glue_fn_ty.to_ref())
493 };
494 ccx.stats.n_real_glues.set(ccx.stats.n_real_glues.get() + 1);
495 let visit_glue =
496 match ti.visit_glue.get() {
497 None => {
498 ccx.stats.n_null_glues.set(ccx.stats.n_null_glues.get() +
499 1u);
500 C_null(glue_fn_ty)
501 }
502 Some(v) => {
503 unsafe {
504 ccx.stats.n_real_glues.set(ccx.stats.n_real_glues.get() +
505 1);
506 llvm::LLVMConstPointerCast(v, glue_fn_ty.to_ref())
507 }
508 }
509 };
510
511 let tydesc = C_named_struct(ccx.tydesc_type(),
512 [ti.size, // size
513 ti.align, // align
514 drop_glue, // drop_glue
515 visit_glue, // visit_glue
516 ti.name]); // name
517
518 unsafe {
519 let gvar = ti.tydesc;
520 llvm::LLVMSetInitializer(gvar, tydesc);
521 llvm::LLVMSetGlobalConstant(gvar, True);
522 lib::llvm::SetLinkage(gvar, lib::llvm::InternalLinkage);
523 }
524 };
525 }
librustc/middle/trans/glue.rs:61:1-61:1 -fn- definition:
pub fn take_ty<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t)
-> &'a Block<'a> {
// NB: v is an *alias* of type t here, not a direct value.
references:- 369: && ty::type_needs_drop(bcx.tcx(), t) => {
70: iter_structural_ty(bcx, v, t, take_ty)
71: }
librustc/middle/trans/datum.rs:
251: // incr. refcount for @T or newtype'd @T
252: glue::take_ty(bcx, val, ty)
253: }
--
622: bcx = self.shallow_copy(bcx, dst);
623: glue::take_ty(bcx, dst, self.ty)
624: }
librustc/middle/trans/glue.rs:227:1-227:1 -fn- definition:
fn trans_struct_drop<'a>(bcx: &'a Block<'a>,
t: ty::t,
v0: ValueRef,
references:- 2223: with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag)), |cx| {
224: trans_struct_drop(cx, t, v0, dtor_did, class_did, substs)
225: })
--
312: ty::TraitDtor(dtor, false) => {
313: trans_struct_drop(bcx, t, v0, dtor, did, substs)
314: }
librustc/middle/trans/glue.rs:104:1-104:1 -fn- definition:
pub fn drop_ty<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t)
-> &'a Block<'a> {
// NB: v is an *alias* of type t here, not a direct value.
references:- 10348: ty::type_is_structural(t) {
349: iter_structural_ty(bcx, v0, t, drop_ty)
350: } else {
--
378: let body = GEPi(free_bcx, v, [0u, abi::box_field_body]);
379: let free_bcx = drop_ty(free_bcx, body, t);
380: let free_bcx = trans_free(free_bcx, v);
librustc/middle/trans/callee.rs:
739: // drop the value if it is not being saved.
740: bcx = glue::drop_ty(bcx, opt_llretslot.unwrap(), ret_ty);
741: }
librustc/middle/trans/expr.rs:
621: bcx, src_datum.to_rvalue_datum(bcx, "ExprAssign"));
622: bcx = glue::drop_ty(bcx, dst_datum.val, dst_datum.ty);
623: src_datum.store_to(bcx, dst_datum.val)
librustc/middle/trans/_match.rs:
1406: TrByValue(llval) => {
1407: bcx = glue::drop_ty(bcx, llval, binding_info.ty);
1408: }
librustc/middle/trans/cleanup.rs:
812: } else {
813: glue::drop_ty(bcx, self.val, self.ty)
814: }
librustc/middle/trans/tvec.rs:
63: let dataptr = get_dataptr(bcx, vptr);
64: iter_vec_raw(bcx, dataptr, unit_ty, fill, glue::drop_ty)
65: } else { bcx }
librustc/middle/trans/glue.rs:446:1-446:1 -fn- definition:
fn make_generic_glue(ccx: &CrateContext,
t: ty::t,
llfn: ValueRef,
references:- 2143: make_generic_glue(ccx, t, glue, make_drop_glue, "drop");
--
158: ti.visit_glue.set(Some(glue_fn));
159: make_generic_glue(ccx, ti.ty, glue_fn, make_visit_glue, "visit");
160: debug!("--- lazily_emit_tydesc_glue VISIT {}", ppaux::ty_to_str(ccx.tcx(), ti.ty));
librustc/middle/trans/glue.rs:147:1-147:1 -fn- definition:
pub fn lazily_emit_visit_glue(ccx: &CrateContext, ti: &tydesc_info) -> ValueRef {
let _icx = push_ctxt("lazily_emit_visit_glue");
let llfnty = Type::glue_fn(ccx, type_of(ccx, ti.ty).ptr_to());
references:- 3175: let static_glue_fn = static_ti.map(|sti| lazily_emit_visit_glue(ccx, sti));
librustc/middle/trans/intrinsic.rs:
328: let static_ti = get_tydesc(ccx, tp_ty);
329: glue::lazily_emit_visit_glue(ccx, &*static_ti);
librustc/middle/trans/reflect.rs:
77: let static_ti = get_tydesc(bcx.ccx(), t);
78: glue::lazily_emit_visit_glue(bcx.ccx(), &*static_ti);
79: PointerCast(bcx, static_ti.tydesc, self.tydesc_ty.ptr_to())
librustc/middle/trans/glue.rs:75:1-75:1 -fn- definition:
fn get_drop_glue_type(ccx: &CrateContext, t: ty::t) -> ty::t {
let tcx = ccx.tcx();
if !ty::type_needs_drop(tcx, t) {
references:- 2111: let glue = get_drop_glue(ccx, t);
112: let glue_type = get_drop_glue_type(ccx, t);
113: let ptr = if glue_type != t {
--
131: pub fn get_drop_glue(ccx: &CrateContext, t: ty::t) -> ValueRef {
132: let t = get_drop_glue_type(ccx, t);
133: match ccx.drop_glues.borrow().find(&t) {
librustc/middle/trans/glue.rs:44:1-44:1 -fn- definition:
pub fn trans_free<'a>(cx: &'a Block<'a>, v: ValueRef) -> &'a Block<'a> {
let _icx = push_ctxt("trans_free");
callee::trans_lang_call(cx,
references:- 2379: let free_bcx = drop_ty(free_bcx, body, t);
380: let free_bcx = trans_free(free_bcx, v);
381: Br(free_bcx, next_bcx.llbb);
librustc/middle/trans/cleanup.rs:
835: HeapManaged => {
836: glue::trans_free(bcx, self.ptr)
837: }
librustc/middle/trans/glue.rs:436:1-436:1 -fn- definition:
fn declare_generic_glue(ccx: &CrateContext, t: ty::t, llfnty: Type,
name: &str) -> ValueRef {
let _icx = push_ctxt("declare_generic_glue");
references:- 2138: let llfnty = Type::glue_fn(ccx, type_of(ccx, t).ptr_to());
139: let glue = declare_generic_glue(ccx, t, llfnty, "drop");
--
156: debug!("+++ lazily_emit_tydesc_glue VISIT {}", ppaux::ty_to_str(ccx.tcx(), ti.ty));
157: let glue_fn = declare_generic_glue(ccx, ti.ty, llfnty, "visit");
158: ti.visit_glue.set(Some(glue_fn));
librustc/middle/trans/glue.rs:130:1-130:1 -fn- definition:
pub fn get_drop_glue(ccx: &CrateContext, t: ty::t) -> ValueRef {
let t = get_drop_glue_type(ccx, t);
match ccx.drop_glues.borrow().find(&t) {
references:- 4110: if ty::type_needs_drop(bcx.tcx(), t) {
111: let glue = get_drop_glue(ccx, t);
112: let glue_type = get_drop_glue_type(ccx, t);
librustc/middle/trans/base.rs:
379: // Allocate space:
380: let drop_glue = glue::get_drop_glue(ccx, t);
381: let r = callee::trans_lang_call(
librustc/middle/trans/meth.rs:
456: // Generate a destructor for the vtable.
457: let drop_glue = glue::get_drop_glue(ccx, self_ty);
458: let vtable = make_vtable(ccx, drop_glue, methods);
librustc/middle/trans/glue.rs:
491: let drop_glue = unsafe {
492: llvm::LLVMConstPointerCast(get_drop_glue(ccx, ti.ty), glue_fn_ty.to_ref())
493: };
librustc/middle/trans/glue.rs:52:1-52:1 -fn- definition:
pub fn trans_exchange_free<'a>(cx: &'a Block<'a>, v: ValueRef)
-> &'a Block<'a> {
let _icx = push_ctxt("trans_exchange_free");
references:- 5287: let bcx = tvec::make_drop_glue_unboxed(bcx, llbox, mt.ty);
288: trans_exchange_free(bcx, llbox)
289: })
--
342: // Free the environment itself
343: trans_exchange_free(bcx, env)
344: })
librustc/middle/trans/cleanup.rs:
838: HeapExchange => {
839: glue::trans_exchange_free(bcx, self.ptr)
840: }
librustc/middle/trans/glue.rs:
300: let bcx = drop_ty(bcx, llbox, content_ty);
301: trans_exchange_free(bcx, llbox)
302: })