All Classes and Interfaces
Class
Description
The lexical return remains present even when its action occupies tail position.
Ordinary AST calls retain typed tuple dispatch and its consumer.
Logical aggregate identity is independent of physical positions; vectors remain atomic.
Boxed array elements are copied opaquely, without entering their contents.
Validates the Core forms with captured AST child edges.
Built only while unwinding an interrupted activation; steps run leaf first.
An already-selected arm: its scrutinee and constructor fields are owned by
the caller.
Re-enter saved caller scopes while its exact child remains parked.
One owned activation; ordinary AST calls neither allocate this nor materialize frames.
Cold capture at an AST edge whose callee already saved its body.
One compiler-selected default arm.
The prepared target is private and non-cloning.
The typed result is already in the caller's destination before this cut.
Operand scratch remains caller-owned across asynchronous suspension.
Sequenced operands retain completed prefixes across cuts, never replaying effects.
A cold AST fragment resumes after its child has produced the input value.
Self transfer already installed the next frame and needs no packet or target.
Immutable frame destinations shared across lexical scopes and cloned nodes.
Clones preserve body identity and cached positive/negative target answers.
Every public, forked and callback entry owns its driver, including reentrant entries.
Scheduling cut owned by the current guest entry, never an async delivery.
Exact self entry moves primitive locals; other calls keep ordinary dispatch.
Trampoline witness: every caller suffix was discarded before this exact target.
A pending throwTo payload.
Async delivery carries its origin separately from the guest payload.
Address atomics return the pre-operation value, including failed CAS.
Narrow CAS uses Int carriers; machine and 64-bit operations use Long.
Load-time 64-bit GHC BigNat limbs, least-significant first in native byte order.
Cache Object-ABI boxes at tail sites without unboxing the cached result.
Byte-array primitive contracts and typed execution, including the logical State# slot.
Prepublished, finite expression regions.
Recreated by bytecode source replay; contains no activation or guest values.
In-process proof control.
Bytecode operands stay in typed locals until the interop protocol needs them.
Keep each operand in its exact primitive local until the interop call.
Typed operand locals survive evaluation exactly once, before native effects.
Constructs and links
BytecodeRoots from exported GHC Core.Executable Truffle root for Core lowered through the Bytecode DSL.
Vector heap fields copy lanes from raw-vector locals before publication.
Tuple operands are scalar inputs; each dispatch arm consumes into typed locals.
Private non-tail tuple checkpoint.
Only the function is a stack operand; aggregate fields stay in typed locals.
A prepared native request is saved before the retry/yield loop.
Original thread queries.
Test-owned, non-tail scalar call edge.
The ordinary noDuplicate# operation remains unchanged; this is a private test checkpoint.
Logical arity includes a PAP's remaining formals, not its physical prefix width.
Constant metadata must stay out of the guest operand stack during PE.
Mask operations below are emitted only by the private call checkpoint path.
A constant descriptor lets partial evaluation see each bytecode local.
The Bytecode DSL delegates to the shared call site.
Nonlocal demand shares a real guest root; completion belongs to that actual target.
Evaluates a zero-width field for effects while producing no destination value.
Return the caller mask so the DSL TryFinally can restore it.
A successful force updates this activation's mutable binding, not its final capture property.
Explicit original-foreign ABI widening; never an implicit guest scalar cast.
Typed machine-Int array read.
Called inside a DSL TryCatch; its typed tuple destination is unchanged.
Private checkpoint variant: a yielded action is captured before tuple destination consumption.
Private checkpoint variant: retain the original handler's tuple and mask update.
The private mask-action edge shares exact action capture but owns host-fault cleanup.
Truffle Bytecode DSL declarations share transaction algorithms and callback
boundaries with the AST.
Internal control result of a matching-root tail bounce, never a guest value.
Exact zero-prefix self classification; cloned roots retain the same body identity.
Invoke exactly one logical State argument, with a fence after real return/throw.
Internal ordering of exact integral case labels, including Word# bit patterns.
Exact wide-integral guard for a statically prepared recovery decision.
Only emitted after checked restoration of a proved-data case binder.
State operands are evaluated before each effect; only the array has a tuple slot.
Force already grants each suspended thunk one evaluator across guest threads.
Exact RTS queries whose selected THC policy is fixed during lowering.
A pending cut uses fixed object registers, never cold generic load/store quickening.
No forcing or thunk-indirection traversal: compare the current operand references.
Poll only at a bytecode cut whose locals and operand stack can be resumed.
The post-throwTo cut must claim self delivery under both masks and speculation.
Process WAIT has saved both scalar and errno before this delivery cut.
Java declarations are required by the Truffle Bytecode DSL processor.
Core's single-register integer representation guarantees a primitive value.
Char# keeps its machine-word carrier independently of four-byte storage.
Marker-preserving stamp for direct cuts that do not park annotations.
Stock DSL prologs run only on fresh entry, before any argument ingress.
catch# acknowledges both direct self-delivery and captured async delivery.
Checked reference identities give restored formals a concrete Graal stamp.
The bytecode handler admits only synchronous Haskell guest exceptions.
Restore an immutable constructor slot without observing a DSL specialization first.
Copies a completed, owned tuple into the original caller frame exactly once.
A cold tuple segment owns its producer result before crossing threads.
The saved-call protocol compares arity before consuming a logical prefix.
Compiler-owned suspension scratch registers have Object carriers on every
write.
Only an internal scope completion is resumed here; external STMRestart reaches the retry owner.
One cold instruction keeps the generated interpreter below its partition limit.
Saturated tuple arithmetic never constructs a result carrier or payload array.
One logical vector field restores to one raw-vector reference local.
Capture source descriptors are replay-local metadata, never payload arrays.
Replay-local destinations for a typed input loan; never retains an activation.
Parse-time lane destinations keep wide instructions below JVM method-size limits.
Exact vector metadata and one replay-local slot; no activation or payload is retained here.
Truffle call helpers that pass the supplied argument array directly.
A cold, one-shot continuation whose answer may itself remain lazy.
Only checkpointed catch# may unwrap this origin tag for its handler.
Parent and child name logical continuations, never carrier threads.
Context-owned requests for the private, exact catch# continuation cut.
Only the exact call edge may capture this returned continuation.
Durable selected closure values, separate from invocation and continuation frames.
Matches the generated capture storage superclass constructor exactly.
Fixed storage metadata for durable selected captures, never an invocation frame.
Share mutable cells with the compiled context-thread-local reader.
A category is not a constructor-family or exhaustiveness proof.
Byte interop over an original allocation, retaining exact allocation identity.
A context-owned C label;
&free delegates to checked native ownership.Immutable label metadata; reusable code resolves native authority only in its invoking context.
Cold caller input distinguishes a child result from its guest failure.
Permanent ownership without a separate strong collection of class keys.
Erase the logical State field, retaining a detached diagnostic snapshot.
Detached word image with unforced pointer fields kept separately in payload order.
Info identities belong to one context, never a global guest-value cache.
THC's detached word image, not the GHC or JVM heap ABI.
Keep exceptional null diagnostics out of generic-call partial evaluation.
Cold graph traversal with an explicit work stack.
A managed byte image, not the GHC heap ABI.
Runs after worker scope/initialization, before doCompile.
The first successful provider supplies a process-lifetime baseline captured
before guest pinning.
Context-owned original RTS unique-supply cells; atomics lock their backing arrays.
Per-layout proof that Java class equality implies constructor identity.
Fixed settings only; IO authority is chosen by the context factory.
Compilation-event ownership, not an execution guard.
GHC's Id arity may exceed the lambdas retained in an exported pre-Tidy RHS.
Immutable source of one RHS.
Original GHC SomeException CAFs supplied implicitly by the RTS.
Original GHC thread queries: capability support and the allocation counter.
Nominal stock declarations for operations on THC-owned boxed identities.
Caller-side demand proofs, distinct from entry contracts and stored WHNF facts.
Compare descriptors with multiplicity; binding traversal order is not an ABI contract.
Exact CAPI descriptors of verified, context-loaded bitcode exports.
Checked ordinary ZIP/ZIP64 directory over one immutable mapped snapshot.
Immutable inflated members, never decoded/executable objects.
Bounded, segment-relative reads.
Display-only selected lookups.
One lazily acquired immutable CBD archive.
CBD facts header and uncompressed member-relative payload extents.
Context-owned selected records over a shared immutable file lease.
Selected typed records decoded into the existing lowering input.
Public THC v1 queries, with ordinary C fallback symbols for native GHC.
Native data labels, with overrides only for context-owned THC RTS state.
Context-owned cold cells.
Requested call-by-value conventions, distinct from already-evaluated value proofs.
Original pinned POSIX imports, with their emitted GHC ABI checked once at admission.
Exact producer type provenance, never inferred from runtime values.
Constructor metadata describes representation after the worker's CBV obligations.
Process-shareable read-only mappings of immutable, producer-identified files.
GHC 9.14.1's RTS-visible bad-descriptor closure, retained lazily.
Decode-time literal payload, never a guest carrier.
Archive validation is not foreign linking, initialization or callback registration.
Link-time proof only; no foreign execution or dynamic exception type dispatch.
Identities whose native implementation cannot operate on THC-owned state.
Lexical captures of one demanded expression, without global lookup or body loading.
Original GHC identity of a globally named Core function or thunk.
Remaining formal inputs and result for an admitted alias or partial application.
Exact original GC/clock foreign declarations and lowered operand checks.
Exact GHC 9.14.1 Core contract for the initial Java-thread primitives.
Declared nominal host types, checked against the optimized worker's physical ABI.
Lowering-only proof checks for known inputs; physical carriers never imply a scalar signature.
Join annotations refer to retained value/coercion arguments, not pre-erasure arity.
Load-time proof checks for the kept reference, State and continuation result.
Exact runtime kind is independent of evidence that a lifted value is evaluated.
Exact GHC.Internal.TopHandler.runMainIO1 foreign declaration.
Original ghc-internal/ram address copies and array's byte-array memcpy declaration.
Original module metadata is admitted once.
Internal Core assembly and request serialization.
Retain linked definitions, never the complete raw package request.
Only the explicitly declared, saturated versioned ABI crosses this boundary.
Cold association of nominal stock stack declarations with their recursive
calls.
Admission of exact exported representation proofs; does not evaluate guest values.
Exact admission of original program-arguments imports.
Exact admission of original RTS diagnostics before any output occurs.
Exact admission of original RTS event-manager declarations.
Exact admission of the reserved runtime service ABI.
One debugger location and the provenance of all collapsed source notes.
GHC coordinates retain their exclusive end even without source text.
Parsing-only metadata: constructing locations neither reads files nor adds executable nodes.
Exact original stable-pointer release declaration.
Only the original local clone FCall; no native stack layout or remote clone ABI.
Raw proof validation for the bounded stack-info seam; no generic FFI aliases.
Reduce the exported runRW# State# lambda in its existing binder/source scope.
Exact original ThreadId# ABI; nominal declaration evidence is checked at owning admission.
Carrier/aggregate checks, not a second GHC type checker.
Carrier and tuple checks only; pinned primop types are checked by the exporter audit.
GHC 9.14.1: a levity-polymorphic reference and State produce bare State.
Package directory owns module names, never binding names.
One context's admitted definitions.
Vector identity is one VecRep, independent of its physical runtime value.
Exact proof boundary for local State/vector reads.
Exact vector proof metadata and validation.
A context snapshots capacity before guest pinning.
Support is not a promise that the OS accepts a particular request.
OS coordinates, not a logical capability or Windows CPU Set identifier.
Expected class-owned layouts identify tags without touching any payload field.
Guest heap data with authenticated generated final-field storage, never an AST node.
Captured annotateStack# return, rebased once per multi-shot invocation.
Immutable multi-shot image: each invocation receives its own copied frame graph.
Cadenza exact/PAP/overapplication specializations with fixed site arity.
Cache the target before forming fixed one-slot or two-slot thunk packets.
Force marked arguments only for saturated calls; PAP construction never enters here.
Signature-driven host entry or one-shot executable IO lifecycle.
Selection reuses the same class-owned nullary values as ordinary construction.
Typed execution widens per kind and consumes each evaluated result once.
Program linkage and context-bound host entrypoints shared across Core backends.
Bytecode operations retain opaque logical wait tokens across async cuts.
Native-endian IEEE values preserve raw NaN and signed-zero bits.
Cold exception translation.
One program retains the exact genuine GHC boxer/projector selected when linked.
Framework classification is separate from arbitrary foreign metadata access.
Projectors remain paired with program/unit identity after caught exceptions escape.
Java null is not a valid receiver for Truffle interop libraries.
No foreign code runs when Haskell displays this opaque value.
Callback authority of a synchronous managed foreign activation.
The handle owns a managed foreign value, never an address into either heap.
Primitive locals widen monotonically to objects across shared descriptors.
Allocate indexed slots during lowering, sharing allocation across lexical scopes.
A side-exit body is a call boundary, not a new owner of an inherited tail cycle.
Original GHC RTS declarations, translated to the JVM rather than fabricated RTS counters.
Saturated megamorphic overapplication consumes arguments in a loop.
Dynamic metadata stays outside the fixed caller-local copy loops.
GHC 9.14.1 Bytecodes.h, not THC's Truffle bytecode format.
Native BCO stack frames and owned AP/PAP payloads; Thunk/Force supplies lazy updates.
Linkage is fixed before execution; code and CAF contents may be prepared lazily.
Preparation may propagate interruption without memoizing it.
Context-owned failure receipts.
Actual JVM heap allocation, including runtime bookkeeping, not a guest limit.
Context-owned copies of GHC's argc/argv, including argv[0] and the final
null pointer.
A context's POSIX environment.
Executable root and fixed calling convention shared by AST and bytecode.
First exit wins; host resources close in both modes, while fast mode skips guest hooks.
A lexical blocking extent follows guest re-entry and is restored even on an unwind.
An unlifted ThreadId# names a guest lifetime, independently of its Java carrier.
A carrier can suspend one guest in foreign code and enter a distinct bound callback.
This is execution permission, not the observable Haskell masking state.
Stable per-context/carrier cell, including between nested guest entries.
Carrier cells can be initialized before the Env-owned guest-thread service is patched.
GHC 9.14.1 Constants.h why_blocked codes and PrimOps.cmm terminal overrides.
Dense argument transport still crosses the Truffle boundary with an empty packet.
Physical generated fields, independent of logical Haskell argument identities.
Context-owned layout interning.
One incoming loan; entry makes its values durable before running guest code.
Physical transport fields belong to this layout; loans have generation-bounded lifetime.
Transfer owns only its incoming argument loan, never an outstanding scalar result.
Opaque anyToAddr# identities are weak roots and never expose a JVM pointer.
A logical host aggregate, never a view of pooled guest transport storage.
Direct IO dispatch and a bounded polyglot-to-guest entry boundary.
Context-owned boundary view.
Megamorphic calls enforce the same physical strict-argument contract.
Each bounded cache arm consumes aggregate completion before its result can merge.
Private control transfers must never become ordinary Haskell exceptions.
Typed use-site identity profiling, never a second library cache or adoption site.
Cold checked-protocol failure, eligible for the genuine Haskell ForeignException bridge.
The acquisition site, not its consumers, owns both bounded dispatcher children.
Runs an executable entry or shutdown action whose caller ignores its return value.
Releases a completed IO tuple when the caller has no use for the action's return value.
GHC has already unboxed the public Int/Double arguments at this boundary.
Cached per context, with no integer handles or process-wide foreign roots.
Small strict JSON transport reader; Core is exported structurally, never parsed from dumps.
Keep the reference alive until actual completion, including every resumed cut.
A sender owns one request across an interruptible ACK wait.
Truffle preserves this object when replacing a preinitialized context's Env.
Shared-carrier fallback; the class-owned base itself retains no owner field.
Immutable partial-inlining recipe, fixed before the lowered root is published.
Compiled-only shortcut attributed to the callee arm, without a synthetic frame.
Nonforcing resolution in the existing boxed Object domain.
Only the current platform thread is changed: pid=0 is not a Java thread ID.
Each cloned root owns its widening state; recursive RHSs stay raw until publication.
One exclusive guest permit per logical HEC, one lifetime routing executor per TSO.
Owning launcher contexts and the existing integer/IO embedding boundaries.
Retain this capability, not a permanent ThreadId#/Java-ID snapshot.
An Addr# retains its original storage and authority.
The owning service serializes this weak allocation/offset index.
Native-endian reads retain exact primitive carriers and the full native loan.
One owner for heap/native bytes and every address alias, including managed pointer cells.
Object[] is the actual Array# storage; elements remain opaque mutable references.
Raw host arrays keep their fast path; guest allocations retain one owner across shrink.
Decode the actual GHC wrapper declaration and its emitted createAdjustor helper.
The generated helper association is distinct from an ordinary native function address.
Target allocation accounting, not a GHC heap image or a JVM GC exclusion zone.
Weak keys never retain compacted data.
A ticket authorizes only the immutable module object that was checked.
Read-only member names retain exact GHC unit/module and external symbol identities.
Contains immutable code/metadata only.
One load transaction owns a program.
The boxed scalar portion of a verified static foreign-export signature.
A declaration alias uses the same program-owned binder, layouts and CAFs as its peers.
Versioned JVM file operations, deliberately independent of any platform C ABI.
Explicit thc_io_v1 service, not a POSIX ABI.
Context-owned GHC ForeignExports.c roots and their declared C entrypoints.
Actual host iconv, not a charset emulation.
Retained wrappers need separately validated managed call adapters.
One mutable guest reference.
The lock orders cell changes, queue removal and request commitment.
Stable request identity is also the seam for deterministic protocol tests.
MVar AST operations preserve operands across a pre-commit asynchronous cut.
Native allocations remain owned until their matching deallocator or context disposal.
Context-owned process lifecycle.
Identity capability, never a guest-supplied host PID.
Until transferred, the context retains cleanup ownership.
ABI marshalling and declared activation.
One explicit CLI context owns supported GHC handlers.
Original advance carriers; a terminal result has a null snapshot and zero words.
Original small-bitmap carriers.
Owned standard info image and its identity key for a managed diagnostic frame.
Original binding identity, never inferred from a display label.
Standard StgInfoTable bytes only: no entry code or resumable stack.
Original Core coordinates with their exclusive end and optional label.
Context owns registrations; snapshots retain only its empty identity token.
Original stack/IPE service boundary: managed diagnostic images, not continuations.
Detached inspection data, newest first, not an executable continuation or native stack.
Detached SourceSection coordinates; end columns are inclusive.
Original stdio protocol over context descriptors, never host fds.
A context-owned commit domain.
Payloads are never forced or compared with equals, and retain their context.
Jam owns conditional reachability; this context owns guest finalizer execution.
Shared lazy application and selector targets; CAS retries allocate only captures and thunks.
GHC's MVar payload is boxed at a known levity, not an arbitrary RuntimeRep.
Storage width and signedness are independent of the JVM Int computation
carrier.
Native immutable images retain no managed backing through their weak keys.
Exact GHC 9.14.1 Foreign.Marshal.Alloc allocation declarations.
Experimental selected-Core auxiliary cache launcher; not the ordinary THC launcher.
Public NFI signatures and native callback lifetimes belong to one THC context.
Filesystem callbacks may run outside an entered guest context.
One factory-owned directory.
Original Unix streams over libc DIR objects.
A distinct duplicate per logical descriptor preserves kernel registrations
for dup aliases without exposing process fd integers to Core.
A poll snapshot owns its duplicates.
Native Image retains an application's prepared AST factory from Truffle
preinitialization.
Private native readiness transport.
Captured host errno, not a guessed managed error category.
Private provider ownership; neither fd nor pointer becomes guest data.
Acquisition is reachable solely through the explicitly configured fixed
NativeFileSystem, never from a guest fd or arbitrary embedding stream.
Factory-owned host authority.
Explicit host-filesystem authority for an opt-in context.
Synchronous provider copies close on the host without re-entering LLVM.
Sulong transport tied to its arena lifetime; never a guest Addr#.
One original safe/interruptible open.
One synchronous configured-provider transaction, not a path/fd registry.
Private readiness transport for the selected Linux/Darwin native-file ABI.
Machine-code process transport, including cleanup after LLVM disposal.
Machine-code signal boundary: an asynchronous native handler never enters Truffle.
Ordinary libc calls.
Preserve the public Truffle channel wrapper for byte operations.
Original getter/IPE calls retain typed managed addresses and target layout.
Exact original GHC declarations only; this table does not enable execution.
Exact pinned GHC/library declarations, not aliases for arbitrary POSIX imports.
A logical vector owns final primitive properties in its enclosing heap object.
Canonical labels retain the loaded component, callable and context lifetime.
Typed stock CLabel evidence is independent of the ordinary foreign-call inventory.
A retained obligation is a prohibition, never a foreign execution capability.
Native definitions and their declared component dependencies, not a Haskell call ABI.
Exact image-host-selected DSO bytes, in dependency-first order.
Native pointers cannot outlive a synchronous call's allocation borrows.
Genuine C provenance retains its carrier and any known checked backing.
One adopted call site for an exact component ABI; reusable sites receive
their invoking program's function rather than caching a context receiver.
The context owns this callable and its lifetime; call sites own interop nodes.
Component C globals and entrypoints belong to one Truffle context.
Verified captured adapters are bound lazily to their context's provider.
A package-owned link needs both the typed GHC import and its complete component ABI.
An internal cut retains the exact uncommitted operation, never a new queue entry.
Cached interop messages can specialize on the foreign language's actual objects.
The selected native LP64 stat image ABI, not a host pointer or
a simulated fstat.
GHC's four locality levels are optional performance hints on this target.
Reentrant ownership of inert lowering, with cooperative guest contention.
Immutable call-site setup is independent of observing a function target.
Cold committed cut for one exact original catch# action.
Checked native transport stages, in the native bridge's declared order.
Live libc process identity; cached handles never cache the returned identity.
Original process-1.6.26.1 POSIX imports, including the interruptible wait.
Zero errno preserves the sticky guest error.
Exact GHC 9.14.1 TopHandler and unix-2.8.8.0 signal declarations.
Constructs and links the AST backend's executable roots from exported GHC Core.
Entry views of one context-owned program, sharing its native roots and lazy cells.
Recursive indirection: captured by identity and initialized once.
Original GHC.Internal.System.Environment declarations, not arbitrary C calls.
Exact original GHC 9.14.1 Conc.Sync, TopHandler and Debug.Trace declarations.
Context stderr diagnostics, not native GHC TSO allocation or binary eventlog records.
Original event-manager prerequisites; no OS event descriptors are manufactured.
Original RTS bookkeeping, not OS locks or ManagedFiles owner claims.
Exact safe, non-returning GHC.Internal.TopHandler declarations.
Non-bottom, same-representation absent fillers; their payload is not observable.
JVM-wide collector counters, not per-THC-context GC or GHC RTS statistics.
Opt-in diagnostics for THC.Internal.JIT, deliberately tied to the pinned
Graal implementation API.
Read-only JVM-wide usage, plus explicitly context-owned libc allocations.
Primitive selector avoids boxing the heap/non-heap flag at this boundary.
Versioned scalar C declarations, with honest native-GHC compatibility stubs.
Small target services behind a versioned private scalar ABI.
Private v1 bridge codes.
Read-only observations of the current guest's Java thread.
JFR's eventThread is the emitter's Java thread; IDs are not GHC TSO addresses.
Provider boundary keeps optional JFR availability and denied controls testable.
Context-owned tracing shared by THC.Trace and the original GHC trace primops.
Runtime categories used by typed AST execution.
One-shot view of a parked activation, retaining its exact published identity.
GHC 9.14.1 rts/posix/TTY.c's three saved pointers, scoped to a Context.
Canonical Core literal spellings and their existing scalar carriers.
Selected GHC 9.14.1 RTS slots holding context-owned shared-CAF StablePtrs.
Exact program-owned Ptr/Int32 layouts preserve constructor case identity.
Small-array operations retain their separate storage carrier and logical size.
SmallArray# has a distinct carrier and an independently published logical size.
One context's bounded speculative WHNF work; Force owns every thunk update.
Lazy spark transport and context-owned queue queries.
Canonical context-owned identity tokens that do not retain their referents.
StablePtr# roots belong to a context; their AddrRep carrier is opaque.
Persistent opaque identity, not guest byte storage.
Persistent lazy payloads; never retains an executable frame or thread.
Shared transaction scopes.
Not a Haskell exception: catchSTM cannot intercept validation failure.
GHC 9.14.1 boxed-at-known-levity payloads, not arbitrary scalar RuntimeRep.
Aborted scopes retain neither child continuation nor mutable log.
Not a Haskell exception: catchSTM cannot intercept retry.
Original Posix and ByteString declarations with their exact installed units.
Context-owned original C code and checked managed/native allocation views.
Native GHC slots and canonical JVM projections are distinct contracts.
Trampoline witness: every caller suffix was discarded before this exact target.
Target-derived ABI of the original GHC stack and InfoProv sources.
Actual terminal-image layout and read-only signal header constants, not
terminal state or native pointers.
A single deadline survives safepoint wakeups and captured guest continuations.
GHC TSO identity operations must observe THC's guest lifetimes, never native heap pointers.
A shared lazy update cell; state publishes the answer and ownership release.
A root-local yield hands the shared thunk to another evaluator.
Direct immutable TruffleString operations, not Java String adapters.
Residual calls consume the pooled token in the caller frame.
A private thread-local result-register token, never a payload carrier.
Cache the complete call shape before making its packet.
Consumers release results before evaluating any guest continuation.
Logical aggregate/vector identity is independent of physical result fields.
The unique erased guest state/void carrier, shared by every execution path.
A Word64 result remains a Truffle number throughout the public interop boundary.
A known implementation gap, distinct from malformed Core or runtime errors.
An unavailable foreign implementation: no invocation, operand effects or result writes.
The superclass argument validates allocation before Object initialization.
Local Addr# vector reads retain exact public carriers and erased State.
JDK Vector API operations.
Local reads publish a dense vector, never a State/vector tuple.
Integer SIMD has no division instruction on the pinned target.
An exact VecRep occupies one raw Vector API reference in activation transport.
Parallel moves retain the immutable raw vector without extracting lanes.
Native-order byte movement at the explicit ByteArray# boundary.
One logical token survives a captured async cut; a new poll request does not.
Original ghc-internal Windows encoding/error imports.
The pinned nonthreaded StablePtr console protocol.
The original Win32 package's search API.
The selected package's real CRT/WinSock namespace.