compiler (reference) in projects: Linux-v5.15

Project(s)

Full Search
Definition
Symbol
File Path
History
Type

Searched refs:compiler (Results 1 – 25 of 147) sorted by relevance

12 3 4 5 6

/Linux-v5.15/tools/memory-model/Documentation/
D	control-dependencies.txt	6 help you prevent your compiler from breaking your code. However, 9 your own code, even in the absence of help from your compiler. 41 WRITE_ONCE() are optional. Without the READ_ONCE(), the compiler might 43 the compiler might fuse the store to "b" with other stores. Worse yet, 44 the compiler might convert the store into a load and a check followed 45 by a store, and this compiler-generated load would not be ordered by 48 Furthermore, if the compiler is able to prove that the value of variable 56 In particular, although READ_ONCE() does force the compiler to emit a 57 load, it does not force the compiler to actually use the loaded value. 90 assembly code, after all of the compiler and link-time optimizations [all …]
D	access-marking.txt	34 any sort of constraint on the compiler's choice of optimizations [2]. 36 compiler's use of code-motion and common-subexpression optimizations. 41 data_race(READ_ONCE(a)), which will both restrict compiler optimizations 91 If it is necessary to both restrict compiler optimizations and disable 115 that provides the compiler much less scope for mischievous optimizations. 152 due to compiler-mangled reads, it can also tolerate the occasional 153 compiler-mangled write, at least assuming that the proper value is in 216 of how the compiler has been prevented from optimizing those accesses 237 As noted earlier, the goal is to prevent the compiler from destroying 278 The reader-writer lock prevents the compiler from introducing concurrency [all …]
D	ordering.txt	190 compiler might then reasonably decide to transform "x = 1" and "y = 1" 222 The Linux kernel's compiler barrier is barrier(). This primitive 223 prohibits compiler code-motion optimizations that might move memory 226 used to prevent to compiler from moving code across an infinite loop: 233 Without the barrier(), the compiler would be within its rights to move the 432 However, control dependencies are easily destroyed by compiler 460 primitives required the compiler to emit the corresponding store 468 primitives required the compiler to emit the corresponding load 501 and further do not guarantee "atomic" access. For example, the compiler 508 any number of compiler optimizations, many of which can break your [all …]
D	README	`28 o You would like a detailed understanding of what your compiler can 54 Guide to preventing compiler optimizations from destroying`
D	simple.txt	`58 locking functions must carefully prevent both the CPU and the compiler 224 no ordering, but they do prevent the compiler from carrying out a number 237 Don't let the compiler trip you up 243 surprising amount of analysis, care, and knowledge about the compiler. 244 Yes, some decades ago it was not unfair to consider a C compiler to be 252 understanding of both the C standard and your compiler. Here are some 255 Who's afraid of a big bad optimizing compiler?`
/Linux-v5.15/scripts/coccinelle/misc/
D	uninitialized_var.cocci	`7 /// For any compiler warnings about uninitialized variables, just add 10 /// compiler warnings (e.g. "unused variable"). If the compiler thinks it 11 /// is uninitialized, either simply initialize the variable or make compiler 13 /// obviously redundant, the compiler's dead-store elimination pass will make`
/Linux-v5.15/include/linux/
D	compiler_types.h	`340 #define __diag_ignore(compiler, version, option, comment) \ argument 341 __diag_ ## compiler(version, ignore, option) 342 #define __diag_warn(compiler, version, option, comment) \ argument 343 __diag_ ## compiler(version, warn, option) 344 #define __diag_error(compiler, version, option, comment) \ argument 345 __diag_ ## compiler(version, error, option)`
/Linux-v5.15/Documentation/RCU/
D	rcu_dereference.rst	26 compiler from deducing the resulting pointer value. Please see 28 for an example where the compiler can in fact deduce the exact 38 The compiler simply knows too much about integral values to 56 "(x-(uintptr_t)x)" for char* pointers. The compiler is within its 95 explained, if the two pointers are equal, the compiler could 103 Because the compiler now knows that the value of "p" is exactly 118 compiler knows that the pointer is NULL, you had better 120 non-equal, the compiler is none the wiser. Therefore, 125 Since there are no subsequent dereferences, the compiler 177 - The pointers are not equal and the compiler does [all …]
D	lockdep.rst	`58 and compiler constraints. This is useful when the data 63 but retain the compiler constraints that prevent duplicating 98 barriers and compiler constraints, it generates better code than do the`
/Linux-v5.15/scripts/
D	Kconfig.include	`27 # Return y if the compiler supports <flag>, n otherwise 39 $(error-if,$(failure,command -v $(CC)),compiler '$(CC)' not found) 42 # Get the compiler name, version, and error out if it is not supported. 44 $(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this compiler is not supported.) 61 # $(m32-flag): -m32 if the compiler supports it, or an empty string otherwise. 62 # $(m64-flag): -m64 if the compiler supports it, or an empty string otherwise.`
/Linux-v5.15/Documentation/ia64/
D	ia64.rst	`21 compiler. And various software packages also compiled with an 22 IA-64 compliant GCC compiler. 35 compliant GCC compiler.`
/Linux-v5.15/arch/nios2/platform/
D	Kconfig.platform	`67 instruction. This will enable the -mhw-mul compiler flag. 73 instruction. Enables the -mhw-mulx compiler flag. 79 instruction. Enables the -mhw-div compiler flag. 87 the -mbmx compiler flag. 95 the -mcdx compiler flag. 100 Enables the -mcustom-fpu-cfg=60-1 compiler flag.`
/Linux-v5.15/Documentation/
D	memory-barriers.txt	139 appears to be maintained. Similarly, the compiler may also arrange the 244 Whether on DEC Alpha or not, the READ_ONCE() also prevents compiler 269 (*) It _must_not_ be assumed that the compiler will do what you want 271 WRITE_ONCE(). Without them, the compiler is within its rights to 319 in a given bitfield are protected by different locks, the compiler's 361 What is required is some way of intervening to instruct the compiler and the 623 Documentation/RCU/rcu_dereference.rst file: The compiler can and does 667 the compiler's ignorance from breaking your code. 701 are optional! Without the READ_ONCE(), the compiler might combine the 703 the compiler might combine the store to 'b' with other stores to 'b'. [all …]
/Linux-v5.15/kernel/bpf/
D	Kconfig	`7 # Used by archs to tell that they support BPF JIT compiler plus which 19 # Used by archs to tell that they want the BPF JIT compiler enabled by 39 bool "Enable BPF Just In Time compiler"`
/Linux-v5.15/Documentation/ABI/testing/
D	configfs-acpi	`49 - ASCII ASL compiler vendor ID 52 - ASL compiler version`
/Linux-v5.15/Documentation/core-api/
D	unaligned-memory-access.rst	83 Fortunately things are not too complex, as in most cases, the compiler 100 Fortunately, the compiler understands the alignment constraints, so in the 102 Therefore, for standard structure types you can always rely on the compiler 106 Similarly, you can also rely on the compiler to align variables and function 126 For a natural alignment scheme, the compiler would only have to add a single 131 structure type. This GCC-specific attribute tells the compiler never to 137 architectural alignment requirements. However, again, the compiler is aware
/Linux-v5.15/include/xen/interface/
D	version.h	`29 char compiler[64]; member`
/Linux-v5.15/Documentation/process/
D	volatile-considered-harmful.rst	`40 compiler might think it knows what will be in shared_data, but the 46 necessary. But the compiler would also be prevented from optimizing access 54 by locks, but one also does not want the compiler "optimizing" register 69 hyperthreaded twin processor; it also happens to serve as a compiler`
/Linux-v5.15/Documentation/features/debug/stackprotector/
D	arch-support.txt	`4 # description: arch supports compiler driven stack overflow protection`
/Linux-v5.15/Documentation/x86/x86_64/
D	fsgs.rst	`31 thread and the compiler emits the FS: address prefix for accesses to these 125 FSGSBASE instructions compiler support 139 code and the compiler option -mfsgsbase has to be added. 192 In case the compiler does not support address spaces, inline assembly can`
/Linux-v5.15/tools/testing/selftests/arm64/mte/
D	Makefile	`27 $(warning compiler "$(CC)" does not support the ARMv8.5 MTE extension.)`
/Linux-v5.15/Documentation/kbuild/
D	llvm.rst	28 The compiler used can be swapped out via ``CC=`` command line argument to ``make``. 38 A single Clang compiler binary will typically contain all supported backends, 43 ``CROSS_COMPILE`` is not used to prefix the Clang compiler binary, instead
D	gcc-plugins.rst	`10 compiler [1]_. They are useful for runtime instrumentation and static analysis. 16 Plugin source files have to be compilable by a C++ compiler.`
/Linux-v5.15/arch/mips/alchemy/
D	Platform	`32 # compiler picks the board one. If they don't, it will make sure`
/Linux-v5.15/Documentation/dev-tools/
D	kasan.rst	22 validity checks before every memory access and, therefore, require a compiler 32 still requires a compiler version that supports memory tagging instructions. 53 ``CONFIG_KASAN_INLINE``. Outline and inline are compiler instrumentation types. 239 With inline instrumentation, instead of making function calls, the compiler 272 instrumentation, a ``brk`` instruction is emitted by the compiler, and a 286 hardware memory tagging support instead of compiler instrumentation and 382 Software KASAN modes use compiler instrumentation to insert validity checks. 406 Note that disabling compiler instrumentation (either on a per-file or a 410 tag-based mode that does not use compiler instrumentation.

12 3 4 5 6