dcc - Direct C Compiler

A C99 compliant C compiler with additions implementing many extensions and features, as well as arbirary-precision integer arithmetic.

The main feature that differentiates this compiler from others, is its ability to directly read, preprocess, tokenize, parse, assemble and link c source code, all at the same time, in a way allowing you to execute C code in an environment similar to that of an interactive commandline. If you are interested in how this is achieved, take a look at /include/drt/drt.h

Currently only able to target I386 and above, support for x86-64 is planned and already partially implemented.

Supported output formats are ELF, windows PE, as well as direct execution of generated code.

DCC supports AT&T inline assembly syntax, emulating gcc's __asm__ statement and the GNU assembler as well as direct parsing of assembly sources.

Using TPP as preprocessor to implement a fully featured perprocessor, DCC implements many GCC extensions such as __asm__, __builtin_constant_p, many __attribute__-s, __typeof__, __auto_type, and many more, including my own twist on awesome C extensions.

Development on DCC started on 17.04.2017, eversince then being the usual one-person project.

Current state:

Note that DCC is still fairly early in its development, meaning that anything can still change and that more features will be added eventually.

Link against windows PE binaries/libraries (*.dll).
Statically link against PE binaries (as in: clone everything from a *.dll)
Dynamically/Statically link against ELF binaries/libraries/object files (*, *.so, *.o)
Output windows PE binary/library (*.exe, *.dll).
Output linux ELF binary/library (*, *.so).
Output ELF relocatable object files (*.o)
Process and merge (link) multiple source-/object files/static libraries.
Compiling DCC is mainly tested and working on windows using Visual C or DCC itself. GCC and linux support is present, but may occasionally be broken.
Full STD-C compliance up to C99.
Full AT&T assembly support with many GNU assembler extensions (see below).
Full ELF binary target support.
Fully working live execution of C source code.
DCC can fully compile itself (And the result can compile itself again!)

Planned features:

Support for X86-64/AMD64 CPU architectures.
Compiling DCC on linux (most of the work's already there, but nothing's tested yet).
Compiling DCC with DCC (because every C compiler must be able to do that!).
Generation of debug information (recognizeable by gdb).
Finish many partially implemented features (see below).
Support for true thread-local storage (aka. segment-based)

Features (Compiler):

DCC as host compiler can easily be detected with defined(__DCC_VERSION__).
Using TPP as preprocessor, every existing preprocessor extension is supported, as well as all that are exclusive to mine.
Live-compilation-mode directly generates assembly.
C-conforming symbol forward/backward declaration.
K&R-C compatible
Full STD-C89/90 compliance
Full STD-C95 compliance
Full STD-C99 compliance
Supports all C standard types.
Supports 64-bit long long integrals (using double-register storage).
Supports all C control statements.
Supports C11 _Generic.
Supports C11 _Atomic (Not fully implemented).
Supports C99 _Bool.
Supports C99 __func__ builtin identifier.
Supports Variable declaration in if-expressions and for-initializers.
Supports nested function declaration, as well as access to variables from surrounding scopes.
Supports C++ lvalue types (int y = 10; int &x = y;).
Supports C structure bitfields
Support for GCC statement-expressions: int x = ({ int z = 10; z+20; }); // x == 30.
Support for __FUNCTION__ and __PRETTY_FUNCTION__, including use by concat with other strings: char *s = "Function " __FUNCTION__ " was called"; printf("%s\n",s);.
Support for GCC __sync_* builtin functions (__sync_val_compare_and_swap(&x,10,20)).
Supports all compiler-slangs for alignof: _Alignof, __alignof, __alignof__ and __builtin_alignof.
Support for compile-time type deduction from expressions: typeof, __typeof, __typeof__.
Support for GCC scoped labels: __label__.
Support for GCC-style inline assembly: __asm__("ret").
Support for MSVC fixed-length integer types: __int(8|16|32|64).
Support for GCC __auto_type (as well as special interpretation of auto when not used as storage class. - auto int x = 42 auto is storage class; auto y = 10; auto denotes automatic type deduction).
Support for C99 variable-length arrays: int x = 10; int y[x*2]; assert(sizeof(y) == 80);.
Support for old (pre-STDC: K&R-C) function declarations/implementations.
Support for new (post-STDC: C90+) function declarations/implementations.
Support for floating-point types (Assembly generator is not implemented yet).
Support for GCC x86 segment address space (__seg_fs/__seg_gs)
Debugging aids for pre-initializing local variables with 0xCC bytes and memory allocated using alloca with 0xAC.
Inherited from assembly: Named register identifiers.
- int x = %eax; (CPU-specific, on i386 compiles to mov %eax, x).
- int x = *(int *)%fs:0x18; (Can also be used to access segment register, on i386 compiles to movl %fs:(0x18), x).
Inherited from assembly: Get current text address.
- void *p = .; (Evaluates to the current text address with void * typing).
Use label names in expressions:
- void *p = &&my_label; my_label: printf("p = %p\n",p);
Support for new & old GCC structure/array initializer:
- dot-field: struct { int x,y; } p = { .x = 10, .y = 20 };
- field-collon: struct point { int x,y; } p = { x: 10, y: 20 };
- array-subscript: int alpha[256] = { ['a' ... 'z'] = 1, ['A' ... 'Z'] = 1, ['_'] = 1 };
Support for runtime brace-initializers: struct point p = { .x = get_x(), .y = get_y() };
Split between struct/union/enum, declaration and label namespaces:foo: struct foo foo; // Valid code and 3 different 'foo'
Support for unnamed struct/union inlining:
- union foo { __int32 x; struct { __int16 a,b; }; };
  - offsetof(union foo,x) == 0, offsetof(union foo,a) == 0, offsetof(union foo,b) == 2
Support for builtin functions offering special compile-time optimizations, or functionality (Every builtin can be queried with __has_builtin(...)):
- char const (&__builtin_typestr(type_or_expr t))[];
  - Accepting arguments just like 'sizeof', return a human-readable representation of the [expression's] type as a compile-time array of characters allocated in the '.string' section.
- _Bool __builtin_constant_p(expr x);
- expr __builtin_choose_expr(constexpr _Bool c, expr tt, expr ff);
- _Bool __builtin_types_compatible_p(type t1, type t2);
- void __builtin_unreachable(void) __attribute__((noreturn));
- void __builtin_trap(void) __attribute__((noreturn));
- void __builtin_breakpoint(void);
  - Emit a CPU-specific instruction to break into a debugging environment, or do nothing if the target CPU doesn't allow for such an instruction
- void *__builtin_alloca(size_t s);
- void *__builtin_alloca_with_align(size_t s, size_t a);
- void __builtin_assume(expr x),__assume(expr x);
- long __builtin_expect(long x, long e);
- const char (&__builtin_FILE(void))[];
- int __builtin_LINE(void);
- const char (&__builtin_FUNCTION(void))[];
- void *__builtin_assume_aligned(void *p, size_t align, ...);
- size_t __builtin_offsetof(typename T, members...);
- T (__builtin_bitfield(T expr, constexpr int const_index, constexpr int const_size)) : const_size;
  - Access a given sub-range of bits of any integral expression, the same way access is performed for structure bit-fields.
- typedef ... __builtin_va_list;
- void __builtin_va_start(__builtin_va_list &ap, T &start);
- void __builtin_va_end(__builtin_va_list &ap);
- void __builtin_va_copy(__builtin_va_list &dstap, __builtin_va_list &srcap);
- T __builtin_va_arg(__builtin_va_list &ap, typename T);
  - Compiler-provided var-args helpers for generating smallest-possible code
- int __builtin_setjmp(T &buf);
- void __builtin_longjmp(T &buf, int sig) __attribute__((noreturn));
  - Requires: sizeof(T) == __SIZEOF_JMP_BUF__
  - Compile-time best-result code generation for register save to 'buf'
  - Optimizations for 'sig' known to never be '0'
- void *__builtin_malloc(size_t s);
- void *__builtin_calloc(size_t c, size_t s);
- void *__builtin_realloc(void *p, size_t c, size_t s);
- void __builtin_free(void *p);
- void __builtin_cfree(void *p);
- void *__builtin_return_address(unsigned int level);
- void *__builtin_frame_address(unsigned int level);
- void *__builtin_extract_return_addr(void *p);
- void *__builtin_frob_return_address(void *p);
- void *__builtin_isxxx(void *p);
  - ctype-style builtin functions
- void *__builtin_memchr(void *p, int c, size_t s);
- void *__builtin_memrchr(void *p, int c, size_t s);
  - Additional functions are available for mem(r)len/mem(r)end/rawmem(r)chr/rawmem(r)len
- T __builtin_min(T args...);
- T __builtin_max(T args...);
- void __builtin_cpu_init(void);
- int __builtin_cpu_is(char const *cpuname);
- int __builtin_cpu_supports(char const *feature);
- char (&__builtin_cpu_vendor(char *buf = __builtin_alloca(sizeof(__builtin_cpu_vendor()))))[?];
- char (&__builtin_cpu_brand(char *buf = __builtin_alloca(sizeof(__builtin_cpu_brand()))))[?];
  - Returns a target-specific '\0'-terminated string describing the brand/vendor name of the host CPU. The length of the returned string is always constant and known at compile-time.
  - __builtin_cpu_init is required to be called first, and if the string cannot be determined at runtime, the returned string is filled with all '\0'-characters.
- uint16_t __builtin_bswap16(uint16_t x);
- uint32_t __builtin_bswap32(uint32_t x);
- uint64_t __builtin_bswap64(uint64_t x);
- int __builtin_ffs(int x);
- int __builtin_ffsl(long x);
- int __builtin_ffsll(long long x);
- int __builtin_clz(int x);
- int __builtin_clzl(long x);
- int __builtin_clzll(long long x);
  - Generate inline code with per-case optimizations for best results
- T __builtin_bswapcc(T x, size_t s = sizeof(T));
- int __builtin_ffscc(T x, size_t s = sizeof(T));
- int __builtin_clzcc(T x, size_t s = sizeof(T));
  - General purpose functions that works for any size
- void *__builtin_memcpy(void *dst, void const *src, size_t s);
  - Replace with inlined code for sizes known at compile-time
  - Warn about dst/src known to overlap
- void *__builtin_memmove(void *dst, void const *src, size_t s);
  - Optimize away dst == src cases
  - Hint about dst/src never overlapping
- void *__builtin_memset(void *dst, int byte, size_t s);
  - Replace with inlined code for sizes known at compile-time
- int __builtin_memcmp(void const *a, void const *b, size_t s);
  - Replace with compile-time constant for constant
  - Replace with inline code for sizes known at compile-time
- size_t __builtin_strlen(char const *s);
  - Resolve length of static strings at compile-time
Split between declaration and assembly name (aka. __asm__("foo") suffix in declarations)
Arbitrary size arithmetic operations (The sky's the limit; as well as your binary size bloated with hundreds of add-instructions for one line of source code).
Support for deemon's 'pack' keyword (now called __pack):
- Can be used to emit parenthesis almost everywhere (except in the preprocessor, or when calling macros)
Explicit alignment of code, data, or entire sections in-source
Support for #pragma comment(lib,"foo") to link against a given library "foo"
Support for #pragma pack(...)
Supports GCC builtin macros for fixed-length integral constants (__(U)INT(8|16|32|64|MAX)_C(...)).
GCC-compatible predefined CPU macros, such as __i386__ or __LP64__.
Support for GCC builtin macros, such as __SIZEOF_POINTER__, __SIZE_TYPE__, etc.

Features (Attributes):

Ever attribute can be written in one of three ways:
- GCC attribte syntax (e.g.: __attribute__((noreturn)))
- cxx-11 attributes syntax (e.g.: [[noreturn]])
- MSVC declspec syntax (e.g.: __declspec(noreturn))
The name of an attribute (in the above examples noreturn) can be written with any number of leading, or terminating underscores to prevent ambiguity with user-defined macros:
- __attribute__((____noreturn_)) is the same as __attribute__((noreturn))
The following attributes (as supported by other compiler) are recognized:
- __attribute__((noreturn*))
- __attribute__((warn_unused_result*))
- __attribute__((weak*))
- __attribute__((dllexport*))
- __attribute__((dllimport*))
- __attribute__((visibility("default")))
- __attribute__((alias("my_alias")))
- __attribute__((weakref("my_alias")))
- __attribute__((used*))
- __attribute__((unused*))
- __attribute__((cdecl*))
- __attribute__((stdcall*))
- __attribute__((thiscall*))
- __attribute__((fastcall*))
- __attribute__((section(".text")))
- __attribute__((regparm(x)))
- __attribute__((naked*))
- __attribute__((deprecated))
- __attribute__((deprecated(msg)))
- __attribute__((aligned(x)))
- __attribute__((packed*))
- __attribute__((transparent_union*))
- __attribute__((mode(x))) (Underscores surrounding x are ignored)
- All attribute names marked with '*' accept an optional suffix that adds an enabled-dependency on a compiler-time expression. (e.g.: __attribute__((noreturn(sizeof(int) == 4))) - Mark as noreturn, if int is 4 bytes wide)
Attributes not currently implemented (But planned to be):
- __attribute__((constructor))
- __attribute__((constructor(priority)))
- __attribute__((destructor))
- __attribute__((destructor(priority)))
- __attribute__((ms_struct))
- __attribute__((gcc_struct))
Attributes ignored without warning:
- __attribute__((noinline...))
- __attribute__((returns_twice...))
- __attribute__((force_align_arg_pointer...))
- __attribute__((cold...))
- __attribute__((hot...))
- __attribute__((pure...))
- __attribute__((nothrow...))
- __attribute__((noclone...))
- __attribute__((nonnull...))
- __attribute__((malloc...))
- __attribute__((leaf...))
- __attribute__((format_arg...))
- __attribute__((format...))
- __attribute__((externally_visible...))
- __attribute__((alloc_size...))
- __attribute__((always_inline...))
- __attribute__((gnu_inline...))
- __attribute__((artificial...))
New attributes added by DCC:
- __attribute__((lib("foo")))
  - Most effective for PE targets: 'foo' is the name of the DLL file that the associated declaration should be linked against.
  - Using this attribute, one can link against DLL files that don't exist at compile-time, or create artificial dependencies on ELF targets.
- __attribute__((arithmetic*))
  - Used on struct types of arbirary size to enable arithmetic operations with said structure. Using this attribute you could easily create e.g.: a 512-bit integer type.
    - Most operators are implemented through inline-code, but some (mul,div,mod,shl,shr,sar) generate calls to external symbols.
  - When this attribute is present, the associated structure type can be modified with 'signed'/'unsigned' to control the sign-behavior.
In addition, the following keywords can be used anywhere attributes are allowed.
- {_}_cdecl: Same as __attribute__((cdecl))
- {_}_stdcall: Same as __attribute__((stdcall))
- {_}_fastcall: Same as __attribute__((fastcall))
- __thiscall: Same as __attribute__((thiscall))

Features (Warnings):

DCC features an enourmous amount of warnings covering everything from code quality, to value truncation, to syntax errors, to unresolved references during linkage, etc...
Any warning can be configured as
- Disabled: (Compilation is continued, but based on severity, generated assembly/binary may be wrong)
- Enabled: Emit a warning, but continue compilation as if it was disabled
- Error: Emit an error message and halt compilation at the next convenient location
- Supress: Works recursively: Handle the warning as Disabled for every time it is suppressed before reverting its state to before it was.
Warnings are sorted into named groups that can be disabled as a whole. The main group of a warning is always displayed when it is emit. (e.g.: W1401("-WSyntax"): Expected ']', but got ...)
The global warning state can be pushed/popped from usercode:
- Push:
  - #pragma warning(push)
  - #pragma GCC diagnostic push
- Pop:
  - #pragma warning(pop)
  - #pragma GCC diagnostic pop
Individual warnings/warning group states can be explicitly defined from usercode:
- Disabled:
 - #pragma warning("[-][W]no-<name>")
 - #pragma warning(disable: <IDS>)
 - #pragma warning(disable: "[-][W]<name>")
 - #pragma GCC diagnostic ignored "[-][W]<name>"
- Enabled:
 - #pragma warning(enable: <IDS>)
 - #pragma warning(enable: "[-][W]<name>")
 - #pragma GCC diagnostic warning "[-][W]<name>"
- Error:
 - #pragma warning(error: <IDS>)
 - #pragma warning(error: "[-][W]<name>")
 - #pragma GCC diagnostic error "[-][W]<name>"
- Suppress (once for every time a warning/group is listed):
 - #pragma warning(suppress: <IDS>)
 - #pragma warning(suppress: "[-][W]<name>")
 - #pragma warning("[-][W]sup-<name>")
 - #pragma warning("[-][W]suppress-<name>")
- Revert to default state:
 - #pragma warning(default: <IDS>)
 - #pragma warning(default: "[-][W]<name>")
 - #pragma warning("[-][W]def-<name>")
- IDS is a space-separated list of individual warning IDS as integral constants
 - Besides belonging to any number of groups, each warning also has an ID
 - Use of these IDS should be refrained from, as they might change randomly
- Similar to the extension-pragma, #pragma warning(...) accepts a comma-seperated list of commands.
 - #pragma warning(push,disable: "-Wsyntax")
All warnings can be enabled/disabled on-the-fly using pragmas:
- #pragma warning(push|pop) Push/pop currently enabled extensions
- #pragma warning("-W<name>") Enable warning 'name'
- #pragma warning("-Wno-<name>") Disable warning 'name'
#pragma GCC system_header treats the current input file as though all warnings disabled
- Mainly meant for headers in /fixinclude which may re-define type declarations, but are not meant to cause any problems

Features (Extensions):

Extensions are implemented in two different ways:
- Extensions that are always enabled, but emit a warning when used.
 - The warning can either be disabled individually (e.g.: #pragma warning("-Wno-declaration-in-if")).
 - Or all extension warnings can be disabled using #pragma warning("-Wno-extensions").
 - Don't let yourself be fooled. Writing "-Wno-extensions" disables warnings about extensions, not extensions themself!
 - Some warnings are also emit for deprecated or newer language features.
 - "constant-case-expressions": Emit for old-style function declarations.
 - "old-function-decl": Emit for old-style function declarations.
- Extensions that may change semantics and can therefor be disabled.
 - All of these extensions can be enabled/disabled on-the-fly using pragmas:
 - As comma-seperated list in #pragma extension(...)
 - push: Push currently enabled extensions (e.g.: #pragma extension(push))
 - pop: Pop previously enabled extensions (e.g.: #pragma extension(pop))
 - "[-][f]<name>": Enable extension name (e.g.: #pragma extension("-fmacro-recursion"))
 - "[-][f]no-<name>": Disable extension name (e.g.: #pragma extension("-fno-macro-recursion"))
 - "expression-statements": Recognize GCC statement-expressions.
 - "label-expressions": Allow use of labels in expression (prefixed by &&).
 - "local-labels": Allow labels to be scoped (using GCC's __label__ syntax).
 - "gcc-attributes": Recognize GCC __attribute__((...)) syntax.
 - "msvc-attributes": Recognize MSVC __declspec(...) syntax.
 - "cxx-11-attributes": Recognize c++11 [[...]] syntax.
 - "attribute-conditions": Allow optional conditional expression to follow a switch-attribute.
 - "calling-convention-attributes": Recognize MSVC stand-alone calling convention attributes (e.g.: __cdecl).
 - "fixed-length-integer-types": Recognize fixed-length integer types (__int(8|16|32|64)).
 - "asm-registers-in-expressions": Allow assembly registers to be used in expressions (e.g.: int x = %eax;).
 - "asm-address-in-expressions": Allow assembly registers to be used in expressions (e.g.: int x = %eax;).
 - "void-arithmetic": sizeof(void) == __has_extension("void-arithmetic") ? 1 : 0.
 - "struct-compatible": When enabled, same-layout structures are compatible, when disabled, only same-declaration structs are.
 - "auto-in-type-expressions": Allow auto be be used either as storage class, or as alias for __auto_type.
 - "variable-length-arrays": Allow declaration of C99 VLA variables.
 - "function-string-literals": Treat __FUNCTION__ and __PRETTY_FUNCTION__ as language-level string literals.
 - "if-else-optional-true": Recognize GCC if-else syntax int x = (p ?: other_p)->x; // Same as '(p ? p : other_p)->x'.
 - "fixed-length-integrals": Recognize MSVC fixed-length integer suffix: __int32 x = 42i32;.
 - "macro-recursion": Enable/Disable TCC recursive macro declaration.
 - Many more extensions are provided by TPP to control preprocessor syntax, such as #include_next directives. Their list is too long to be documented here.

Features (Optimization):

Dead code elimination
- Correct deduction on merging branches, such as if-statement with two dead branches
- Re-enable control flow when encountering a label
- Correctly interpretation of __builtin_unreachable()
- Correctly interpretation of __{builtin_}assume(0)
Automatic constant propagation
- Even capable of handling generic offsetof: (size_t)&((struct foo *)0)->bar
Automatic removal of unused symbols/data
- Recursively delete unused functions/data symbols from generated binary
- Can be suppressed for any symbol using __attribute__((used))
Automatic merging of data in sections marked with M (merge) (Not fully implemented, because of missing re-use counter; the rest already works)
- Using the same string (or sub-string) more than once will only allocate a single data segment:
  - printf("foobar\n"); printf("bar\n"); Re-use "bar\n\0" as a sub-string of "foobar\n\0"

Features (Assembler):

Full AT&T Assembly support
Extension for fixed-length
Supported assembly directives are:
- .align <N> [, <FILL>]
- .skip <N> [, <FILL>]
- .space <N> [, <FILL>]
- .quad 
- .short 
- .byte 
- .word 
- .hword 
- .octa 
- .long 
- .int 
- .fill <REPEAT> [, <SIZE> [, <FILL>]]
- . = <ORG>
- .org <ORG>
- .extern <SYM>
- .global <SYM>
- .globl <SYM>
- .protected <SYM>
- .hidden <SYM>
- .internal <SYM>
- .weak <SYM>
- .local <SYM>
- .used <SYM>
- .unused <SYM>
- .size <SYM>, <\SIZE>
- .string <STR>
- .ascii <STR>
- .asciz <STR>
- .text
- .data
- .bss
- .section
- .previous
- .set <SYM>, <VAL>
- .include <NAME>
- .incbin <NAME> [, <SKIP> [, <MAX>]]
CPU-specific, recognized directives:
- I386+
  - .code16
  - .code32
- X86-64
  - .code64
Directives ignored without warning:
- .file ...
- .ident ...
- .type ...
- .lflags ...
- .line ...
- .ln ...

Features (Linker):

Integrated linker allows for direct (and very fast) creation of executables
Merge multiple source files into a single compilation unit
ELF-style visibility control/attributes (__attribute__((visibility(...))))
Directly link against already-generated PE binaries
Add new library dependencies from source code (#pragma comment(lib,...))
Output to PE binary (*.exe/*.dll)

GrieferAtWork / dcc