Lines Matching full:are

12 clang, improving performance on constructs which are executed inefficiently
24 one to directly evaluate expressions as they are compiled, without
25 generating bytecode (``EvalEmitter``). All functions are compiled to
26 bytecode, while toplevel expressions used in constant contexts are directly
34 description of opcodes, can be found in ``Opcodes.td``. The opcodes are
50   implement integral types which are required by the target, but are not
96 records (structs and classes). Unions are represented as records, except
98 fields are kept until they are reactivated and overwritten.
100 (``__attribute((vector_size(16)))``) are treated as arrays.
108 ``InterpFrame`` objects storing the call frames. Frames are built by
125 Blocks contain data interleaved with metadata. They are allocated either
128 containing the local variables of a function. Blocks are associated with a
139 Static blocks are never deallocated, but local ones might be deallocated
140 even when there are live pointers to them. Pointers are only valid as
141 long as the blocks they point to are valid, so a block with pointers to
143 scope. Since the frame is destroyed on function exit, such blocks are
145 interpreter itself, not the frame. Reads and writes to these blocks are
147 pointer goes out of scope, dead blocks are also deallocated.
154   which are not trivial (``Pointer``, ``RealFP``, etc.)
163 all pointers to it are invalidated, emitting the appropriate diagnostics when
178   fully initialised. When all fields are initialised, the map is deallocated
181   Array elements are stored sequentially, without padding, after the pointer
188   allocation site. Descriptors and elements are stored sequentially in the
190   Records are laid out identically to arrays of composites: each field and base
205 Inline descriptors are filled in by the `CtorFn` of blocks, which leaves storage
211 Descriptors are generated at bytecode compilation time and contain information
221 Pointers, implemented in ``Pointer.h`` are represented as a tagged union.
231    through pointer arithmetic, such as ``((int *)0x100)[20]``. Null pointers are
247 pointers, are implemented as a union of all pointer types. The ``BitCast``
279 On the target, ``&a`` and ``&a.b.x`` are equal. So are ``&a.c[0]`` and
281 distinguished since the are all allowed to address distinct range of
286 be derived to the object are illustrated in the following diagram:
305 Array elements are identified by the ``Offset`` field of pointers,
317 Extern pointers can be derived, pointing into symbols which are not
337 are characterised by 3 offsets: a field offset, an array offset and a
342 case, null pointers are target pointers with all offsets set to 0.
353 Such pointers are built by operations which cannot generate valid
376   when it encounters a type: ones which are not yet defined should be lazily