| /openbsd-src/gnu/llvm/compiler-rt/include/xray/ |
| H A D | xray_log_interface.h | 11 // APIs for installing a new logging implementation.
16 /// to replace the default runtime-controllable implementation that comes with
17 /// compiler-rt/xray. The "flight data recorder" (FDR) mode implementation uses
19 /// compiler-rt/lib/xray_fdr_logging.{h,cc} for details of that implementation.
34 /// // Once that's done, we can now attempt to configure the implementation.
42 /// // When the log implementation has had the chance to initialize, we can
51 /// // If we want to stop the implementation, we can then finalize it (before
59 /// // chance to see that the implementation is already finalized. Also, at
78 /// // implementation supports exporting this data directly).
89 /// implementation first. Some implementations might stay in an "off" state when
[all …]
|
| /openbsd-src/gnu/gcc/gcc/doc/ |
| H A D | implement-c.texi | 5 @node C Implementation
6 @chapter C Implementation-defined behavior
7 @cindex implementation-defined behavior, C language
9 A conforming implementation of ISO C is required to document its
11 ``implementation defined''. The following lists all such areas,
13 9899:1999 standards. Some areas are only implementation-defined in
21 @xref{Implementation-defined behavior, , Implementation-defined
27 * Translation implementation::
28 * Environment implementation::
29 * Identifiers implementation::
[all …]
|
| H A D | standards.texi | 35 @cindex freestanding implementation
37 @cindex hosted implementation
105 implementation. A @dfn{conforming hosted implementation} supports the
107 freestanding implementation} is only required to provide certain
117 implementation-defined, and a @dfn{hosted environment}, which is not
122 in a hosted implementation.
126 implementation, or as the compiler for a conforming hosted
127 implementation. By default, it will act as the compiler for a hosted
128 implementation, defining @code{__STDC_HOSTED__} as @code{1} and
131 freestanding implementation for a freestanding environment, use the
|
| /openbsd-src/lib/libcbor/src/cbor/ |
| H A D | callbacks.h | 110 /** Dummy callback implementation - does nothing */
113 /** Dummy callback implementation - does nothing */
116 /** Dummy callback implementation - does nothing */
119 /** Dummy callback implementation - does nothing */
122 /** Dummy callback implementation - does nothing */
125 /** Dummy callback implementation - does nothing */
128 /** Dummy callback implementation - does nothing */
131 /** Dummy callback implementation - does nothing */
134 /** Dummy callback implementation - does nothing */
137 /** Dummy callback implementation - does nothing */
[all …]
|
| /openbsd-src/usr.bin/sed/ |
| H A D | POSIX | 41 backslash in front of it. This implementation follows the BSD
50 implementation permits whitespace but does not require it.
54 POSIX. This implementation permits whitespace but does not
61 is a cleanup, and is followed by this implementation.
78 one might reverse the behaviour.) This implementation follows
86 command. This implementation follows historic practice and
99 This implementation follows historic practice.
107 any particular purpose, this implementation follows the POSIX
121 Historic implementations, and this implementation, do not output
128 does not specify this. This implementation follows historical
[all …]
|
| /openbsd-src/gnu/llvm/clang/include/clang/AST/ |
| H A D | LexicallyOrderedRecursiveASTVisitor.h | 29 /// some declarations, like Objective-C @implementation declarations
32 /// In particular, Objective-C @implementation declarations may contain
35 /// @implementation MyClass
42 /// Clang's AST stores these declarations outside of the @implementation
52 /// corresponding TraverseDecl for the @implementation returns. This ensures
54 /// @implementation is preserved while traversing the AST. Note that the
55 /// current implementation doesn't mix these declarations with the declarations
56 /// contained in the @implementation, so the traversal of all of the
57 /// declarations in the @implementation still doesn't follow the lexical order.
67 // Objective-C @implementation declarations should not trigger early exit in TraverseObjCImplementationDecl()
[all …]
|
| /openbsd-src/lib/libcrypto/man/ |
| H A D | EVP_CIPHER_meth_new.3 | 153 a symmetric cipher implementation.
212 the IV entirely to the implementation.
214 the implementation is typically expected to do that in its
220 and similar initialization functions to call the implementation's
229 and similar initialization functions to call the implementation's
247 but instead leave that to the implementation by calling the
258 to call the implementation's
270 implementation specific data block has been copied.
271 The implementation-specific data block is reached with
290 implementation.
[all …]
|
| H A D | EC_GFp_simple_method.3 | 72 Each implementation is optimised for different scenarios.
73 An implementation is represented by an
79 an implementation method must be provided.
84 It is important that the correct implementation type for the form
87 For Fp curves the lowest common denominator implementation is the
89 implementation.
|
| /openbsd-src/gnu/llvm/llvm/docs/DependenceGraphs/ |
| H A D | index.rst | 14 The implementation of these ideas in LLVM may be slightly different than
16 the `implementation details <implementation-details_>`_.
72 ``DirectedGraph`` class. Each implementation extends its corresponding
94 pattern as it applies to the dependence graph implementation.
105 implementation.
126 Implementation Details
129 The current implementation of DDG differs slightly from the dependence
132 …implementation, DDG nodes naturally represent LLVM IR instructions. An assignment statement in thi…
133 …cy*, *flow-*, *anti-*, *output-*, and *input-* dependencies. In this implementation *memory* edges…
134 …re SCCs and *IN* nodes whose bodies are not part of any SCC. In this implementation, pi-blocks are…
|
| /openbsd-src/gnu/gcc/libstdc++-v3/include/bits/ |
| H A D | postypes.h | 57 // behaviour of these types is mostly implementation defined or
58 // unspecified. The behaviour in this implementation is as noted
66 * implementation defined type.
87 * In this implementation StateT must be DefaultConstructible,
89 * should contain a member of type StateT. In this implementation it also
103 // constructed. This implementation provides a default
112 // implementation implicit conversion is also allowed, and this
156 // implementation it constructs a copy of *this, adds the
170 // implementation it constructs a copy of *this, subtracts the
184 // implementation it returns the difference between the offset
[all …]
|
| /openbsd-src/gnu/llvm/compiler-rt/lib/sanitizer_common/ |
| H A D | sanitizer_local_address_space_view.h | 10 // space are the same) implementation of the `AddressSpaceView` interface which
18 // load any pointers in instance methods. This implementation is effectively
23 // change its implementation at compile time which has no run time overhead.
34 // process (always local for this implementation) starting at address
40 // The lifetime of loaded memory is implementation defined.
49 // process (always local for this implementation) starting at address
58 // separate calls to `LoadWritable()`, it is implementation defined whether
66 // The lifetime of loaded memory is implementation defined.
|
| H A D | sanitizer_win_defs.h | 55 // implementation until it links with that object file.
56 // So, suppose we provide a default implementation "fundef" for "fun", and this
80 // which defines an alias to a default implementation, and only works when
82 // So, to define a weak function "fun", we define a default implementation with
88 // Dummy name for default implementation of weak function.
90 // Name for exported implementation of weak function.
110 // + A default implementation must always be provided.
118 // // We can use the default implementation from the library:
124 // that the linker includes the object file with the default implementation.
136 // // We can use the default implementation from the library:
|
| /openbsd-src/gnu/usr.bin/perl/pod/ |
| H A D | perlapio.pod | 144 This has been the default implementation since the abstraction was
151 Introduced just after perl5.7.0, this is a re-implementation of the
156 to remain with a known value while swapping the implementation around
158 very simple) functions which call the underlying implementation.
160 This is the only implementation for which C<PerlIO_apply_layers()>
163 The USE_PERLIO implementation is described in L<perliol>.
168 these functions are somewhat dependent on the underlying implementation.
188 implementation limit on the number of open handles, which may be lower
221 Depending on implementation C<errno> may be C<EINTR> if operation was
232 Depending on implementation
[all...] |
| /openbsd-src/gnu/gcc/gcc/ |
| H A D | dwarf.h | 79 #define TAG_lo_user 0x8000 /* implementation-defined range start */
80 #define TAG_hi_user 0xffff /* implementation-defined range end */
171 #define AT_lo_user 0x2000 /* implementation-defined range start */
172 #define AT_hi_user 0x3ff0 /* implementation-defined range end */
190 #define OP_LO_USER 0x80 /* implementation-defined range start */
191 #define OP_HI_USER 0xff /* implementation-defined range end */
250 #define FT_lo_user 0x8000 /* implementation-defined range start */
251 #define FT_hi_user 0xffff /* implementation defined range end */
262 #define MOD_lo_user 0x80 /* implementation-defined range start */
263 #define MOD_hi_user 0xff /* implementation-defined range end */
[all …]
|
| /openbsd-src/gnu/usr.bin/binutils-2.17/include/elf/ |
| H A D | dwarf.h | 82 #define TAG_lo_user 0x8000 /* implementation-defined range start */
83 #define TAG_hi_user 0xffff /* implementation-defined range end */
174 #define AT_lo_user 0x2000 /* implementation-defined range start */
175 #define AT_hi_user 0x3ff0 /* implementation-defined range end */
193 #define OP_LO_USER 0x80 /* implementation-defined range start */
194 #define OP_HI_USER 0xff /* implementation-defined range end */
253 #define FT_lo_user 0x8000 /* implementation-defined range start */
254 #define FT_hi_user 0xffff /* implementation defined range end */
265 #define MOD_lo_user 0x80 /* implementation-defined range start */
266 #define MOD_hi_user 0xff /* implementation-defined range end */
[all …]
|
| /openbsd-src/gnu/usr.bin/gcc/gcc/ |
| H A D | dwarf.h | 79 #define TAG_lo_user 0x8000 /* implementation-defined range start */
80 #define TAG_hi_user 0xffff /* implementation-defined range end */
171 #define AT_lo_user 0x2000 /* implementation-defined range start */
172 #define AT_hi_user 0x3ff0 /* implementation-defined range end */
190 #define OP_LO_USER 0x80 /* implementation-defined range start */
191 #define OP_HI_USER 0xff /* implementation-defined range end */
250 #define FT_lo_user 0x8000 /* implementation-defined range start */
251 #define FT_hi_user 0xffff /* implementation defined range end */
262 #define MOD_lo_user 0x80 /* implementation-defined range start */
263 #define MOD_hi_user 0xff /* implementation-defined range end */
[all …]
|
| /openbsd-src/gnu/usr.bin/binutils/include/elf/ |
| H A D | dwarf.h | 81 #define TAG_lo_user 0x8000 /* implementation-defined range start */
82 #define TAG_hi_user 0xffff /* implementation-defined range end */
173 #define AT_lo_user 0x8000 /* implementation-defined range start */
174 #define AT_hi_user 0xffff /* implementation-defined range end */
188 #define OP_LO_USER 0x80 /* implementation-defined range start */
189 #define OP_HI_USER 0xff /* implementation-defined range end */
245 #define FT_lo_user 0x8000 /* implementation-defined range start */
246 #define FT_hi_user 0xffff /* implementation defined range end */
257 #define MOD_lo_user 0x80 /* implementation-defined range start */
258 #define MOD_hi_user 0xff /* implementation-defined range end */
[all …]
|
| /openbsd-src/lib/libpthread/man/ |
| H A D | pthread_getconcurrency.3 | 44 function allows an application to inform the threads implementation
47 The actual level of concurrency provided by the implementation
51 is zero, it causes the implementation to maintain the concurrency
63 indicate that the implementation is maintaining the concurrency
67 it is informing the implementation of its desired concurrency
69 The implementation uses this as a hint, not a requirement.
|
| /openbsd-src/gnu/usr.bin/gcc/gcc/testsuite/objc/execute/ |
| H A D | class-8.m | 7 implementation - in a category */
15 @implementation RootClass
26 @implementation SubClass
40 @implementation SubSubClass
43 @implementation SubSubClass (Additions)
|
| H A D | class-9.m | 7 implementation but reusing it with super - in a category */
15 @implementation RootClass
26 @implementation SubClass
40 @implementation SubSubClass
43 @implementation SubSubClass (Additions)
|
| H A D | class-11.m | 7 implementation and using self to call another method of itself - in
16 @implementation RootClass
27 @implementation SubClass
42 @implementation SubSubClass
49 @implementation SubSubClass (Additions)
|
| H A D | class-3.m | 13 @implementation RootClass
19 @implementation SubClassA
25 @implementation SubClassB
31 @implementation SubSubClass
|
| /openbsd-src/gnu/usr.bin/gcc/gcc/doc/ |
| H A D | standards.texi | 35 @cindex freestanding implementation
37 @cindex hosted implementation
105 implementation. A @dfn{conforming hosted implementation} supports the
107 freestanding implementation} is only required to provide certain
117 implementation-defined, and a @dfn{hosted environment}, which is not
122 in a hosted implementation.
126 implementation, or as the compiler for a conforming hosted
127 implementation. By default, it will act as the compiler for a hosted
128 implementation, defining @code{__STDC_HOSTED__} as @code{1} and
131 freestanding implementation for a freestanding environment, use the
|
| /openbsd-src/gnu/llvm/llvm/docs/ |
| H A D | SupportLibrary.rst | 49 are forbidden to be included by LLVM source code outside the implementation of
116 The implementation of a function for a given platform must be written exactly
118 implementation to multiple operating systems if those operating systems can
119 share the same implementation. This rule applies to the set of operating
127 methods. There is no need to use inheritance for implementation differences, it
142 terms of ``stat`` but that is strictly an implementation detail. The interface
212 distinguish which implementation to compile, the code in ``lib/Support`` uses
215 functionality needs to include the correct implementation using a set of
228 The implementation in ``lib/Support/Unix/Path.inc`` should handle all Unix
229 variants. The implementation in ``lib/Support/Windows/Path.inc`` should handle
[all …]
|
| /openbsd-src/gnu/llvm/clang/docs/ |
| H A D | Toolchain.rst | 86 command-line interface of the frontend is considered to be an implementation
134 appropriate implementation of each runtime library, selected based on
204 compiler-rt contains an implementation of an atomics library.
209 libgcc_s does not provide an implementation of an atomics library. Instead,
250 This is another implementation of the libunwind specification.
256 This is another implementation of the libunwind specification.
267 The only supported implementation of these runtimes is provided by LLVM's
282 The C++ ABI library provides an implementation of the library portion of
303 `libc++abi <https://libcxxabi.llvm.org/>`_ is LLVM's implementation of this
309 libsupc++ is GCC's implementation of this specification. However, this
[all …]
|