Compiling a C program:- Behind the Scenes

What is a Compiling?

The most common way of interpreting source code (taken as contribution) to machine code or item code is called Compilation. It is finished with the assistance of the compiler. The compiler checks source code for any linguistic or primary mistakes and produces object code.

The aggregation is a course of changing over the source code into object code. It is finished with the assistance of the compiler. The compiler checks the source code for the grammatical or primary blunders, and on the off chance that the source code is without mistake, then, at that point, it creates the article code.

Compiling process in c

The c assemblage process changes over the source code taken as contribution to the item code or machine code. The accumulation cycle can be isolated into four stages, i.e., Pre-handling, Compiling, Assembling, and Linking.

The preprocessor takes the source code as an info, and it eliminates every one of the remarks from the source code. The preprocessor takes the preprocessor order and deciphers it. For instance, on the off chance that <stdio.h>, the mandate is accessible in the program, the preprocessor deciphers the order and supplant this order with the substance of the ‘stdio.h’ document.

Coming up next are the stages through which our program passes prior to being changed into an executable structure:

  • Preprocessor
  • Compiler
  • Constructing agent
  • Linker



The source code is the code which is written in a content manager and the source code document is given an augmentation “.c”. This source code is first passed to the preprocessor, and afterward the preprocessor grows this code. In the wake of extending the code, the extended code is passed to the compiler.


The code which is extended by the preprocessor is passed to the compiler. The compiler changes over this code into gathering code. Or then again we can say that the C compiler changes over the pre-handled code into get together code.

Constructing agent

The gathering code is changed over into object code by utilizing a constructing agent. The name of the item document produced by the constructing agent is as old as source record. The expansion of the item record in DOS is ‘.obj,’ and in UNIX, the augmentation is ‘o’. Assuming the name of the source document is ‘hello.c’, then, at that point, the name of the article record would be ‘hello.obj’.


Primarily, every one of the projects written in C use library capacities. These library capacities are pre-assembled, and the article code of these library documents is put away with ‘.lib’ (or ‘.a’) expansion. The principle working of the linker is to join the item code of library documents with the article code of our program. Here and there the circumstance emerges when our program alludes to the capacities characterized in different documents; then, at that point, linker assumes a vital part in this. It interfaces the article code of these documents to our program. In this way, we reason that the occupation of the linker is to interface the item code of our program with the article code of the library documents and different records. The result of the linker is the executable document. The name of the executable document is as old as source record however contrasts just in their expansions. In DOS, the expansion of the executable document is ‘.exe’, and in UNIX, the executable record can be named as ‘a.out’. For instance, assuming we are utilizing printf() work in a program, then, at that point, the linker adds its related code in a result document.

We should comprehend through a model.


In the above stream chart, the accompanying advances are taken to execute a program:

  • Initially, the info document, i.e., hello.c, is passed to the preprocessor, and the preprocessor changes over the source code into extended source code. The augmentation of the extended source code would be hello.i.
  • The extended source code is passed to the compiler, and the compiler changes over this extended source code into get together code. The expansion of the get together code would be hello.s.
  • This gathering code is then shipped off the constructing agent, which changes over the get together code into object code.
  • Later the production of an article code, the linker makes the executable record. The loader will then, at that point, load the executable record for the execution.

The least demanding instance of arrangement is the point at which you have all your source code set in a solitary document. This eliminates any pointless strides of synchronizing a few documents or thinking excessively. Lets expect there is a document named ‘single_main.c’ that we need to order. We will do as such utilizing an order line like this:

cc single_main.c

Note that we expect the compiler is classified “cc”. In the event that you’re utilizing a GNU compiler, you’ll compose ‘gcc’ all things being equal. In the event that you’re utilizing a Solaris framework, you may utilize ‘acc, etc. Each compiler may show its messages (mistakes, admonitions, and so forth) in an unexpected way, yet in all cases, you’ll get a document ‘a.out’ subsequently, assuming the aggregation finished effectively. Note that some more seasoned frameworks (for example SunOs) accompany a C compiler that doesn’t comprehend ANSI-C, yet rather the more established ‘K&R’ C style. In such a case, you’ll need to utilize gcc (ideally it is introduced), or get familiar with the contrasts between ANSI-C and K&R C (not prescribed in the event that you don’t actually need to), or move to an alternate framework.

You may whine that ‘a.out’ is a too conventional name (where does it come from at any rate? – all things considered, that is a verifiable name, because of the utilization of something many refer to as “a.out design” for programs aggregated on more seasoned Unix frameworks). Assume that you need the subsequent program to be classified “single_main”. All things considered, you could utilize the accompanying line to order it:

cc single_main.c – o single_main

Each compiler I’ve met up to this point (counting the brilliant gcc) perceived the ‘- o’ banner as “name the subsequent executable document ‘single_main'”. Aggregating A Single-Source “C++” Program
Since we perceived how to aggregate C projects, the change to C++ programs is somewhat basic. We should simply utilize a C++ compiler, instead of the C compiler we utilized up until this point. Thus, assuming that our program source is in a document named ‘’ (‘cc’ to signify C++ code. A few software engineers favor a postfix of ‘C’ for C++ code), we will utilize an order like the accompanying:

g++ – o single_main

Or then again on certain frameworks you’ll utilize “CC” rather than “g++” (for instance, with Sun’s compiler for Solaris), or “aCC” (HP’s compiler, etc. You would take note of that with C++ compilers there is less consistency in regards to order line choices, somewhat in light of the fact that as of not long ago the language was developing and had no concurred standard. Yet at the same time, basically with g++, you will utilize “- g” for troubleshoot data in the code, and “- O” for streamlining.

Assembling A Multi-Source “C” Program
So you figured out how to assemble a solitary source program appropriately (ideally at this point you played a little with the compiler and evaluated a couple of instances of your own). However, at some point or another you’ll see that having all the source in a solitary document is somewhat restricting, for quite some time:

  • As the record develops, arrangement time will in general develop, and for every little change, the entire program must be re-accumulated.
  • It is extremely hard, assuming certainly feasible, that few individuals will chip away at a similar undertaking together thusly.
  • Dealing with your code becomes more diligently. Retreating wrong changes turns out to be almost incomprehensible.
  • The answer for this is parted the source code into various records, each containing a bunch of intently related capacities (or, in C++, all the source code for a solitary class).
  • There are two potential ways of assembling a multi-source C program. The first is to utilize a solitary order line to assemble every one of the documents. Assume that we have a program whose source is found in documents “main.c”, “a.c” and “b.c” (found in index “multi-source” of this instructional exercise). We could arrange it thusly:

cc main.c a.c b.c – o hello_world

This will make the compiler accumulate every one of the given records independently, and afterward connect them all together to one executable document named “hello_world”. Two remarks about this program:

Assuming we characterize a capacity (or a variable) in one document, and attempt to get to them from a subsequent record, we really want to pronounce them as outside images in that subsequent document. This is finished utilizing the C “extern” watchword.
The request for introducing the source records on the order line might be modified. The compiler (really, the linker) will know how to take the significant code from each document into the last program, regardless of whether the principal source record attempts to utilize a capacity characterized in the second or third source document.
The issue with this method of arrangement is that regardless of whether we just roll out an improvement in one of the source records, every one of them will be re-accumulated when we run the compiler once more.
To beat this impediment, we could separate the accumulation cycle into two stages – aggregating, and connecting. Lets first perceive how this is done, and afterward clarify:

cc – c
cc – c a.c
cc – c b.c
cc main.o a.o b.o – o hello_world

The initial 3 orders have each taken one source record, and arranged it into something many refer to as “object document”, with similar names, yet with a “.o” postfix. It is the “- c” banner that tells the compiler just to make an item record, and not to produce a last executable document presently. The item record contains the code for the source document in machine language, however for certain unsettled images. For instance, the “main.o” record alludes to an image named “func_a”, which is a capacity characterized in document “a.c”. Certainly we can’t run the code like that.

In this way, subsequent to making the 3 article documents, we utilize the fourth order to connect the 3 item records into one program. The linker (which is summoned by the compiler presently) takes every one of the images from the 3 item documents, and connections them together – it ensures that when “func_a” is conjured from the code in object record “main.o”, the capacity code in object document “a.o” gets executed. Further more, the linker likewise connects the standard C library into the program, for this situation, to determine the “printf” image appropriately.

Also Read: How to make elements float to center?

Leave a Reply

Your email address will not be published.