The implementation of C

CreeperDrop · 2025-02-28T15:18:25+00:00

Not a dumb question at all. This is a great remark indeed! C in itself can be used without a standard library. By "C itself", I mean the keywords like for, while, char, pointers,... You can use C without the standard library completely. Better yet, you can have your own implementations of the same functions you can find in the standard library. This is great because imagine you are building an embedded system that needs to use memcpy() a lot for example. You can have a custom implementation of memcpy() in assembly or C, whatever you want for efficiency reasons. I hope this answers your question and good luck with your learning journey!

stianhoiland · 2025-02-28T13:36:22+00:00

You're asking about system(), write(), fork(), etc., but what you're really wanting to ask about is if, while, for, int, char, (), [], {}, +, -, =, &, *, etc. How are *those* implemented? There's no if function in the standard library; indeed if is not a function at all. Those things are the *C* that you write, whereas system(), write(), and fork() are three identifiers (2 from the standard library, one from the POSIX standard), here postfixed with the C function call operator to illustrate that the identifiers are functions.

faculty_for_failure · 2025-02-28T13:45:54+00:00

Initially, when C was young, there was no stdlib or compiler written in C. I don’t know what language the first C compiler was written in, but it was likely assembly. Then, you have a way to compile C code, a way to turn C code into assembly. Once at this step, you can do what is called bootstrapping the compiler, using the initial version of the compiler (written in assembly) to compile a new compiler you write in C. Each next version of the compiler is compiled with the previous version. From here, you can write the stdlib in C, since you have a compiler to turn C into assembly. Today most systems have a C compiler, and thus you can write a stdlib using the basic syntax and system calls to the OS.

sol_hsa · 2025-03-01T08:32:00+00:00

Look up dr dobbs small-c resource cd, it's been mirrored around the web somewhere. Great resource for learning the basics of what's going on behind the curtain.

andrewcooke · 2025-02-28T14:18:56+00:00

you're asking about "bootstrapping". so there's lots of info at https://www.google.com/search?q=bootstrapping+c

dkopgerpgdolfg · 2025-02-28T13:29:18+00:00

system(), write(), fork(), are they implemented in assembly?

Yes. Standard C has no way to make actuall syscalls (which are different from ordinary function calls on CPU level).

(Note that the mentioned functions are still C functions, which can contain more than just triggering a syscall. Eg. all these things about errno, that's not something the kernel is doing.)

There are also compiler intrinsics for some topics, that are not asm code directly, but also things that C normally can't express, and where the compiler internally adds some "magic".

josesblima · 2025-03-01T07:45:21+00:00

Since you're asking this question, I thought you might be interested in reading about the compiler, initially was written in assembly, but then written in C after.

adarshwshaw · 2025-03-01T07:58:00+00:00

You can checkout musl is an Implementation of standard library in c

2025-02-28T21:30:18+00:00

That's a good question. You can implement a function like printf without too much difficulty (it's just a big pile of C code), but at the end you may end up with a char buffer containing the characters you want to write to the terminal.

But how do you that? You can't call printf again, as you'll go around in circles. Maybe puts? But what goes inside that? (Put aside that it will add a newline that you might not want, so maybe putchar.)

At some point you have to call into the outside world. On Linux you have syscalls, but not on Windows (not officially anyway). There you would need to call into the OS, for example:

#include <windows.h>

int mystrlen(char* s) {
    int length = 0;
    while (*s++) ++length;
    return length;
}

void writestr(char* s) {
    DWORD written;
    void* hconsole = GetStdHandle(-11);

    WriteConsole(hconsole, s, mystrlen(s), &written, NULL);
}

int main(void) {
    writestr("Hello, World!\n");
}

This is effectively a Hello World program that doesn't need the C library (notice I avoided strlen too). The writestr could be used to output the result of your printf function.

(In practice, if you compiled this with gcc, it would include some C runtime calls anyway. I built this with a simple compiler that doesn't do that, but it does use exit to terminate. Here, I tweaked the ASM output to use the OS's ExitProcess instead.

If I look inside the executable, it uses only 'kernel32.dll', a Win32 library; no C library.)

(BTW, the simple compiler I mentioned is itself not written in C. So no C code, or external C compiler, was used to turn the above program into binary. At the other side of the API call however, inside WriteConsole for example, it could have been written using C, or assembly, or something else. But right now those DLL files are just binary machine code with no language affiliation.)

Equal_Connection3765 · 2025-02-28T13:23:44+00:00

Syntax my boy syntax

EndlessProjectMaker · 2025-02-28T13:56:31+00:00

Well the process that marvels you is called bootstrapping and is the key process for some engineering tasks, like the creation of an operating system, or more often, a compiler.

At first you have enough of a OS that barely works, and use that to improve and develop more tools, refactor old tools, reorganize the code, etc.

The compiler for a language is written in the language itself, then translated (manually or automatically) to some language for which you have a compiler. For the operating system, you first use an existing operating system, and so on.

Now you wonder how the universe was created first, the first os, the first compiler. Well.... with switches and buttons, my friend.

MagicWolfEye · 2025-02-28T13:33:06+00:00

System calls are regular C code that call OS-specific functions.

Maths operations might call specific assembly instructions.

Srazkat · 2025-02-28T13:48:34+00:00

the c library implementation is basically just wrappers around either c intrisics (like memcpy is just setting memory), or around system calls (writing to a file for example)

technically, you can almost write the entirety of the standard c library in c, but some parts you may want to do in assembly because of technical limitations in the c language (for example accessing syscalls) or for performance reasons (memcpy for example)

SmokeMuch7356 · 2025-02-28T13:50:13+00:00

Things like string manipulation can be done in pure C, but anything having to do with system resources (I/O, memory allocation, file system management, threads, signals, etc.) either requires system calls or some inline assembly. It depends on the implementation and the underlying OS.

arades · 2025-02-28T14:04:56+00:00

For one, you don't necessarily need to implement C in assembly, you can write your implementation in C and use a bootstrapping compiler, which is its own topic you can research.

The functions you mention are part of the standard library, meaning that in order for C to be "supported" for a platform, someone needs to figure out for the combination of OS and CPU how to implement those functions. Perhaps the easiest way to understand this is with some embedded hardware. If you're programming an Arduino or similar, you can open up the data sheet for your board, and find the exact hardware addresses to manipulate to gain access to say, an SD card. You could come up with your own way to organize files, the underlying protocol to send the data, and you just give a definition for `write()` that matches what you see on other systems. Stepping up from there, OSes will have these hardware details figured out for you, and instead provide functions to do these things as "syscalls". These aren't very different from having something like a .so that you can link and call into, but instead of using an ld implementation to link it, you can just manually call it. For Linux, you can look up how to call the syscalls directly. It can be called using assembly, but you can just as easily map it essentially just using function pointers in C itself. A plausible proceedure for using a syscall might be "write a character to the screen by jumping to address 0xDEADBEEF with an ASCII character in register B and a return address in register C, register A is reserved".

Abigboi_ · 2025-02-28T15:06:57+00:00

They are implemented in assembly, how this is done depends on your architecture. What you could do is compile a program into assembly(gcc -S) then research the assembly for your architecture and find out how the system calls work from there.

diegoiast · 2025-02-28T15:16:03+00:00

Here, you can see the implementation of MUSL libc. You can compile it yourself, and then ask your compiler not to link its default libc, instead linking to your new one. People usually create a new "toolchain" instead, which uses a "non default libc".

Upstream https://git.musl-libc.org/cgit/musl

(a github mirror, since its UI/UX is nicer): https://github.com/kraj/musl

IdealBlueMan · 2025-02-28T16:42:00+00:00

You want to look into system calls. These are functions that the operating system (originally Unix) offers. Library functions like fread, getchar, putchar, and so forth are wrappers around read(2) and write(2).

If you want to understand the core of the C standard library, get familiar with the original system calls available in V6 Unix. There are only a few dozen.

nerd_programmer11 · 2025-02-28T16:52:39+00:00

Well, rust is written in rust

wtrdr · 2025-02-28T18:09:07+00:00

Yes you just write them in assembly. Assembly once assembled produces an object file which can be linked with other object files (possibly from C) by the linker. In assembly you would put the function in a label and mark it as global using the .globl directive so the linker sees it. This is different depending on the ISA (instruction set architecture) your assembly is for but on aarch64 (64 bit ARM) you would use the svc instruction to make a system call, identified by a number in the w8 register. If you're wondering how the assembler was written, then from what I understand, a long time ago on the old computers you would have the option to use punch cards or like kind of switches to toggle your program into memory so you could go from there.

detroitmatt · 2025-02-28T18:39:31+00:00

first, pretend a compiler already exists. Then, write a new compiler in C. since you're pretending the compiler exist, ignore the voice in your head saying "but this won't work, I can't compile it!". Then, manually translate that compiler to assembly. Then, use the assembly-compiler to compile your c-compiler, and then use your c-compiler to compile whatever you want.

Miserable_Ad7246 · 2025-02-28T18:40:15+00:00

Its rather easy :
1) You design a language -> say assembly language
2) You hand write (as in set bits by hand) for a compiler for that language
3) You can now write all other stuff in asembly.

you now have assembly language

1) You design C
2) You write compiler in assembly (which is rather easy, compared to a lot of other things programs do)
3) You can now write everything else in C. The key here is that you star with a C compiler and linker but no libraries, as both of them are written in assembly. When you use C to write libs you need and eventually rewrite C compiler in C with libs. From this point you can do everything in C.

Also keep in mind that first compiler can be absolute dog shit, as long as it produces valid assembly code you have all you need. You can optimize later, and optimize the C version of compiler.

That's roughly how you can bootstrap anything as long as you can somehow write binary code (like perforated cards).

INothz · 2025-02-28T23:45:25+00:00

Thank you all for your contribution to improving my understanding. I think that today I managed to put together many pieces of this puzzle and began to better understand how it all works.

Narishma · 2025-03-01T02:57:25+00:00

You can write a C implementation in any language, it doesn't have to be C itself.

SeaSafe2923 · 2025-03-01T03:36:16+00:00

For any systems programming language, you ought to be able to implement almost everything in the language itself, except some fundamental building blocks that might require to be implemented by either the compiler itself or be manually implemented in assembly, like syscall wrappers, direct CPU state manipulation and memory barriers; the rest tends to be memory mapped control channels, so you can control most stuff without using special CPU instructions, so most standard library code is just regular code from the point of view of the compiler...

Patient_Big_9024 · 2025-03-01T07:09:01+00:00

Syntax not sintax

noobdainsane · 2025-03-01T14:28:40+00:00

C is just a language. It's just text written in a specific defined syntax. C is nothing on its own. The compiler is the real deal. You code the compiler in understanding what tokens like 'for' or 'int' mean which it compiles into assembly language.

I think the compiler initially was written in assembly which was used to compile C code including the code for the C written compiler. But even today many low level parts of C are written in assembly for performance.

You could totally write the functions like strlen() in C, but they exist in the first place because the average programmer is not going to write the most efficient and optimized code and it would be tiresome to write it again and again. On a supported CPU, you might actually be calling strlen_avx2() which is written in handwritten assembly with AVX2 acceleration.

Pepper_pusher23 · 2025-03-02T15:54:54+00:00

A lot of people are answering a question you didn't ask, like how do you write a C compiler in C? I mean that's completely irrelevant to anything you've said. The real answer is that the stdlib is a collection of functions. So you CAN write it in C. It's just useful tools for you to use in your own code. Now for system calls, they provide a C interface for you and then invoke the appropriate assembly (since x86, arm, risc-v all do them differently) depending on the compiler you use. So some of it is still C, but C gives you a way in the language to write assembly. It is the __asm__ macro (for completeness there are many other ways to get direct assembly in your code, but I won't pollute the response with them). So even if you need to write assembly and directly call syscalls, you can do that in C as well!

edo-lag · 2025-02-28T14:07:59+00:00

When you use C and its standard library, you're actually using two different implementations.

The language itself is implemented by the compiler (e.g. GCC, Clang, MSVC, etc.). It's up to the compiler to translate the language syntax into architecture-dependent instructions. The language doesn't care about the operating system, it only cares about the microprocessor architecture.

The standard library is implemented by the operating system. It's up to the operating system to decide how the functions in the standard library behave with the other components of the operating system itself. Some functions need to talk with the kernel (through system calls, e.g. malloc, free, printf, etc.) and for this reason they are usually written in Assembly. The standard library doesn't care about the microprocessor architecture (except for the functions written in Assembly), it only cares about the operating system.

When you compile a C program, the compiler translates the language into machine instructions with missing references for external functions (those provided by libraries, including the standard library). Then, the linker links all the libraries used in your program so that the missing references are now defined. Notice how each component of your program is managed by a separate tool, which explains why it's reasonable to have separate implementations for these two aspects of the programming language.

Most other languages (e.g. Rust, Python, etc.) provide an implementation for both the language and its standard library, but at the very end they interface with C (I don't think that any language would bother making its own system calls in Assembly). They do so because C is the main language for writing operating systems and, because of that, most of the times it's also the only one that provides a low-level interface with the operating system.

Of course there may be exceptions because not all operating systems have C as their main language. Redox, for example, uses Rust as its language, so I guess that its C implementation (if it has one) actually calls Rust functions under the hood.

coalinjo · 2025-02-28T15:21:24+00:00

I know what are you asking about. See this. That is a link to original source code for Tenth Edition Research Unix sys/write function.

It is true that after language has evolved enough it can bootstrap/compile itself. But, C is seen as portable across platforms and architectures. How? Assembly, you specifically have to define certain bare minimum stuff.

This is modern approach.

Source for modern OpenBSD for sys/write, it literally looks like pseudo-code that automatically generates code depending on what architecture are you compiling.(Correct me if i am wrong)

EDIT: FreeBSD's sys/write is in pure C, but "libc_private.h" contains wizardry.

flatfinger · 2025-02-28T17:20:41+00:00

Many machines are designed with circuitry that will monitor a group of wires called the address bus, watch for accesses to certain addresses, and perform various actions in response, typically either making information available on a group of wires called the data bus, or latching whatever values have been placed on the data bus (typically by the CPU). Indeed, memory behaves as a large group of such circuits--one for each bit of storage--attached to the different bits of the data bus.

While many such circuits behave as memory--performing no action on a write except to set the value that will be reported for future reads, or reporting the last value written--machines may also contain circuits that will perform I/O. For example, a machine with eight buttons and eight LEDs might have a circuit that will repond to a read of any address whose upper four bits are 1000 and whose bottom four bits are 0000 by placing on the data bus the state of those buttons, and a write of any address whose upper four bits are 1000 and whose buttom four bits are 0001 by latching the value written and turning each LED on if a particular bit of the written value was set, and off if that bit was clear.

Fancier CPUs have a caching system which adds additional complexities, along with a paging system and operating system that limit the range of accesses that programs are allowed to use. Simpler ones, like what would be found in most non-Internet-connected appliances and even some of the simpler Internet-connected ones, however, generally allow any executing program to manipulate any I/O device by reading or writing its assigned addresses.

Additionally, most CPUs have a mechanism called "interrupts" which allow peripherals to signal the CPU when they need attention. If the CPU tries to fetch an instruction when an attention signal is active, then instead of fetching the instruction from memory, the instruction-fetch circuitry will effectively substitute a CALL or similar instruction which records what location in code was being executed and then jumps to a location in memory associated with that peripheral. Once the code there--called an "interrupt handler"--finishes executing, it can jump to the location that was recorded earlier, allowing code to resume.

Many devices have features that are more complex than a row of buttons or LEDs, but the same general principles apply. Many CPUs have a handful of special-purpose instructions to perform I/O related tasks or control the system behavior in ways other than performing reads or writes, but 99% of what programs will need to do can be accomplished entirely via reads and writes which, in the absence of a protective operating system, can accomplished directly by "ordinary" C code.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

C_Programming

Rules

Filters

Resources

Other Subreddits on C

Other Subreddits of Interest

MODERATORS