CLI Flag Inventory

Quick Reference: 20 Most Important CUDA-Specific Flags

These are the flags most commonly passed through -Xcudafe for CUDA development. The full inventory of 276 flags follows below.

cudafe++ accepts 276 command-line flags registered in a flat table at dword_E80060. The flags are not parsed directly from the binary's argv -- NVIDIA's driver compiler nvcc decomposes its own options and invokes cudafe++ with the appropriate low-level flags. Users never run cudafe++ directly; instead, they pass options through nvcc -Xcudafe <flag>, which strips the -Xcudafe prefix and forwards the remainder as a bare argument to the cudafe++ process.

The flag system is implemented in three functions within cmd_line.c:

Flag Table Structure

Each flag occupies a 40-byte entry in a contiguous array beginning at dword_E80060, with a maximum capacity of 552 entries (overflow triggers a panic via sub_40351D). The current count is tracked in dword_E80058.

struct flag_entry {                    // 40 bytes per entry
    int32_t   case_id;                 // dword_E80060[idx*10]    -- switch dispatch ID
    char*     name;                    // qword_E80068[idx*5]     -- long flag name string
    int16_t   short_char;              // word_E80070[idx*20]     -- single-char alias (0 if none)
    int8_t    is_valid;                // word_E80070[idx*20]+1   -- always 1
    int8_t    takes_value;             // byte_E80072[idx*40]     -- flag requires =<value> argument
    int32_t   visible;                 // dword_E80080[idx*10]    -- mode/action classification
    int8_t    is_boolean;              // byte_E80073[idx*40]     -- flag is on/off toggle
    int64_t   name_length;             // qword_E80078[idx*5]     -- strlen(name), precomputed
};

The flag-was-set bitmap at byte_E7FF40 spans 0x110 bytes (272 flag slots). When a flag is matched during parsing, the corresponding bit is set to record that the user explicitly provided it. This bitmap is zeroed by default_init before every compilation.

Registration Protocol

register_command_flag (sub_451F80) is called approximately 275 times from init_command_line_flags. Its prototype:

void register_command_flag(
    int    case_id,        // dispatch ID for the switch statement
    char*  name,           // "--name" (without the dashes)
    char   short_opt,      // single-letter alias, 0 for none
    char   takes_value,    // 1 if the flag requires =<value>
    int    mode_flag,      // visibility / classification
    char   enabled         // whether the flag is active
);

Some flags are registered as paired toggles -- --flag and --no_flag share the same case_id but set the target global to 1 or 0 respectively. These pairs are registered either by two calls to register_command_flag or by inline table population within init_command_line_flags.

Parsing Flow

proc_command_line (sub_459630) is the master CLI parser. It:

1. Calls init_command_line_flags to populate the flag table (once)
2. Allocates four hash tables for accumulating -D, -I, system include, and macro alias arguments
3. Adjusts nine diagnostic severities by default via sub_4ED400: four are suppressed (severity 3: errors 1373, 1374, 1375, 2330) and five are demoted to remark (severity 4: errors 1257, 1633, 111, 185, 175)
4. Enters the main loop over argv:
   • Scans for - prefix to identify flags
   • Handles -X short flags and --flag-name long flags
   • Handles --flag=value syntax via parse_flag_name_value (sub_451EC0)
   • Matches flag names against the registered table using strncmp against each entry's precomputed name_length
   • Dispatches to a giant switch(case_id) with 276 cases (IDs 0..275; case 0 is the default sink for unrecognized flag names)
5. Executes post-parsing dialect resolution (described below)
6. Opens output, error, and list files
7. Treats the remaining non-flag argv entry as the input filename

The -Xcudafe Pass-Through

Users never invoke cudafe++ directly. The intended usage path is:

nvcc --some-option -Xcudafe --diag_suppress=1234 source.cu

nvcc strips -Xcudafe and passes --diag_suppress=1234 directly to the cudafe++ process as an argv element. Multiple -Xcudafe arguments accumulate. Because cudafe++ flags use -- long-form prefixes, there is no ambiguity with nvcc's own flag namespace.

Certain nvcc flags like --expt-extended-lambda and --expt-relaxed-constexpr are translated by nvcc into the corresponding cudafe++ internal flags (--extended-lambda, --relaxed_constexpr) before invocation. Users do not need to know the internal names.

Flag Catalog by Category

The 276 flags are grouped below by functional category. Each table lists:

• ID -- the case_id used in the dispatch switch
• Flag -- the --name as registered (paired flags shown as name / no_name)
• Short -- single-character alias (dash required: -E, -C, etc.)
• Arg -- whether the flag takes a =<value> argument
• Effect -- what the flag does internally

Core EDG Flags (1--44)

These are standard Edison Design Group frontend options that predate NVIDIA's CUDA modifications.

NVIDIA CUDA-Specific Flags (45--89)

These flags are NVIDIA additions absent from stock EDG. They control CUDA compilation modes, device code generation, and host/device interaction.

Architecture and Host Compiler Flags (90--114)

These flags identify the target architecture and host compiler for compatibility emulation.

C++ Language Feature Toggle Flags (115--275)

The largest group -- approximately 120 paired boolean toggles that control individual C++ language features. Most are inherited from EDG's configuration surface. Each pair shares a case_id and sets a global variable to 1 (--flag) or 0 (--no_flag).

Precompiled Headers (115--121)

Core C++ Feature Toggles (122--170)

Include Paths and Module Support (167, 172, 256--265)

Note: These flags use non-contiguous IDs because sys_include and incl_suffixes are registered early, while the C++20 module flags use a separate ID range (256+).

Host Compiler and Language Feature Toggles (182--239)

Note: All IDs below are verified against the decompiled init_command_line_flags (sub_452010). Flags are registered by sub_451F80 (explicit call) or by inline array population. IDs are not sequential -- gaps exist where flags were removed or repurposed.

Late C++/Architecture/Output Flags (240--258)

Note: Many IDs in the 240-252 range serve double duty as both C/C++ standard selectors and feature toggles. The standard selection IDs are also cross-referenced in the Language Standard Selection section above.

Inline-Registered Paired Flags

Seven additional paired flags are registered through inline table population rather than calls to register_command_flag. They share the same entry structure but are populated directly into the array:

Language Standard Selection

Six language standard flags set dword_126EF68 (the internal __cplusplus / __STDC_VERSION__ value) and trigger corresponding mode changes:

C Standards

C++ Standards

When a C++ standard is selected, the post-parsing dialect resolution logic automatically enables the corresponding feature flags. For example, selecting --c++11 (value 201103) enables lambdas, rvalue references, auto type deduction, nullptr, variadic templates, and other C++11 features. The resolution logic also interacts with GCC/Clang version thresholds to determine which extensions are available.

Diagnostic Control Flags

The five diag_* flags (IDs 39--43) accept comma-separated lists of diagnostic numbers. The parser strips whitespace, splits on commas, and calls sub_4ED400(number, severity, 1) for each number:

--diag_suppress=1234,5678       # suppress errors 1234 and 5678
--diag_warning=20001            # demote CUDA error 20001 to warning
--diag_error=111                # promote diagnostic 111 to error
--diag_remark=185               # demote diagnostic 185 to remark
--diag_once=175                 # emit diagnostic 175 only once

The error number system is documented in Diagnostic System Overview. Numbers above 3456 in the internal range correspond to the 20000-series CUDA errors via the offset formula display_code = internal_code + 16543.

Post-Parsing Dialect Resolution

After the main parsing loop completes, proc_command_line executes a large block of dialect resolution logic that:

1. Resolves host compiler mode conflicts -- If both --gcc and --clang are set, or --cfront_2.1 is combined with modern modes, the resolution picks one and adjusts feature flags accordingly
2. Sets C++ feature flags from __cplusplus version -- Based on the value in dword_126EF68:
   • 199711 (C++98/03): baseline features only
   • 201103 (C++11): enables lambdas, rvalue refs, auto, nullptr, variadic templates, range-based for, delegating constructors, unrestricted unions, user-defined literals
   • 201402 (C++14): adds digit separators, generic lambdas, relaxed constexpr
   • 201703 (C++17): adds aligned new, exception spec in function type, structured bindings
   • 202002 (C++20): adds concepts, modules, coroutines
   • 202302 (C++23): adds latest features
3. Applies GCC version thresholds -- When in GCC compatibility mode, certain features are gated on the GCC version number stored in qword_126EF98 (default 80100 = GCC 8.1.0). Known thresholds:
   • 40299 (0x9D6B): GCC 4.2
   • 40599 (0x9E97): GCC 4.5
   • 40699 (0x9EFB): GCC 4.6
   • Higher versions enable progressively more features
4. Opens output files -- Error output, listing file, output file
5. Processes the input filename -- The remaining non-flag argv entry

Key Globals After Resolution

The set_flag / clear_flag Mechanism

Flag ID 199 (--set_flag / --clear_flag) provides a raw escape hatch. The argument is a flag name looked up in the off_D47CE0 table -- an array of {name, global_address} pairs. If the name is found, the corresponding global variable is set to the provided integer value (--set_flag=name=value) or cleared to 0 (--clear_flag=name). This mechanism allows nvcc to toggle internal EDG configuration flags that do not have dedicated CLI flag registrations.

Default Values

default_init (sub_45EB40) runs before proc_command_line and initializes approximately 350 global configuration variables. Notable non-zero defaults:

Conflict Detection

Before the main parsing loop, check_conflicting_flags (sub_451E80) verifies that flags 3, 193, 194, and 195 (no_line_commands, set_flag, clear_flag, and related flags) are not used in conflicting combinations. If any conflict is detected, error 1027 is emitted.

Inline-Registered Flags

init_command_line_flags (sub_452010) calls the helper register_command_flag (sub_451F80) 251 times. The remaining 25 flags reach the dispatch switch through a different mechanism: their entries are populated directly into the flag table by inline stores in sub_452010, bypassing the helper. The two registration mechanisms produce identical runtime behavior -- both result in valid 40-byte entries in the table at dword_E80060. The distinction is purely a source-level artifact, and is invisible from the parser's perspective.

There are two reasons a flag is registered inline rather than through the helper:

1. Non-default field values. A few flags need a visible bit pattern, target compiler gate, or takes_value configuration that the helper's parameter signature cannot express. Inline stores write the exact byte layout required.

2. Paired-toggle positive forms. EDG paired toggles register both --no_flag and --flag to the same case_id. The --no_flag form is registered through the helper (with the negation-bit flag set). The --flag form is then written inline at the next table slot, sharing the same case_id but with the negation bit clear. The helper is not parameterized for the positive form, so inline stores are the only path.

The 25 inline-registered flag names:

(The first row has 13 names; the second row has 15 names. The "approximately 25" figure in the wave-58 audit collapses the two c++11/c++0x aliases that share case ID 247, and the c11/c17/c23 C-mode group that share case IDs, into the lower count.)

Sum check. 251 helper-registered flag entries + 25 inline-registered entries = 276 total table entries. This matches the init_command_line_flags exit state, the dword_E80058 counter immediately after registration completes, and the case count of the dispatch switch (IDs 0..275, where 0 is the default sink for unrecognized command-line input).

Version Banners

The CLI exposes two distinct version-printing flags. They share the substring "version" in their long name but differ in case (--version vs. --Version), parsing case ID, format of the printed banner, and whether they terminate the process.

--version (ID 21, -v) -- continues execution

Case 21 in the dispatch switch writes the cudafe++ version banner to stdout via the standard print path, then falls through to the next iteration of the argv loop without calling exit(). The flag is used by build systems that want to query the compiler version while still receiving any subsequent flags on the same command line.

Banner format (lines emitted in order):

cudafe: NVIDIA (R) Cuda Language Front End
Portions Copyright (c) 2005, 2024-YYYY NVIDIA Corporation
Portions Copyright (c) 1988-2018, 2024 Edison Design Group Inc.
Based on Edison Design Group C/C++ Front End, version 6.6
Cuda compilation tools, release 13.0, V13.0.88

The YYYY placeholder is the current compilation year, sourced from a build-time constant. The string "1988-2018, 2024" is the EDG copyright span -- the two date ranges in a single Edison Design Group copyright line are an explicit choice by EDG, not a formatting artifact.

--Version (ID 92, -V) -- emits EDG portion banner then exit(1)

Case 92 in the dispatch switch writes a single EDG-portion copyright line to stdout, then calls exit(1) immediately. The exit code is the conventional "success but no compilation performed" value used by GNU-style version flags. No further argv processing occurs after case 92.

Banner string (single line):

Portions Copyright (c) 1988-2016 Edison Design Group Inc.

The "1988-2016" date range here is intentionally different from the "1988-2018, 2024" range printed by --version: case 92 emits the older, narrower EDG portion-only copyright form. The two banners do not share string data in .rodata; they are two separate string literals, embedded at distinct addresses. Tooling that grep's the binary for either banner should not assume the other will be present in the same form.

Cross-References

• Pipeline Overview -- Stage 2 is proc_command_line
• Diagnostic System Overview -- diag_suppress/diag_error flag handling
• Architecture Detection -- --target flag and SM version parsing
• Experimental Flags -- --set_flag/--clear_flag for internal feature gates
• EDG 6.6 Overview -- cmd_line.c source file context