Introduction of Object Code in Compiler Design

Let assume that you have a C program then, you give it to the compiler and compiler will produce the output in assembly code. Now, that assembly language code will be given to the assembler and assembler will produce some code and that code is known as Object Code. 

Object Code

Object Code is a key concept in the process of compiling a program. It refers to the intermediate code produced by the compiler after it translates the source code (written in a high-level programming language) into a lower-level, machine-readable format.

This object code is usually not directly executable and typically needs to be linked with other files to produce the final executable program.

Steps Involved in Compilation

The compilation of a program involves several stages, and object code is produced at a specific point in that process. The steps involved in the process are:

1. Source Code: The programmer writes the program in a high-level programming language (like C, Java, Python, etc.).
2. Lexical Analysis: The compiler performs lexical analysis to break the source code into tokens (keywords, operators, identifiers, etc.).
3. Syntax and Semantic Analysis: Next, the compiler checks the structure (syntax) and meaning (semantics) of the code, ensuring that it follows the rules of the language and is logically correct.
4. Intermediate Code Generation: The compiler may create an intermediate code that is not machine-specific, providing a way to optimize or analyze the program further. This is often a platform-independent representation.
5. Code Generation (Object Code): Finally, the compiler translates the intermediate code into object code, which is machine-level code specific to the target machine architecture but still not fully executable.

Structure of Object Code

Object code is a binary file that contains machine instructions, but it's not directly executable yet. The object code is typically in a format that can be understood by the computer’s linker (a separate tool that helps to create an executable file). The main elements of object code include:

• Header : The header will say what are the various parts present in this object code and then point that parts. So header will say where the text segment is going to start and a pointer to it and where the data segment going to start and it say where the relocation information and symbol information there.
• Text segment : It is nothing but the set of instruction.
• Data Sections: Object code may contain sections for data (variables, constants, etc.), including initialized data and uninitialized data (commonly called .data and .bss sections).
• Relocation Information: Object code may include information on how addresses should be adjusted during the linking process. It’s used to modify addresses of variables and functions when combining multiple object files into a single executable.

Let us assume you have instruction 1, instruction 2, instruction 3, instruction 4,....

Now if you say somewhere Goto L4 (Even if you don't write Goto statement in the high-level language, the output of the compiler will write it), then that code will be converted into object code and L4 will be replaced by Goto 4.

Now Goto 4 for the level L4 is going to work fine, as long as the program is going to be loaded starting at address no 0. But in most cases, the initial part of the RAM is going to be dedicated to the operating system. Even if it is not dedicated to the operating system.

Then might be some other process that will already be running at address no 0. So, when you are going to load the program into memory, means if the program has to be loaded in the main memory, it might be loaded anywhere. Let us say 1000 is the new starting address, then all the addresses have to be changed, that is known as Reallocation.

• Symbol Table: The object code contains a symbol table that keeps track of all the variables, functions, and other symbols used in the program. This table is essential for linking because it helps the linker resolve references to functions or variables that are defined elsewhere (in other object files or libraries).
• Debugging Information: Sometimes, object code also contains debugging information, allowing developers to debug the program after compilation (e.g., file names, line numbers, variable names).

Features of Object Code

• Machine-readable format: Object code is in a format that can be executed directly by the processor without the need for further translation.
• Architecture-specific: It is specific to a particular processor architecture, so it must be recompiled for other architectures.
• Linking: It can be linked together with other object files and libraries to create a complete executable program.
• Debugging information: It can include debugging information, such as line numbers and variable names, to aid in debugging the program.
• Relocation information: It includes information about the addresses of symbols in the code, allowing the linker to adjust the addresses when the code is linked with other code.
• Code optimization: It can be optimized by the compiler to improve performance, reduce code size, or both.
• Assembly code: It can be disassembled into assembly code, which can be useful for understanding how the program works or for reverse engineering.

Advantages of Object Code

• Efficiency: It is optimized for the specific target platform, which can result in more efficient code than would be possible with a high-level language.
• Portability: It is typically platform-specific, but it can still be portable across different systems that use the same platform. This allows developers to write code once and compile it for multiple target systems.
• Debugging: It can be easier to debug than source code, as it provides a low-level view of the program's execution. Developers can use object code to trace the execution of the program and identify errors or issues that may be present.
• Protection: It can be protected through the use of obfuscation techniques, making it harder for others to reverse engineer the code or steal intellectual property.
• Security: It is more secure than source code because it is not readable by humans, making it more difficult for attackers to reverse engineer the code.
• Interoperability: It can be easily linked with other object files to create a complete executable program.

Disadvantages of Object Code

• Platform-specific: It is specific to a particular platform, which means that it may not be compatible with other systems. This can limit the portability of the code and make it harder to deploy across multiple systems.
• Limited readability: It is a low-level language that is harder to read and understand than source code. This can make it more difficult for developers to maintain and debug the code.
• Limited control: It is generated by the compiler, and developers have limited control over the resulting code. This can limit the ability to optimize the code or tailor it to specific requirements.
• Compatibility issues: It can sometimes be incompatible with other components of the system, which can cause errors or performance issues.
• Code size: It is typically larger than source code because it contains additional information, such as symbols and relocation information.
• Licensing: It may be subject to licensing restrictions that limit its use and distribution.