GCC

https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/
Admin
GCC is a GNU compiler collection that supports multiple programming languages including C, C++,...
Tokens:774,058
Snippets:8,850
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### CPU Detection Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/x86-Built-in-Functions.html

Example demonstrating how to use __builtin_cpu_init and __builtin_cpu_supports for dynamic function resolution based on CPU features.

```c
static void (*resolve_memcpy (void)) (void)
{
  // ifunc resolvers fire before constructors, explicitly call the init
  // function.
  __builtin_cpu_init ();
  if (__builtin_cpu_supports ("ssse3"))
    return ssse3_memcpy; // super fast memcpy with ssse3 instructions.
  else
    return default_memcpy;
}

void *memcpy (void *, const void *, size_t)
     __attribute__ ((ifunc ("resolve_memcpy")));

```

--------------------------------

### RTM Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/x86-transactional-memory-intrinsics.html

Example demonstrating the usage of _xbegin, _xend, and _xabort with retry and fallback logic.

```APIDOC
## RTM Example

### Description
This example shows how to handle `_XABORT_RETRY` and provides a fallback path for other transaction failures.

### Code
```c
#include <immintrin.h>

int n_tries, max_tries;
unsigned status = _XABORT_EXPLICIT;
...

for (n_tries = 0; n_tries < max_tries; n_tries++) 
  {
    status = _xbegin ();
    if (status == _XBEGIN_STARTED || !(status & _XABORT_RETRY))
      break;
  }
if (status == _XBEGIN_STARTED) 
  {
    ... transaction code...
    _xend ();
  } 
else 
  {
    ... non-transactional fallback path...
  }

```

Note that, in most cases, the transactional and non-transactional code must synchronize together to ensure consistency.
```

--------------------------------

### RTM Transaction Handling Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/x86-transactional-memory-intrinsics.html

Demonstrates how to start an RTM transaction, handle retries, and implement a fallback path for failures. Ensure to include `<immintrin.h>` for these intrinsics.

```c
#include <immintrin.h>

int n_tries, max_tries;
unsigned status = _XABORT_EXPLICIT;
...

for (n_tries = 0; n_tries < max_tries; n_tries++) 
  {
    status = _xbegin ();
    if (status == _XBEGIN_STARTED || !(status & _XABORT_RETRY))
      break;
  }
if (status == _XBEGIN_STARTED) 
  {
    ... transaction code...
    _xend ();
  } 
else 
  {
    ... non-transactional fallback path...
  }


```

--------------------------------

### Example Output with -MQ

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Preprocessor-Options.html

This example shows the output when using -MQ, demonstrating how special characters in the target are quoted for Make.

```makefile
$$(objpfx)foo.o: foo.c

```

--------------------------------

### Function Alignment Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Optimize-Options.html

Illustrates various ways to specify function alignment using the -falign-functions option. This option optimizes code performance by aligning function starts to specific byte boundaries.

```c
-falign-functions=32
```

```c
-falign-functions=24
```

```c
-falign-functions=32:7
```

```c
-falign-functions=64:7:32:3
```

--------------------------------

### Symbolic Output Operand Example (i386)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Extended-Asm.html

This example shows how to use symbolic names for operands, which can improve readability and maintainability by avoiding manual reordering of operand indices. It achieves the same result as the basic example.

```c
uint32_t Mask = 1234;
uint32_t Index;

  asm ("bsfl %[aMask], %[aIndex]"
     : [aIndex] "=r" (Index)
     : [aMask] "r" (Mask)
     : "cc");

```

--------------------------------

### Example Output with -MT

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Preprocessor-Options.html

This example shows the output when using -MT, where the target is set directly without special quoting.

```makefile
$(objpfx)foo.o: foo.c

```

--------------------------------

### GCC Developer Pass Examples

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Developer-Options.html

Examples demonstrating the usage of GCC developer options for enabling/disabling specific optimization passes.

```c
# disable ccp1 for all functions
   -fdisable-tree-ccp1
```

```c
# disable complete unroll for function whose cgraph node uid is 1
   -fenable-tree-cunroll=1
```

```c
# disable gcse2 for functions at the following ranges [
# 1,1],
# [300,400],
# and [400,1000]
# disable gcse2 for functions foo and foo2
   -fdisable-rtl-gcse2=foo,foo2
```

```c
# disable early inlining
   -fdisable-tree-einline
```

```c
# disable ipa inlining
   -fdisable-ipa-inline
```

```c
# enable tree full unroll
   -fenable-tree-unroll
```

--------------------------------

### Fast Enumeration Example with Foundation Library

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Using-fast-enumeration.html

A complete example demonstrating fast enumeration with `NSArray` and `NSLog` from a Foundation library. This iterates over string objects in an array.

```objectivec
NSArray *array = [NSArray arrayWithObjects: @"1", @"2", @"3", nil];
NSString *object;

for (object in array)
  NSLog (@"Iterating over %@", object);
```

--------------------------------

### SARIF Output Examples

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Diagnostic-Message-Formatting-Options.html

These examples demonstrate how to specify SARIF output for diagnostics, including different versions and filenames. Use these options to direct diagnostic information into SARIF-compliant files for structured analysis.

```bash
-fdiagnostics-add-output=sarif:version=2.1,file=foo.2.1.sarif
-fdiagnostics-add-output=sarif:version=2.2-prerelease,file=foo.2.2.sarif
```

--------------------------------

### Example with Dialect-Specific Instruction and Special Characters

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Extended-Asm.html

This example shows a dialect-specific instruction ('xchg') and the use of '%%' to output a literal '%'. It highlights differences between AT&T and Intel syntax.

```c++
"xchg{l}\t{%%}ebx, %1"
```

--------------------------------

### i386 asm goto Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Extended-Asm.html

Demonstrates a basic 'asm goto' for i386 architecture, showing how to reference a label using positional format.

```c
asm goto (
    "btl %1, %0\n\t"
    "jc %l2"
    : /* No outputs. */
    : "r" (p1), "r" (p2) 
    : "cc"
    : carry);

return 0;

carry:
return 1;

```

--------------------------------

### Example Stack Usage Warning (Static)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Warning-Options.html

Example warning message when static stack usage exceeds the specified limit.

```text
warning: stack usage is 1120 bytes
```

--------------------------------

### Example of Multiple Assembler Dialects (x86)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Extended-Asm.html

This example demonstrates how to use dialect-specific assembly instructions. The 'bt' instruction varies between AT&T and Intel syntax for x86.

```c++
"bt{l %[Offset],%[Base] | %[Base],%[Offset]}; jc %l2"
```

--------------------------------

### Basic Extended Asm Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Extended-Asm.html

A simple i386 example demonstrating how to copy a C variable to another and perform an arithmetic operation using extended `asm`. This snippet shows basic input and output operand usage.

```c
int src = 1;
int dst;

asm ("mov %1, %0\n\t"
    "add $1, %0"
    : "=r" (dst) 
    : "r" (src));

printf("%d\n", dst);

```

--------------------------------

### Example Stack Usage Warning (Dynamic Unbounded)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Warning-Options.html

Example warning message when dynamic stack usage is unbounded and exceeds the specified limit.

```text
warning: stack usage might be unbounded
```

--------------------------------

### Example Stack Usage Warning (Dynamic Bounded)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Warning-Options.html

Example warning message when dynamic stack usage is bounded and exceeds the specified limit.

```text
warning: stack usage might be 1648 bytes
```

--------------------------------

### Label Alignment Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Optimize-Options.html

Shows how to align branch targets using the -falign-labels option. This option is analogous to -falign-functions but applies to labels.

```c
-falign-labels=n
```

```c
-falign-labels=n:m
```

```c
-falign-labels=n:m:n2
```

```c
-falign-labels=n:m:n2:m2
```

--------------------------------

### Example: Array Encoding

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Type-encoding.html

Demonstrates the compiler encoding for an array of integers.

```objective-c
int a[10];

```

```text
[10i]
```

--------------------------------

### Example of --prime-paths-lines Output

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Invoking-Gcov.html

Illustrates the output format for --prime-paths-lines, showing the number of paths covered and details on uncovered paths.

```text
paths covered 12 of 15
path  2 not covered: lines 8 8(false) 11(true) 11 13(true) 13(true) 14 17
path  3 not covered: lines 8 8(false) 11(true) 11 13(true) 13(false) 16 17
path  4 not covered: lines 8 8(false) 11(true) 11 13(false) 16 17

```

--------------------------------

### Example of Verbose Assembly Output

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Code-Gen-Options.html

This example shows the C source code and the resulting verbose assembly output generated by GCC with the -fverbose-asm option. The comments provide details about the compiler, source lines, and high-level expression mapping.

```c
int test (int n)
{
  int i;
  int total = 0;

  for (i = 0; i < n; i++)
    total += i * i;

  return total;
}

```

```assembly
	.file	"test.c"
# GNU C11 (GCC) version 7.0.0 20160809 (experimental) (x86_64-pc-linux-gnu)
  [...snip...]
# options passed:
  [...snip...]

	.text
	.globl	test
	.type	test, @function
test:
.LFB0:
	.cfi_startproc
# test.c:4:   int total = 0;
	xorl	%eax, %eax	# <retval>
# test.c:6:   for (i = 0; i < n; i++)
	xorl	%edx, %edx	# i
.L2:
# test.c:6:   for (i = 0; i < n; i++)
	cmpl	%edi, %edx	# n, i
	 jge	.L5	#
# test.c:7:     total += i * i;
	movl	%edx, %ecx	# i, tmp92
	imull	%edx, %ecx	# i, tmp92
# test.c:6:   for (i = 0; i < n; i++)
	incl	%edx	# i
# test.c:7:     total += i * i;
	addl	%ecx, %eax	# tmp92, <retval>
	jmp	.L2	#
.L5:
# test.c:10: }
	ret
	.cfi_endproc
.LFE0:
	.size	test, .-test
	.ident	"GCC: (GNU) 7.0.0 20160809 (experimental)"
	.section	.note.GNU-stack,"",@progbits

```

--------------------------------

### _xbegin

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/x86-transactional-memory-intrinsics.html

Starts a Restricted Transactional Memory (RTM) transaction. Returns _XBEGIN_STARTED on success. On abort, it returns a bitmask indicating the reason for failure.

```APIDOC
## _xbegin

### Description
Starts a RTM (Restricted Transactional Memory) transaction. Returns `_XBEGIN_STARTED` when the transaction started successfully (note this is not 0, so the constant has to be explicitly tested).
If the transaction aborts, all side effects are undone and an abort code encoded as a bit mask is returned.

### Return Value
`unsigned` - `_XBEGIN_STARTED` on success, or a bit mask indicating the abort reason on failure.
```

--------------------------------

### Enable Built-in Functions Selectively

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/C-Dialect-Options.html

Example macros to selectively enable built-in functions when using options like -fno-builtin or -ffreestanding.

```c
#define abs(n)          __builtin_abs ((n))
#define strcpy(d, s)    __builtin_strcpy ((d), (s))
```

--------------------------------

### Functions for DMA setup

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/ARC-SIMD-Built-in-Functions.html

These functions configure DMA channels. The first argument must be a 3-bit compile-time constant indicating the DMA channel.

```APIDOC
## __builtin_arc_vdiwr

### Description
Writes to a DMA channel configuration register.

### Signature
void __builtin_arc_vdiwr (const int, int)

### Parameters
- `const int`: A 3-bit compile-time constant specifying the DMA channel (DR0-DR7).
- `int`: The value to write.

## __builtin_arc_vdowr

### Description
Writes to a DMA channel configuration register.

### Signature
void __builtin_arc_vdowr (const int, int)

### Parameters
- `const int`: A 3-bit compile-time constant specifying the DMA channel (DR0-DR7).
- `int`: The value to write.
```

--------------------------------

### C++ CTAD Unsupported Guide Pattern

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/C_002b_002b-Dialect-Options.html

Shows a pattern to suppress the -Wctad-maybe-unsupported warning by providing a deduction guide with an incomplete parameter type. This guide will not be considered, effectively opting out of CTAD for the type.

```cpp
struct allow_ctad_t;
template <typename T> struct S {
  S(T) { }
};
S(allow_ctad_t) -> S<void>;

```

--------------------------------

### Initializing Global Variables with +load (Correct)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Executing-code-before-main.html

This example shows the correct way to initialize global variables using the +load method, ensuring they are ready before main execution.

```objectivec
@implementation FileStream

+ (void)load
{
    Stdin = [[FileStream new] initWithFd:0];
    Stdout = [[FileStream new] initWithFd:1];
    Stderr = [[FileStream new] initWithFd:2];
}

/* Other methods here */
@end

```

--------------------------------

### Interactive Program Startup Notice (GNU GPL)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Copying.html

Display this short notice when your program starts in interactive mode to inform users about its free software status and warranty limitations. It directs users to commands for more details.

```text
program Copyright (C) year name of author 
This program comes with ABSOLUTELY NO WARRANTY; for details type ‘show w’.
This is free software, and you are welcome to redistribute it
under certain conditions; type ‘show c’ for details.

```

--------------------------------

### Compiling app.c with coverage and checking symbols

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Freestanding-Environments.html

Demonstrates compiling the app.c file with the --coverage flag and using 'nm' to inspect the generated object file for coverage-related symbols.

```bash
$ gcc --coverage -c app.c
$ nm app.o
0000000000000000 r a
0000000000000030 T application
0000000000000000 t can_decode
                 U fgetc
                 U fputc
0000000000000000 b __gcov0.application
0000000000000038 b __gcov0.can_decode
0000000000000000 d __gcov_.application
00000000000000c0 d __gcov_.can_decode
                 U __gcov_exit
                 U __gcov_init
                 U __gcov_merge_add
                 U stdin
                 U stdout
0000000000000161 t _sub_D_00100_1
0000000000000151 t _sub_I_00100_0

```

--------------------------------

### Display All GCC Options (--help)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Overall-Options.html

Use --help to print a description of all command-line options understood by GCC to standard output. If -v is also specified, --help is passed to subprocesses.

```gcc
gcc --help
```

--------------------------------

### Example of --prime-paths-source Output

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Invoking-Gcov.html

Demonstrates the output format for --prime-paths-source, detailing basic blocks, decisions, and line numbers for uncovered paths.

```text
path 10 not covered:
BB  3:           8:  for (i = 0; i < 10; i++)
BB  3:           9:    total += i;
BB  4: (false)   8:  for (i = 0; i < 10; i++)
BB  5: (true)   11:  int v = total > 100 ? 1 : 2;
BB  6:          11:  int v = total > 100 ? 1 : 2;
BB  8: (false)  13:  if (total != 45 && v == 1)
BB 11:          16:    printf ("Success\n");
BB 12:          17:  return 0;

```

--------------------------------

### Display Options by Class (--help=class)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Overall-Options.html

Use the extended --help=syntax to display options belonging to specific classes like 'optimizers', 'warnings', or 'target'. This allows filtering the displayed options.

```gcc
gcc --help=optimizers
```

```gcc
gcc --help=warnings
```

```gcc
gcc --help=target
```

```gcc
gcc --help=params
```

--------------------------------

### Loop Alignment Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Optimize-Options.html

Demonstrates the syntax for loop alignment using the -falign-loops option. This option helps optimize loop performance by aligning loop structures.

```c
-falign-loops=n
```

```c
-falign-loops=n:m
```

```c
-falign-loops=n:m:n2
```

--------------------------------

### Initializing __memx Pointer

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Named-Address-Spaces.html

Illustrates the initialization of a pointer 'pfoo' located in static storage with a 24-bit address from the __memx address space.

```c
extern const __memx char foo;
const __memx void *pfoo = &foo;
```

--------------------------------

### Wrapper for Variadic Functions using __builtin_va_arg_pack

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Constructing-Calls.html

This example demonstrates how to create a wrapper for a variadic function like `myprintf` using `__builtin_va_arg_pack`. It's suitable for inline functions that are always inlined and helps avoid preprocessor macros.

```c
extern int myprintf (FILE *f, const char *format, ...);
extern inline __attribute__ ((__gnu_inline__)) int
myprintf (FILE *f, const char *format, ...)
{
  int r = fprintf (f, "myprintf: ");
  if (r < 0)
    return r;
  int s = fprintf (f, format, __builtin_va_arg_pack ());
  if (s < 0)
    return s;
  return r + s;
}
```

--------------------------------

### strncpy Warning Example (Buffer Size)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Warning-Options.html

This example shows a strncpy call where the destination buffer size is used as the bound, potentially leading to non-NUL-terminated results. GCC diagnoses this.

```c
void copy (const char *s)
{
  char buf[80];
  strncpy (buf, s, sizeof buf);
  …
}
```

--------------------------------

### Display Enabled Optimizations at -O2

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Overall-Options.html

Use -Q with --help=optimizers to discover which optimizations are enabled at a specific optimization level, such as -O2.

```bash
-Q -O2 --help=optimizers

```

--------------------------------

### Side Effect Order Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Non-bugs.html

The order of evaluation of side effects in function arguments is not guaranteed by the C or C++ standards. This example demonstrates a call where the order of i++ increments is undefined.

```c
void func (int, int);

int i = 2;
func (i++, i++);

```

--------------------------------

### Packed Structure Member Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Common-Variable-Attributes.html

The `packed` attribute ensures a structure member has the smallest possible alignment. This example shows the `x` member packed to immediately follow `a` without padding.

```c
struct foo
{
  char a;
  int x[2] __attribute__ ((packed));
};

```

--------------------------------

### AVR MASK1 Built-in Function Examples

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/AVR-Built-in-Functions.html

Examples illustrating the use of __builtin_avr_mask1 for rotating bit masks. This function is an optimization for bit shifting operations when the offset is known and within a specific range.

```c
__builtin_avr_mask1 (1, offs)      // same like  1 << offs
```

```c
__builtin_avr_mask1 (~1, offs)     // same like  ~(1 << offs)
```

```c
__builtin_avr_mask1 (0x80, offs)   // same like  0x80 >> offs
```

```c
__builtin_avr_mask1 (~0x80, offs)  // same like  ~(0x80 >> offs)
```

--------------------------------

### AVR INSERT_BITS Built-in Function Examples

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/AVR-Built-in-Functions.html

Examples demonstrating the use of __builtin_avr_insert_bits for manipulating bits within a byte based on a map. This function is useful for adjusting values to non-contiguous port layouts.

```c
// same as val, bits is unused
__builtin_avr_insert_bits (0xffffffff, bits, val);
```

```c
// same as bits, val is unused
__builtin_avr_insert_bits (0x76543210, bits, val);
```

```c
// same as rotating bits by 4
__builtin_avr_insert_bits (0x32107654, bits, 0);
```

```c
// high nibble of result is the high nibble of val
// low nibble of result is the low nibble of bits
__builtin_avr_insert_bits (0xffff3210, bits, val);
```

```c
// reverse the bit order of bits
__builtin_avr_insert_bits (0x01234567, bits, 0);
```

--------------------------------

### Register or Memory Output Operand Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Extended-Asm.html

This example illustrates using a combined constraint ('=rm') for an output operand, allowing the compiler to choose between a register or memory for the output. This is useful when the compiler might already have the value in a register.

```c
uint32_t c = 1;
uint32_t d;
uint32_t *e = &c;

asm ("mov %[e], %[d]"
   : [d] "=rm" (d)
   : [e] "rm" (*e));

```

--------------------------------

### Equivalent static initialization without compound literals

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Compound-Literals.html

Provides the equivalent initialization for static objects without using compound literals, illustrating the direct initialization syntax.

```c
static struct foo x = {1, 'a', 'b'};
static int y[] = {1, 2, 3};
static int z[] = {1, 0, 0};

```

--------------------------------

### Initializer list lifetime warning example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/C_002b_002b-Dialect-Options.html

Illustrates potential dangling pointer issues with std::initializer_list due to its underlying array's lifetime. The example shows how assignment or returning temporaries can lead to undefined behavior.

```c++
// li's initial underlying array lives as long as li
std::initializer_list<int> li = { 1,2,3 };
// assignment changes li to point to a temporary array
li = { 4, 5 };
// now the temporary is gone and li has a dangling pointer
int i = li.begin()[0] // undefined behavior
```

--------------------------------

### Display Target-Specific Options with Status

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Overall-Options.html

When used with -Q, this displays target-specific options along with their enabled, disabled, or set value. This example shows options for the ARM port.

```bash
  % gcc -Q -mabi=2 --help=target -c
  The following options are target specific:
  -mabi=                                2
  -mabort-on-noreturn                   [disabled]
  -mapcs                                [disabled]


```

--------------------------------

### Enable vtable verification (preinit)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Instrumentation-Options.html

Turns on runtime verification for virtual calls. 'preinit' builds runtime data structures before shared libraries are loaded.

```c++
-fvtable-verify=preinit
```

--------------------------------

### GCC Unterminated Character Constant Warning Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Incompatibilities.html

GCC issues warnings for unterminated character constants within failing preprocessing conditionals. This example demonstrates a case that would produce an error due to the apostrophe in the comment.

```c
#if 0
You can't expect this to work.
#endif

```

--------------------------------

### ARM 'notshared' Attribute Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/ARM-Type-Attributes.html

Use the 'notshared' attribute to prevent virtual tables and similar data for a class from being exported from a DLL on ARM targets like Symbian OS. The example shows how to export the constructor but not the virtual table.

```cpp
class __declspec(notshared) C {
public:
  __declspec(dllimport) C();
  virtual void f();
}

__declspec(dllexport)
C::C() {}

```

--------------------------------

### Enable 3DNow! Instructions

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/x86-Function-Attributes.html

Use the target attribute to enable the generation of 3DNow! instructions.

```c
__attribute__ ((target ("3dnow")))
```

--------------------------------

### PowerPC HTM Portable Transactional Execution Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/PowerPC-Hardware-Transactional-Memory-Built-in-Functions.html

A portable implementation of transactional execution using the high-level HTM inline functions (`__TM_begin`, `__TM_abort`, `__TM_end`). This example is designed to work on both PowerPC and S/390 systems and includes a retry mechanism with a fallback path.

```c
#include <htmxlintrin.h>

int num_retries = 10;
TM_buff_type TM_buff;

while (1)
  {
    if (__TM_begin (TM_buff) == _HTM_TBEGIN_STARTED)
      {
        /* Transaction State Initiated.  */
        if (is_locked (lock))
          __TM_abort ();
        ... transaction code...
        __TM_end ();
        break;
      }
    else
      {
        /* Transaction State Failed.  Use locks if the transaction
           failure is "persistent" or we've tried too many times.  */
        if (num_retries-- <= 0
            || __TM_is_failure_persistent (TM_buff))
          {
            acquire_lock (lock);
            ... non transactional fallback path...
            release_lock (lock);
            break;
          }
      }
  }


```

--------------------------------

### Basic Output Operand Example (i386)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Extended-Asm.html

This example demonstrates a basic output operand for the `bsfl` instruction. The output operand `Index` is placed in a register, allowing the compiler to choose the most efficient register. Use the generic 'r' constraint when a specific register is not required.

```c
uint32_t Mask = 1234;
uint32_t Index;

  asm ("bsfl %1, %0"
     : "=r" (Index)
     : "r" (Mask)
     : "cc");

```

--------------------------------

### GCC Specifier for Startup File Directories

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Spec-Files.html

Use %D to dump out a -L option for each directory that might contain startup files. If multilibs are supported, the current multilib directory is prepended.

```gcc-spec
%D
```

--------------------------------

### GCC Spec: Substitute `X` if switches starting with `-S` are specified

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Spec-Files.html

Use `%{S*:X}` to substitute `X` if one or more switches starting with `-S` are specified. If `%*` is in `X`, it's replaced by the matching part of the switch for each occurrence. A space is added after the last substitution if `%*` is at the end of the sequence.

```gcc-spec
%{mcu=*:--script=%*/memory.ld}
```

--------------------------------

### Initialize v2sf Vector

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/MIPS-Paired-Single-Support.html

Demonstrates initializing `v2sf` vector types, similar to aggregate initialization, and assigning values from individual floats.

```c
v2sf a = {1.5, 9.1};
v2sf b;
float e, f;
b = (v2sf) {e, f};
```

--------------------------------

### GCC Spec: Substitute all switches starting with `-S` that take arguments

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Spec-Files.html

Use `%{S*}` to substitute all switches given to GCC whose names start with `-S` and also take an argument. This includes switches like `-o`, `-D`, and `-I`. The substitution includes the space and generates two arguments.

```gcc-spec
%{S*}
```

--------------------------------

### Example of -Wformat-overflow=1

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Warning-Options.html

Demonstrates a potential buffer overflow scenario diagnosed by -Wformat-overflow=1. At this level, unknown numeric arguments are assumed to be 1 and unknown strings are empty, leading to a warning if the buffer is too small.

```c
void f (int a, int b)
{
  char buf [13];
  sprintf (buf, "a = %i, b = %i\n", a, b);
}
```

--------------------------------

### __builtin_tbeginc

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/S_002f390-System-z-Built-in-Functions.html

Generates the `tbeginc` machine instruction to start a constrained hardware transaction.

```APIDOC
## __builtin_tbeginc

### Description
Generates the `tbeginc` machine instruction starting a constrained hardware transaction. The second operand is set to `0xff08`.

### Function Signature
`void __builtin_tbeginc(void)`
```

--------------------------------

### Example of Clobbered Registers in VAX Assembly

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Extended-Asm.html

This example demonstrates the use of clobbered registers in VAX assembly. It lists registers 'r0' through 'r5' and 'memory' as clobbered, indicating that the 'movc3' instruction may modify them. The 'memory' clobber signifies that the assembly code performs memory operations beyond the explicitly defined operands.

```c
asm volatile ("movc3 %0, %1, %2"
                   : 
                   : "g" (from), "g" (to), "g" (count)
                   : "r0", "r1", "r2", "r3", "r4", "r5", "memory");

```

--------------------------------

### Print libgcc.a file name

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Developer-Options.html

Use this option when linking with -nostdlib or -nodefaultlibs but still needing to include libgcc.a. It helps in dynamically obtaining the correct path to libgcc.a.

```bash
gcc -nostdlib files… `gcc -print-libgcc-file-name`
```

--------------------------------

### C++ Implicit Copy-Assignment with Virtual Bases Example

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Copy-Assignment.html

This example demonstrates a scenario with virtual bases where the implicit copy-assignment behavior is unspecified. It includes a Base class, derived classes A and B inheriting virtually from Base, and a Derived class inheriting from A and B. The func function invokes the implicit copy-assignment for Derived objects.

```cpp
struct Base{
  char *name;
  Base(const char *n) : name(strdup(n)){
  }
  Base& operator= (const Base& other){
   free (name);
   name = strdup (other.name);
   return *this;
  }
};

struct A:virtual Base{
  int val;
  A():Base("A"){
  }
};

struct B:virtual Base{
  int bval;
  B():Base("B"){
  }
};

struct Derived:public A, public B{
  Derived():Base("Derived"){
  }
};

void func(Derived &d1, Derived &d2)
{
  d1 = d2;
}

```

--------------------------------

### Compile with C++20 Modules and Search Paths

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Preprocessor-Options.html

This command demonstrates compiling C++20 modules using -fmodules and -fsearch-include-path to locate module interface units and header units.

```c++
g++ -c -std=c++20 -fmodules -fsearch-include-path bits/stdc++.h bits/std.cc
```

--------------------------------

### typeof with a typename

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Typeof.html

Use `typeof` with a typename to refer to that type. This example refers to the type of pointers to `int`.

```c
typeof (int *)
```

--------------------------------

### Initialize static objects with compound literals (GNU extension)

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Compound-Literals.html

Shows how GCC allows initialization of static objects with compound literals, even when the initializer is not a constant, as a GNU extension.

```c
static struct foo x = (struct foo) {1, 'a', 'b'};
static int y[] = (int []) {1, 2, 3};
static int z[] = (int [3]) {1};

```

--------------------------------

### Initializing a Jump Table with Label Values

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Labels-as-Values.html

Illustrates initializing a static array with label addresses. This array can then be used as a jump table to select a label for a computed goto based on an index.

```c
static void *array[] = { &&foo, &&bar, &&hack };
```

--------------------------------

### Complex Integer Constant

Source: https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/Complex.html

Example of a complex integer constant with type `_Complex int` using the `i` suffix.

```c
3i
```
Tokens:
Raw