Method visit_terminator

src/analysis/pointsto/mod.rs:605–654

For destination = Arc::clone(move arg0) and destination = ptr::read(move arg0), destination = alias copy args0 For AtomicPtr::store(move args0, move args1, move args2), args0 = copy args1 For other callsites like `destination = call fn(move args0)`, heuristically assumes that destination = copy args0

(&mut self, terminator: &Terminator<'tcx>, _location: Location)

    /// heuristically assumes that
    /// destination = copy args0
    fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, _location: Location) {
        if let TerminatorKind::Call {
            func,
            args,
            destination,
            ..
        } = &terminator.kind
        {
            match (
                args.iter()
                    .map(|x| x.node.clone())
                    .collect::<Vec<_>>()
                    .as_slice(),
                destination,
            ) {
                (&[Operand::Move(arg)], dest) | (&[Operand::Copy(arg)], dest) => {
                    let func_ty = func.ty(self.body, self.tcx);
                    if let TyKind::FnDef(def_id, substs) = func_ty.kind() {
                        if ownership::is_arc_or_rc_clone(*def_id, substs, self.tcx)
                            || ownership::is_ptr_read(*def_id, self.tcx)
                        {
                            return self.process_alias_copy(arg.as_ref(), dest.as_ref());
                        }
                    }
                    self.process_call_arg_dest(arg.as_ref(), dest.as_ref());
                }
                (&[Operand::Move(arg), _], dest) => {
                    let func_ty = func.ty(self.body, self.tcx);
                    if let TyKind::FnDef(def_id, _) = func_ty.kind() {
                        if ownership::is_index(*def_id, self.tcx) {
                            // index(arg0, arg1)
                            // e.g., <String as Index<std::ops::Range<usize>>>::index(move _97, move _98)
                            self.process_call_arg_dest(arg.as_ref(), dest.as_ref())
                        }
                    }
                }
                (&[Operand::Move(arg0), Operand::Move(arg1), Operand::Move(_arg2)], _dest)
                | (&[Operand::Move(arg0), Operand::Move(arg1), Operand::Copy(_arg2)], _dest) => {
                    let func_ty = func.ty(self.body, self.tcx);
                    if let TyKind::FnDef(def_id, list) = func_ty.kind() {
                        if is_atomic_ptr_store(*def_id, list, self.tcx) {
                            // AtomicPtr::store(arg0, arg1, ord) equals to arg0 = call(arg1)
                            self.process_call_arg_dest(arg1.as_ref(), arg0.as_ref())
                        }
                    }
                }
                _ => {}
            }
        }
    }
}

/// We do not use Must/May/Not since the pointer analysis implementation is overapproximate.