}

/// Return the `AllocId` for the given thread-local static in the current thread.

_ecx: &mut InterpCx<'mir, 'tcx, Self>,

def_id: DefId,

) -> InterpResult<'tcx, Pointer<Self::Provenance>> {

throw_unsup!(ThreadLocalStatic(def_id))

}

ecx: &InterpCx<'mir, 'tcx, Self>,

def_id: DefId,

) -> InterpResult<'tcx, Pointer<Self::Provenance>>;

///

/// `kind` is the kind of the allocation the pointer points to; it can be `None` when

/// it's a global and `GLOBAL_KIND` is `None`.

ecx: &InterpCx<'mir, 'tcx, Self>,

ptr: Pointer,

kind: Option<MemoryKind<Self::MemoryKind>>,

Ok(alloc)

}

ecx: &InterpCx<$mir, $tcx, Self>,

def_id: DefId,

) -> InterpResult<$tcx, Pointer> {

}

#[inline(always)]

_ecx: &InterpCx<$mir, $tcx, Self>,

ptr: Pointer<CtfeProvenance>,

_kind: Option<MemoryKind<Self::MemoryKind>>,

///

/// This function can fail only if `ptr` points to an `extern static`.

#[inline]

&self,

ptr: Pointer<CtfeProvenance>,

) -> InterpResult<'tcx, Pointer<M::Provenance>> {

bug!("global memory cannot point to thread-local static")

}

Some(GlobalAlloc::Static(def_id)) if self.tcx.is_foreign_item(def_id) => {

}

None => {

assert!(

_ => {}

}

// And we need to get the provenance.

}

pub fn fn_ptr(&mut self, fn_val: FnVal<'tcx, M::ExtraFnVal>) -> Pointer<M::Provenance> {

id

}

};

// We know this is not an `extern static` so this cannot fail.

}

pub fn allocate_ptr(

);

let alloc = M::adjust_allocation(self, id, Cow::Owned(alloc), Some(kind))?;

self.memory.alloc_map.insert(id, (kind, alloc.into_owned()));

}

pub fn reallocate_ptr(

// Other cases need layout.

let adjust_scalar = |scalar| -> InterpResult<'tcx, _> {

Ok(match scalar {

Scalar::Int(int) => Scalar::Int(int),

})

};

let layout = from_known_layout(self.tcx, self.param_env, layout, || self.layout_of(ty))?;

let imm = match val_val {

mir::ConstValue::Indirect { alloc_id, offset } => {

// This is const data, no mutation allowed.

CtfeProvenance::from(alloc_id).as_immutable(),

offset,

))?;

// This is const data, no mutation allowed.

let alloc_id = self.tcx.reserve_and_set_memory_alloc(data);

let ptr = Pointer::new(CtfeProvenance::from(alloc_id).as_immutable(), Size::ZERO);

}

};

Ok(OpTy { op: Operand::Immediate(imm), layout })

) -> InterpResult<'tcx, MPlaceTy<'tcx, M::Provenance>> {

// This must be an allocation in `tcx`

let _ = self.tcx.global_alloc(raw.alloc_id);

let layout = self.layout_of(raw.ty)?;

Ok(self.ptr_to_mplace(ptr.into(), layout))

}

use rustc_middle::mir::Rvalue::*;

match *rvalue {

ThreadLocalRef(did) => {

self.write_pointer(ptr, &dest)?;

}

ensure_monomorphic_enough(*self.tcx, poly_trait_ref)?;

let vtable_symbolic_allocation = self.tcx.reserve_and_set_vtable_alloc(ty, poly_trait_ref);

Ok(vtable_ptr.into())

}

}

/// Convert a relative (tcx) pointer to a Miri pointer.

&self,

ptr: Pointer<CtfeProvenance>,

tag: BorTag,

ecx.alloc_id_from_addr(addr.bytes())?

};

// must have been called in the past, so we can just look up the address in the map.

let base_addr = *ecx.machine.alloc_addresses.borrow().base_addr.get(&alloc_id).unwrap();

borrow_tracker_method: BorrowTrackerMethod,

/// Next unused pointer ID (tag).

next_ptr_tag: BorTag,

/// We need this in a separate table to handle cyclic statics.

/// Next unused call ID (for protectors).

next_call_id: CallId,

/// All currently protected tags.

GlobalStateInner {

borrow_tracker_method,

next_ptr_tag: BorTag::one(),

next_call_id: NonZero::new(1).unwrap(),

protected_tags: FxHashMap::default(),

tracked_pointer_tags,

}

}

let tag = self.new_ptr();

if self.tracked_pointer_tags.contains(&tag) {

machine.emit_diagnostic(NonHaltingDiagnostic::CreatedPointerTag(

None,

));

}

tag

})

}

pub fn remove_unreachable_allocs(&mut self, allocs: &LiveAllocs<'_, '_, '_>) {

}

pub struct AllocHistory {

id: AllocId,

creations: smallvec::SmallVec<[Creation; 1]>,

invalidations: smallvec::SmallVec<[Invalidation; 1]>,

protectors: smallvec::SmallVec<[Protection; 1]>,

pub fn new(id: AllocId, item: Item, machine: &MiriMachine<'_, '_>) -> Self {

Self {

id,

creations: SmallVec::new(),

invalidations: SmallVec::new(),

protectors: SmallVec::new(),

})

})

.or_else(|| {

// this allocation.

Some((

format!(

self.history.id

),

))

} else {

None

// not through a pointer). That is, whenever we directly write to a local, this will pop

// everything else off the stack, invalidating all previous pointers,

// and in particular, *all* raw pointers.

// Everything else is shared by default.

};

Stacks::new(size, perm, base_tag, id, machine)

}

let mut first_removed = None;

// We never consider removing the bottom-most tag. For stacks without an unknown

// Note that the algorithm below is based on considering the tag at read_idx - 1,

// so precisely considering the tag at index 0 for removal when we have an unknown

// bottom would complicate the implementation. The simplification of not considering

self.unique_range = 0..self.len();

}

for i in 0..CACHE_LEN {

if self.cache.idx[i] >= first_removed {

self.cache.items[i] = self.borrows[0];

self.verify_cache_consistency();

}

pub fn new(item: Item) -> Self {

Stack {

borrows: vec![item],

let mut removed = 0;

let mut cursor = 0;

// Remove invalid entries from the cache by rotating them to the end of the cache, then

for _ in 0..CACHE_LEN - 1 {

if self.cache.idx[cursor] >= start {

self.cache.idx[cursor..CACHE_LEN - removed].rotate_left(1);

_kind: MemoryKind,

machine: &MiriMachine<'_, 'tcx>,

) -> Self {

let span = machine.current_span();

Tree::new(tag, size, span)

}

/// Crates which are considered local for the purposes of error reporting.

pub(crate) local_crates: Vec<CrateNum>,

extern_statics: FxHashMap<Symbol, Pointer<Provenance>>,

/// The random number generator used for resolving non-determinism.

ecx.generate_nan(inputs)

}

ecx: &mut MiriInterpCx<'mir, 'tcx>,

def_id: DefId,

) -> InterpResult<'tcx, Pointer<Provenance>> {

ecx.get_or_create_thread_local_alloc(def_id)

}

ecx: &MiriInterpCx<'mir, 'tcx>,

def_id: DefId,

) -> InterpResult<'tcx, Pointer<Provenance>> {

weak_memory: buffer_alloc,

backtrace,

},

)?;

if matches!(kind, MemoryKind::Machine(kind) if kind.should_save_allocation_span()) {

Ok(Cow::Owned(alloc))

}

ecx: &MiriInterpCx<'mir, 'tcx>,

ptr: Pointer<CtfeProvenance>,

kind: Option<MemoryKind>,

// The machine promises to never call us on thread-local or extern statics.

match ecx.tcx.try_get_global_alloc(alloc_id) {

Some(GlobalAlloc::Static(def_id)) if ecx.tcx.is_thread_local_static(def_id) => {

}

Some(GlobalAlloc::Static(def_id)) if ecx.tcx.is_foreign_item(def_id) => {

}

_ => {}

}

}

// FIXME: can we somehow preserve the immutability of `ptr`?

let tag = if let Some(borrow_tracker) = &ecx.machine.borrow_tracker {

} else {

// Value does not matter, SB is disabled

BorTag::default()

};

}

/// Called on `usize as ptr` casts.

|

= help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental

= help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information

--> $DIR/invalidate_against_protector3.rs:LL:CC

|

LL | let ptr = alloc(Layout::for_value(&0i32)) as *mut i32;