BitcodeTransformRegistryDsl
Project-wide registry of reusable LLVM bitcode transforms. Function rules accept originalSource as a StigRepoFile or an upstream HTTP(S) source URL. It defaults to originalCompileUnit and records the original function location for comparison. reviewStatus is shared by every activity selecting the rule.
Properties
The source-level return value, including aggregate returns lowered through sret.
The implicit receiver of a non-static C++ member function.
Functions
Bind the supplied pointer only when the selected stored pointer is null; preserve an existing binding.
Assign an exact Boolean value to a Boolean destination.
Assign a literal integer; zero can initialize all supported payload fields of a named object or array.
Copy fixed bytes through a named byte-pointer member, then reload and advance that stored pointer.
Transfer corresponding elements of equal-size fixed arrays, optionally selecting a scalar field per element. Both endpoints use eachElement(); destinations require an aggregate return. Explicit zeroInitializeReturn clears unassigned scalar members; otherwise every scalar must be covered. A constant may instead initialize selected fields of a counted receiver/parameter array. The count is read once; only active elements are written, and zero or excessive counts perform no writes. Other fields remain. Compiler types provide the capacity, stride and field offsets. This preserves index correspondence.
Read one scalar (or scalar field) from a fixed array, selected by an integer parameter. Compiler types supply capacity, stride and member offsets. The caller must supply a valid index, as for an unchecked C++ array access; this does not reduce or merge the other elements.
Join dependencies of possible scalar elements of a named counted array into a scalar return or field. Emits a bounded symbolic read, with no traversal or count-to-return dependency. An empty or invalid count performs no read. NO_CHECK may merge all indices within the compiler-declared array capacity; this is a dependency abstraction, not a numerical reduction or precise active-prefix analysis.
Return the address of an existing global object identified by its exact LLVM linkage name (without @). This preserves object identity; it neither reads the object's payload nor supplies its initialization.
Supply exactly one analysis source or recorded native compiler input. A native input retains its own compile recipe; selecting it is an explicit analysis-scope decision.
Retain the original body and request a compiler policy. NEVER does not imply optnone.
A numeric, Boolean, enum, or single-scalar wrapper member of a parameter, receiver, or returned object. Dotted paths follow embedded objects and C++ reference members using compiler debug types. A reference selects its referent, never its stored pointer. Const referents reject writes; const owners can still contain mutable references. Ordinary pointer members require a separate model.
Read selected input bytes/active array elements as dependencies, without computing their values.
A neutral body, with no argument/global writes and a zero/null return where needed.
A terminating body; its compiler protection is controlled by STIG.
The zero-based source-level parameter, excluding hidden LLVM ABI arguments.
An exact compiler-recorded parameter name; field paths follow embedded objects and C++ reference members.
Return the current global pointer with one sequentially consistent atomic load, preserving its alias.
Return a stored member pointer, using the current value of a defined global pointer when it is null.
The returned scalar, or a named scalar field of the returned object (including hidden sret storage).
Group possible entry-time contributors without introducing a computation or sequence.
Group destinations receiving every contributor of this transfer.
The implicit receiver, selecting a scalar field or a C++ reference member's scalar referent.
Reusable value and memory operations lowered directly to LLVM, without a replacement C/C++ source file.
Materialize a combined dependency summary. All sources describe entry-time values, including self-edges. Contributors to each destination are joined into one write; declaration order does not sequence assignments. Unspecified destinations remain unchanged.
One dependency edge. This overload does not compute the original numeric result.