EDG Build-Time #define Surface

cicc embeds the complete Edison Design Group front-end configuration as a single hand-rolled case 0xE1u: block inside the option dispatcher sub_617BD0 at 0x617BD0. When the dispatcher is fed option index 0xE1 (the --gen_config operation, paired with the file-open setter 0xE0 that writes dword_4D04944=1, dword_4D0493C=0, dword_4D04910=1 and rebinds qword_4F07510 away from stderr), it emits 748 preprocessor directives to the sink file pointer at 0x4F07510 — 558 numeric #define X N entries, 85 string/enum #define X "s" entries, 103 informational /* X not defined */ comments, and 2 narrative banner lines. The directives reproduce the exact INCLUDE/edg_*_cfg.h header that EDG ships to downstream tooling, so a third party can re-link front_end.a against an identically-configured driver. Every value is a compile-time constant of the cicc binary itself; nothing here is reachable from the command line at runtime — these are bake-time switches that froze the EDG personality when cicc was linked, and the dump operation is the only way to recover them post-hoc.

The 643-entry list provided to this page (/tmp/build_defines.txt) is the deduplicated subset of identifiers reachable via uppercase-only string scan and consequently omits the 105 macros that are emitted as /* ... not defined */ comments. Both halves matter: the negative space (what EDG explicitly disabled) is as load-bearing for ABI matching as the positive defines, so this page documents the full 748-line surface but anchors the categorical buckets on the 643 enabled identifiers.

Dispatcher Entry Point and Output Sink

The dispatcher fragment is structurally a single 753-line straight-line case ending in sub_88CDC0(); v308 = 1; continue;. There is no loop, no table lookup, no string sort: every define is a literal fprintf(qword_4F07510, "#define %s %td\n", "X", N) instruction emitted in source order. This is one of the largest single basic blocks in cicc (>20 KiB of unique fmt-strings) and is the primary reason cicc_full.c exceeds 11 M lines after IDA decompilation.

CONFIDENCE: High for entry point, sink address, opcode, and the 748 emitted strings (extracted directly from decompiled case 0xE1u). Medium for the semantics of individual switches — names are self-describing in most cases, but a handful (TARG_LIBGCC_CMP_RETURN_MODE, BUILTIN_VA_LIST_OVERRIDE_TYPE_NAME value "__gnuc_va_list") require EDG documentation to interpret.

Category Map (643 enabled defines)

The identifiers cluster into eight families by prefix. Counts below sum to the 643 enabled defines; the additional 105 not defined placeholders mostly belong to TARG_* (fixed-point types, far-pointer arithmetic) and DEFAULT_* (rare modes like DEFAULT_AUTOMATIC_INSTANTIATION_MODE).

Each category is detailed below with 5-15 representative keys and their baked values as observed in this cicc build.

1. ABI compatibility (6 keys)

These freeze the C++ ABI shape. The values reflect the Itanium ABI (IA64_ABI = 1) plus EDG's compatibility-version dial.

2. Target attributes — TARG_* (~106 keys)

The largest family. Encodes the data model. cicc targets x86-64 (LP64) host-side and emits to a separate device pipeline; the values below are the host side that the EDG front-end uses for sizeof/alignof in constant evaluation.

The 26 TARG_*_FIXED_POINT, TARG_*_NEAR_POINTER, TARG_*_FAR_POINTER, and TARG_*_SIGNED_ACCUM keys are all emitted as /* X not defined */ — EDG declares them in its master header set but they have no meaning on x86-64.

3. Default language-mode toggles — DEFAULT_* (~130 keys)

These are the initial values of EDG runtime feature flags before any --c++14 / --gnu++17 / -std=gnu++20-equivalent CLI option flips them. Numeric values for version dials are encoded as MMmmpp-style integers.

4. Feature capability gates — *_ENABLING_POSSIBLE (~16 keys)

Distinct from DEFAULT_*_ENABLED. A _POSSIBLE value of 0 hard-disables the feature regardless of CLI flags — the front end will reject -fexceptions if EXC_SPEC_IN_FUNC_TYPE_ENABLING_POSSIBLE = 0. All _POSSIBLE keys in this cicc build are 1.

5. Compiler-emulation flags

6. Macro emission policies — MACRO_DEFINED_WHEN_* / DEFINE_MACRO_WHEN_*

Controls whether the predefined macros (the things visible to user code as __cpp_*, __GXX_*, etc.) are emitted into the preprocessing context when a feature is active.

7. IL / lowering pipeline switches

These instruct the EDG-to-NVVM lowering layer (run before cicc hands off to its LLVM core) what to expand vs. preserve.

8. Host attributes — HOST_* (7 keys)

What the compiler binary runs on — distinct from TARG_* (what it generates code for).

9. Driver / integration identity

10. Diagnostics & instrumentation (25 keys)

11. Other (239 catch-all)

Highlights from the bulk: path constants, token-handling, generated-C personality, name-mangling.

QUIRK Callouts

QUIRK 1 — ABI_COMPATIBILITY_VERSION = 9999. EDG's source dial uses 9999 as a sentinel meaning "latest known". It is not a literal version number. Downstream code paths that compare against this value must treat any 4-digit-and-above reading as "current". Pairs with DRIVER_COMPATIBILITY_VERSION = 9999 — together they mean cicc never advertises that its own ABI is older than the latest EDG point release, even when emulating older personalities via CLI overrides.

QUIRK 2 — TARG_SUPPORTS_ARM64 = 0 despite NVIDIA shipping aarch64 CUDA. This is the host arm64 support flag for the EDG front end's own arithmetic preview, not the device target. cicc generates NVVM IR; the actual aarch64 codegen happens in cudafe++/nvcc host-side tooling and is not exercised here. Build a Grace-Hopper-host cicc and this would flip — but the x86-64 cicc binary documented in this wiki has it hard-zeroed.

QUIRK 3 — DEFAULT_GNU_VERSION = 80100 (gcc 8.1.0) is anachronistic. NVIDIA's cicc v13.0 advertises a gcc-8.1.0 emulation default. Modern host toolchains routinely run gcc 12-14, so users who don't pass an explicit -ccbin/--use_fast_math/--gnu_version end up with cicc claiming a 2018-era g++. The disagreement matters when consumers inspect __GNUC__ to gate <bit>, std::format, or other C++20+ features in headers cicc preprocesses.

QUIRK 4 — DEFAULT_AUTO_TYPE_SPECIFIER_ENABLED = 0. C++11's auto type specifier is off by default in EDG; the runtime driver flips it via -std=c++11+ but the raw EDG personality is C++03-shaped. This is harmless in normal nvcc usage because the driver always supplies a -std= flag, but it bites anyone embedding front_end.a directly.

QUIRK 5 — IMPLEMENTATION_SUPPORTS_MULTIPLE_THREADS = 0. Despite NVIDIA's cicc using parallel device compilation pipelines downstream, the EDG front end itself declares non-threadsafe. The --threads mechanism added in CUDA 11.5 spawns separate cicc processes, not threads inside one cicc, so this flag is structurally correct — but easy to mistake for an indicator of a serial compiler. Cross-reference infra/concurrent-compilation.md.

QUIRK 6 — VERSION_NUMBER is a string, not an integer. The dispatcher emits #define VERSION_NUMBER "6.6" (note the embedded quotes — verified at cicc_full.c:1193119, format "#define %s %s\n"), distinct from the integer-valued VERSION_NUMBER_FOR_MACRO 606 (line 1193120, format "#define %s %td\n"). The two halves of the EDG version dial are not interchangeable: code that reads VERSION_NUMBER as an integer in preprocessing will see a string-literal token, not a numeric comparator. The companion GNU_TARGET_VERSION_NUMBER = 100300 and DEFAULT_GNU_ABI_VERSION = 30200 are integer-valued.

Pre-Defined Macro Layer (downstream of 0xE1)

The dump is not the only consumer of these defines: every macro that gets predefined into user translation units (__GNUC__, __cplusplus, __cpp_constexpr, __cpp_lambdas, …) is gated by the MACRO_DEFINED_WHEN_* family above. The actual macro definitions flow from a parallel table walked by sub_88BDE0 (the case 0xE2u consumer) and by per-mode initialisers in the EDG predefined-macro file (PREDEFINED_MACRO_FILE_NAME, defined here, points to the file under EDG_AUXILIARY_INFO_DIR_NAME/include). The --gen_config output is therefore the upper-half mirror of what user code sees as macros — modify a DEFAULT_* here and the lower-half changes automatically.

How to Reproduce the Dump

# The driver-side switch is --gen_config; cicc opcode is 0xE1.
# Direct invocation (the EDG-style long form has been preserved):
cicc --gen_config --gen_config_file edg_cfg.h <minimal.cu>

# The output is identical bytewise to the 748 fprintf calls in case 0xE1u.
# Use this to diff cicc builds across CUDA versions to detect personality drift.
diff <(cicc-13.0 --gen_config ...) <(cicc-12.6 --gen_config ...)

A clean output looks like:

/* Configuration data for Edison Design Group C/C++ Front End */
/* version 6.6, built on <date> at <time>. */

#define ABI_CHANGES_FOR_ARRAY_NEW_AND_DELETE 1
#define ABI_CHANGES_FOR_CONSTRUCTION_VTBLS 1
#define ABI_CHANGES_FOR_COVARIANT_VIRTUAL_FUNC_RETURN 1
...
#define WRITE_SIGNOFF_MESSAGE 1

/* Legacy configuration: <unnamed> */
#define LEGACY_TARGET_CONFIGURATION_NAME NULL

The build-date strings come from off_4B6EB10 and off_4B6EB08[0] in .rodata — they are the C macros __DATE__/__TIME__ evaluated at cicc link time, not at runtime.

Cross-References

• pipeline/edg.md — EDG 6.6 frontend, dispatcher overview, and the CLI options that feed sub_617BD0
• targets/index.md — Where the TARG_* host-side values are converted into per-SM device attributes
• config/cli-flags.md — The 0x150-entry option table that includes 0xE0u/0xE1u/0xE2u
• config/env-vars.md — Parallel runtime config surface (24 environment variables); the build-time defines on this page are the static counterpart
• infra/concurrent-compilation.md — Why IMPLEMENTATION_SUPPORTS_MULTIPLE_THREADS=0 is structurally correct

Open Follow-Ups

• The 105 /* X not defined */ placeholders are not enumerated here; build a diff against the EDG public egcfg.h to confirm which are EDG-internal vs. genuinely unused on x86-64 LP64.
• Five *_INT_KIND defines (TARG_BOOL_INT_KIND, TARG_CHAR16_T_INT_KIND, TARG_CHAR32_T_INT_KIND, TARG_PTRDIFF_T_INT_KIND, TARG_SIZE_T_INT_KIND) emit cast expressions (((an_integer_kind)ik_long)) rather than literal integers; the an_integer_kind enum is defined inside front_end.a and is not currently mirrored in this wiki.
• The companion opcode 0xE2u (sub_88BDE0) emits named legacy target configurations. The set of recognised names and their value overlays is undocumented.
• Cross-version drift: comparing the 748-line surface across CUDA 11.x → 12.x → 13.x would expose which EDG personality changes ride along with each toolkit release. This is the most direct way to date a stripped cicc binary.

CONFIDENCE: Categories and counts are mechanically derived from cicc_full.c and /tmp/build_defines.txt. Quirks are interpretive — flagged accordingly.