LOW LEVEL OBJECT ORIENTED
LANGUAGES IN CONTEXT OF A
COMPARATIVE STUDY BETWEEN
TWO LOW LEVEL LANGUAGES: MSIL
(MICROSOFT INTERMEDIATE
LANGUAGE) OR CIL AND JAVA
BYTECODE
Amit Juyal1
amitjuyal26@gmail.com
Ashish Kumar Pal2
asheesh.pal@gmail.com
Janmejay Pant3
geujay2010@gmail.com
1, 2, 3
: Assistant Professor, Graphic Era University Dehradun, Uttarakhand 248001, India
Abstract:
Most of the software, in the last decade were developed using high level languages such as Java, C#.NET, C++ etc. The main advantages of these languages are their object oriented features .They help the developer to develop software with graphical user interface, portable, ease of use, efficient and secure, and simultaneously keep the focus strongly on the real participants of the game, the Objects. Low level language like assembly language, machine languages are not user friendly, hard to program but faster in execution than high level languages..In this paper we have done comparative study between two low level languages MSIL (Microsoft Intermediate language) or CIL and Java Byte Code. Both of these languages have object-oriented features. This paper also includes brief introduction about programming languages, and translators.
Keywords:
MSIL, CIL, Java Byte Code, Just in time (JIT) Compiler, Graphical User Interface (GUI), Object-Oriented Paradigm (OOP)
1. Introduction
Mainly in computers there are two types of languages: Low level such as Assembly language and High Level
such as C++, Java, C#.NET etc. Object oriented paradigm is a feature of high level languages. Object
2. What is a Programming Language?
Programming languages are the building blocks of the software. Programming languages provides an efficient way to communicate with hardware and other system as well as application software. The programming paradigms provide a good range of choices to the developer .Success of every software project is mainly dependent upon multiple constraints such as on-time delivery, within budget, secure, ease of use, portability and meeting quality criteria. The main and important task of the software developers is to translate the ideas, which come from the client’s requirements, to the working code and this is achieved from choosing appropriate programming language for the particular project. Requirements are gathered in natural languages from customers but the formal programming languages such as C, C++, COBOL, Java, C# .NET, PERL etc. are used in software development for analysis, design and programming. Programming language is a tool for instructing machines, programming language is a communication bridge between developer and machine, and it is a way of expressing high level design and a means for implementing computerized automations. Programming languages are essentially carefully designed notations. They are used to specify, organize and reason about aspect of problem solving.
2.1Low Level Languages
The term low level means closeness to the hardware and a way in which data is directly stored in to the internal registers of the CPU. Low Level languages are machine oriented and require extensive knowledge of computer hardware and its configuration. There are two types of low level languages: Machine language and Assembly language. Machine Language is the language of the computer in the form of binary number and is the only language that is directly understood by the computer. We also call it machine code and it is written as strings of 1’s and 0’s. It is on this basis that the computer is designed. When this sequence of codes is fed to the computer, it recognizes the codes and converts it in to electrical signals needed to run it. For example, a program instruction may look like this: 1011000111101
It is not an easy language for a programmer to learn because of its complexity as it consists of 1's and 0's. It is most efficient in terms of very fast execution .Machine level language is already in the form of machine code hence there is no need to translate it. Another low level language is assembly language. Assembly Language is the first step to improve the programming structure. In this language, the machine codes comprising of 1's and 0's are substituted by symbolic codes (called mnemonic codes) to improve their understanding. The set of symbols and letters forms the assembly language and a translator program (called Assembler) is required to translate the programs written in assembly language into machine language for execution by the computer. It is considered to be a second-generation language.
2.2 High Level Language
High Level Language is mostly suitable for business oriented programming where there is very little processing and high-level presentation artifact. High level languages make programming very simple as it allows quick development, quick debug, quick testing. High level languages consist of English, special symbols and mathematical symbols like +, -, %, /, etc. for its program construction .Any high-level language has to be converted to machine language for the computer to understand and for this purpose Language Translators are used. A Translator is a package that reads a program written either in high level or low level language and produces an equivalent machine language instruction set as output. Three types of translators are used to translate programming languages written in higher-level languages into machine specific code. These are Assembler, Interpreter and Compiler.
Assembler: Assembler is a translator which is used for converting the mnemonic codes or machine instructions of low level language (Assembly Language) into machine specific code or in binary format set.
Interpreter: An interpreter is a program that reads a high-level program and produce machine specific code as output. It translates the program line-by-line and if the line is error free it translate line into machine specific code.
Compiler: A compiler is a program that scan whole program once and if the program is error free, compiler translate it into the target or machine specific code. A compiler is a program that reads a high-level program and translates it all at once, before running any of the commands .In compilation process, the high-level program is called the source code, and the translated program is called the object code or the executable.
3.1 Object-Oriented Paradigm (OOP)
Object-oriented programming (OOP) is a programming paradigm which mainly focuses on objects as the actors in the process. An object consists of data structures with data fields and methods together with their interactions to design applications and computer programs. Object oriented paradigm treats the process architectures in terms of objects. OOP allows decomposing large projects into number of small independently distinguishable components. These components are further decomposes into number of other modules which is easy to build. At the end all these components are reassembles into one complete application or project. In OOP each object is made up of data and the method. Only the method which is associated with the object can access that object. OOP also provide data hiding concept. OOP programming includes various features such as data abstraction, encapsulation, messaging, modularity, polymorphism, and inheritance. Almost every modern programming language now supports OOP. Object-oriented programming is an efficient way to develop projects more closely modeled the way people think about and deal with the world. Using procedural programming, a programmer first try to find solution of some problem which perform computing task, programming back then, consisted of sequence of instructions that will accomplish that task. But in object-oriented programming, instead of tasks, we work with objects – entities that have behaviors, which hold information and that can interact with one another. Programming consists of designing a set of objects that model the problem at hand. Software objects in the program can represent real or abstract entities in the problem domain. This is supposed to make the design of the program more natural and hence easier to get right and easier to understand. An object-oriented programming language such as Java and C# includes a number of features that make it very different from a procedural language.
3.2 Low Level Object Oriented languages
When we talk about low level languages, we talk about the languages which directly communicate with hardware, languages whose data directly stored on internal registers of the CPU, languages which are not portable and languages which are faster in execution rater than high level languages. Object orientation is a feature of high level languages .But all the high level languages like C#, Java etc. are not executed directly by any machine .These high level languages need to be translated into the machine level languages for execution. When these languages are translated by translators such as Just in Time compiler (translator) in case of .NET platform, or Java Virtual Machine (Java compiler) in case of Java, an intermediate language such as MSIL (Microsoft Intermediate Language) or CIL (Common Intermediate Language) in .NET and Java Byte code in Java, is generated by these translators or compilers. These intermediate languages such as MSIL and Java Byte code are Low level Languages because these languages consist of mnemonic codes or machine instructions which are a low level language form (like assembly language). Hence we can say that “Java Byte code and .NET MSIL are low level object oriented programming languages because both the Byte code and MSIL have all the objects, classes and other OOP features in the form of mnemonics”. The analysis and implementation strategy of a low level object oriented programming language can be explained in light of two of the most dominating technologies in the recent past, to name JAVA BYTECODE and Microsoft Intermediate Language i.e. CIL.
3.3 The Common Language Runtime (CLR)
The CLR provide run time environment for various languages that .NET framework supports .The CLR meta data engine was designed to provide a language –independent schema and supporting APIS to enable the CLR development model .When the program is compiled with a CLR ,information describing the classes defined and used in that program are emitted as meta data through the meta data Engine and stored with the resulting program object along with CIL.[7]The CLR consist of several components like class loader, garbage collector ,metadata engine and debugging.CLR uses the meta data for object instantiation ,type safety verification and JIT compilation for compiling CIL or MSIL into native code.
3.3.1 Common Intermediate Language (CIL)
object code. CIL is a CPU & platform-independent instruction set that can be executed in any environment supporting the Common Language Infrastructure, such as the .NET runtime on Windows, or the cross-platform .NET-Mono runtime. In theory, this eliminates the need to distribute different executable files for different platforms and CPU types. CIL code is verified for safety during runtime, providing better security and reliability than natively compiled executable files.
.NET is a platform which provides programming and run time execution for 20+ programming languages such as C#, VB etc. All the languages which are supported by the .NET platform are not directly executed or understood by the machine. For the execution of these languages ,first these are translated into CIL by language specific compiler and then these intermediate languages are translated into machine specific code by Just in time (JIT) compiler which is generally in the form of binary(10101010….1001). This CIL is stored into an executable file by language specific compiler. This file is loaded for execution by the JIT compiler then is compiled by JIT into native code. Hence all .NET programming languages does not compile into executable code directly instead it compiles into an intermediate code called MSIL or CIL. Programmers need not worry about the syntax of MSIL since our source code is automatically converted into MSIL by the .NET Framework. MSIL code is then sent to CLR that converts the code into machine language which is then run on the host machine. MSIL is similar to JAVA Byte code. In other words, when initial step completes, all files in the same folder (immediate parent, not the top level) are given to the C# compiler that generates one assembly file per given folder. The language of generated assembly is intermediate language, but its format is not readable and suitable for analysis, so it must be converted in text format. This is the third step; a process called disassembling, by calling external process and executing ILDasm.exe.ILDasm.exe is a tool that is included in installation of Visual Studio or Framework SDK, which loads an assembly containing intermediate language code and generates a text file. This text file, generated in the third step, is the actual input file. Text file containing disassembler code is parsed line by line and verified if they satisfy predefined patterns. Generally, only lines starting with IL_ contain intermediate language instructions. The example is shown in Fig. which shows second instruction (IL_0002) inside observed method, that takes value from stack and stores it (stloc) in the local variable 0 (.0). IL_0002: stloc .0 line position instruction variable 0. Last number is the index of local variable. Index is based on the position Index is based on the position in the original (high-level language) source code, where the variable is introduced for the first time.
CIL is a stack based, type neutral intermediate form and look like assembly language because it uses mnemonics similar to that of assembly language. CIL is not interpreted so there is no type information .All type information can be obtained from token references to metadata artifacts.
3.3.2 Object-Oriented Concepts for CIL (Object Oriented feature of Low level Language (Common Intermediate Language))
Here is an example of OOP feature of low level language CIL, shown in the following table. This is object-oriented feature for CIL. You can create objects, call methods and use other types of members such as fields.CIL is an object-oriented programming language and in CIL every method needs to reside in a class.
C# CODE using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace demo5 { class A {
public void getdata() {
Console .WriteLine("enter the value of a" );
int a=Convert .ToInt32 (Console .ReadLine ());
Console.WriteLine("enter the value of b"); int b = Convert.ToInt32(Console.ReadLine()); int c = a + b;
Console.WriteLine("Result..."+c); Console.ReadLine();
}
COMMON INTERMEDIATE LANGUAGE
- C:\Users\sony\Documents\Visual Studio 2008\Projects\demo5\demo5\Program.cs - using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace demo5 { class A {
public void getdata() {
00000000 mov qword ptr [rsp+8],rcx 00000005 sub rsp,78h
00000009 mov dword ptr [rsp+20h],0 00000011 mov dword ptr [rsp+24h],0 00000019 mov dword ptr [rsp+28h],0 00000021 mov rax,7FF001B1E30h 0000002b mov eax,dword ptr [rax] 0000002d test eax,eax 0000002f je 0000000000000036 00000031 call FFFFFFFFEF89C420 00000036 nop
Console .WriteLine("enter the value of a" ); 00000037 mov rcx,127B3100h 00000041 mov rcx,qword ptr [rcx] 00000044 call FFFFFFFFEE7B5BC0 00000049 nop
}
class Program {
static void Main(string[] args) {
A obj1 = new A(); obj1.getdata(); }
} }
0000005e mov dword ptr [rsp+38h],eax 00000062 mov eax,dword ptr [rsp+38h] 00000066 mov dword ptr [rsp+20h],eax Console.WriteLine("enter the value of b"); 0000006a mov rcx,127B3108h 00000074 mov rcx,qword ptr [rcx] 00000077 call FFFFFFFFEE7B5BC0 0000007c nop
int b = Convert.ToInt32(Console.ReadLine()); 0000007d call FFFFFFFFEEDCADD0 00000082 mov qword ptr [rsp+40h],rax 00000087 mov rcx,qword ptr [rsp+40h] 0000008c call FFFFFFFFEED7BB70 00000091 mov dword ptr [rsp+48h],eax 00000095 mov eax,dword ptr [rsp+48h] 00000099 mov dword ptr [rsp+24h],eax int c = a + b;
0000009d mov ecx,dword ptr [rsp+20h] 000000a1 mov eax,dword ptr [rsp+24h] 000000a5 add eax,ecx
000000a7 mov dword ptr [rsp+28h],eax Console.WriteLine("Result..."+c); 000000ab mov rax,127B3110h 000000b5 mov rax,qword ptr [rax] 000000b8 mov qword ptr [rsp+50h],rax 000000bd mov eax,dword ptr [rsp+28h] 000000c1 mov dword ptr [rsp+2Ch],eax 000000c5 mov rcx,7FEEEA3EF10h 000000cf lea rdx,[rsp+2Ch] 000000d4 call FFFFFFFFEF63B1C0 000000d9 mov rdx,rax
000000dc mov rcx,qword ptr [rsp+50h] 000000e1 call FFFFFFFFEE809D10 000000e6 mov qword ptr [rsp+58h],rax 000000eb mov rcx,qword ptr [rsp+58h] 000000f0 call FFFFFFFFEE7B5BC0 000000f5 nop
Console.ReadLine();
000000f6 call FFFFFFFFEEDCADD0 000000fb mov qword ptr [rsp+60h],rax 00000100 nop
}
00000101 jmp 0000000000000103 00000103 add rsp,78h 00000107 rep ret
In the above table there is a code sample of C# program and correspond CIL code. In this C# program there are two classes named “class A” and “Program”, It also consist “Main()”method and “getdata()”
method. This code also consist some library methods of Console class, namely WritLine() & ReadLine().
Above code takes the value of two variable from the user using getdata() method and performs sum of these two values. In Main() method which is member function of Program class and is also the entry point, creates object named “obj1”. Further, member function of class A is invoked by the obj1.getdata() statement. These classes, object and methods are all the OOP features as C# is a object oriented high level language. The CIL code on the right side in table is a corresponding low level language code of C# program on left side. This CIL code is a low level language code because it include stack-oriented machine instruction set like mov, add, sub, call, nop etc. This CIL code is like assembly language which is low level language. All the classes, methods and objects of C# code are also available in CIL code in the form of machine instruction. Hence we can say that CIL is a Low Level Object Oriented Programming Language.
Another example of Low Level OOP Language Instruction Set:-
C# CODE using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication3 { class Add { int a, b; int geta() {
return a = 6; }
int getb() {
return a = 2; }
public int sum()
--- C:\Users\sony\Documents\Visual Studio
2008\Projects\ConsoleApplication3\ConsoleApplication3\Program.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication3 { class Program {
static void Main(string[] args) {
00000000 mov qword ptr [rsp+8],rcx 00000005 sub rsp,48h
00000009 mov qword ptr [rsp+20h],0 00000012 mov rax,7FF001B1E38h 0000001c mov eax,dword ptr [rax] 0000001e test eax,eax
00000020 je 0000000000000027 00000022 call FFFFFFFFEF89CBD0 00000027 nop
Add a = new Add();
{
int a = geta(); int b = getb(); int c = a + b; return c; }
public void show() {
int r = sum();
Console.WriteLine("Result... "+r); }
}
class Program {
static void Main(string[] args) {
Add a = new Add(); a.sum();
a.show();
Console.ReadLine();
} } }
00000032 call FFFFFFFFEF63B900 00000037 mov qword ptr [rsp+28h],rax 0000003c mov rcx,qword ptr [rsp+28h] 00000041 call FFFFFFFFFFEC9AA0 00000046 mov r11,qword ptr [rsp+28h] 0000004b mov qword ptr [rsp+20h],r11 a.sum();
00000050 mov rax,qword ptr [rsp+20h] 00000055 cmp byte ptr [rax],0 00000058 mov rcx,qword ptr [rsp+20h] 0000005d call FFFFFFFFFFEC9A90 00000062 mov dword ptr [rsp+30h],eax 00000066 nop
a.show();
00000067 mov rax,qword ptr [rsp+20h] 0000006c cmp byte ptr [rax],0 0000006f mov rcx,qword ptr [rsp+20h] 00000074 call FFFFFFFFFFEC9A98 00000079 nop
Console.ReadLine();
0000007a call FFFFFFFFEEDCB580 0000007f mov qword ptr [rsp+38h],rax 00000084 nop
}
00000085 jmp 0000000000000087 00000087 add rsp,48h
0000008b rep ret
In the above table there is a code sample of a C# program and correspond CIL code. In this C# program there are two classes namely “Add” and “Program” and Four member functions of Add class namely geta(), getb(), sum() and show(). Main() method is the entry point for the Program class. Two methods geta() and getb() method returns the values of a and b, sum() performs the sum of two values which is getting from geta() and getb() method ,show() method display the result or sum.In Program class object “a” is created by Add a = new Add() statement. This object ”a” is used to invoke sum() and show() method of Add class. The CIL code on the right side in table is a corresponding low level language code of C# program on left side with in the table .This CIL code is a low level language code because it include machine instruction codes like
mov, add, sub,call, nop , test etc. This CIL code is like assembly language which is low level language. All the classes, methods and objects of C# code are also available in CIL code in the form of machine instructions. Hence we can say that CIL is a Low Level Object Oriented Language.
These are just a representation of how CIL looks like near VM-level. When compiled the methods are stored in tables and the instructions are stored as bytes inside the assembly, which is a Portable Executable file (PE). A CIL assembly and instructions are generated by either a compiler or a utility called the IL Assembler (ILASM) that is shipped with the execution environment. Assembled IL can also be disassembled into code again using the IL Disassembler (ILDASM). There are other tools such as .NET Reflector that can decompile IL into a high-level language (e.g. C# or Visual Basic). This makes IL a very easy target for reverse engineering. This trait is shared with Java Byte Code.
3.3.3 Just-in-time compilation
Figure: Execution process of .NET compatible languages
Hence we can say in .NET platform all languages that support .NET are generally compiled twice before finally executed on particular operating system. First compiler is language specific, which compiles the source code to low-level language called CIL (Common Intermediate Language). For example, code written in C# language is compiled to CIL using C# compiler. CIL is processor and platform-independent instruction set look like assembly language that can be executed in any environment supporting the Common Language Infrastructure, such as .Net CLR on Windows or cross-platform Mono runtime. Finally CIL code is executed via compiled using second compiler known as JIT (Just-In-Time) compiler, which generates platform or processor-specific binary code, also known as native code. Intermediate language code is the lowest level human-readable programming language, and therefore it has lesser commands and simpler structure than third-generation languages like C#.
C# code is high level object oriented code while CIL is low level language code because it uses instruction like add, sub, load (mnemonics instruction sets). Hence we can say that CIL or MSIL is low level object oriented language because all objects, classes, interfaces, methods of C# and object oriented features like encapsulation, data hiding, abstraction, inheritance etc. which are used to develop program are translated into CIL, which is lower level language.
4 Java Byte code: A Low Level Object Oriented Programming Language
Java byte code is a low level object oriented language. Java is high level object oriented language developed by Sun Micro system of USA in 1991. Almost everything in java is an object. All programs, code, methods and data reside within objects and classes. Java is not directly translated into the machine specific code. Java is both compiled and interpreted. Instead of translating programs into machine specific language, the Java compiler generates intermediate code known as Java Byte code. Byte code is easy (and fast) to interpret, like machine language, but it is also portable, like a high-level language. Thus, it is possible to compile a program on one machine, run the byte code to another machine, and then interpret the byte code on the other machine. This ability is an advantage of Java over many other high-level languages.
software interpreter (translator) and also helpful for further translation in machine codes. The name byte code is originated from instruction set which have one byte op-codes followed by optional parameters. This byte code is like an assembly language. Byte code can reduce hardware and operating system dependency by allowing the same code to run on different platforms. Byte code often be directly executed on a virtual machine (interpreter) and further compiled into machine code for better performance. Byte codes are compact numeric codes, constants and references (numerical address)
Byte code is a low-level object-oriented language which is widely used in the context of mobile code due to its platform independent characteristics. Byte code which is generated by the java compiler is a set of instruction of source code which is very much similar to Assembly language mnemonics. Byte code is a low level code of object oriented Java source code hence java byte code can be consider as low level object oriented language. Java compiler produces an intermediate code known as byte code for a machine that does not exist physically. This machine is called Java Virtual Machine and it exists only inside the computer memory as a firmware. It can be considered as a simulated computer within the computer.
Figure: Java source code execution process
This Virtual machine code (Java byte code) is not machine specific code; rather it is like an Assembly language code. In next phase this Byte code is translated in to machine specific code by java interpreter which is directly executed by machine.
4.1 Low level feature of Java byte code:-
Computer can understand only machine specific codes i.e. in binary form. Java program is a high level object oriented language. When Java code is converted into byte code by javac compiler, this Java Byte code generated is similar to assembly language because byte code is a collection of mnemonics. This Java byte code is saved on the disk with the file extension .class. When the program is to be run, the Java byte code is converted, using the Just-In-Time (JIT) compiler. The result is machine code which is then fed to the memory and is executed. We propose to say byte code is low level language that sits between high level Java program and low level machine specific code. Programs compiled into Java byte code are highly portable, meaning that they provide the same functionality when executed on different (virtual) machines.
The technique is portable to different targets and different types of Java byte code execution: interpretation, ahead of-time compilation, and direct execution on hardware.
Porting the WCET information to a specific target does not require the availability of complex tools.
The target specific analysis requires only a small amount of resources and could even be implemented as part of a virtual machine.
Taking into account hardware characteristics in the analysis allows us to keep the pessimism of the WCET analysis within reasonable bounds analysis of Java byte code without relying on source code.
Java byte code is the object-code format of a stack based Virtual Machine (VM). A program (in Java, Ada or any other language) is compiled into a Java Class File which holds the definitions of constants methods, attributes and other information as well as the actual JBC. The Java VM is the name of an engine which is able to execute Java byte code programs. The portability is achieved by producing an appropriate VM for each different platform.
5. Conclusion
Through this work, we propose that both Java Byte Code and the MSIL are Low level Object Oriented Programming Languages because these languages are intelligently interpreted outcome of Java and C#, which are high level object oriented languages, respectively. But machine does not directly understand these languages. So these languages are converted into machine closeness code using translator for the execution .All the objects, classes, constructors, methods, interfaces of the high level object oriented languages are translated into intermediate languages which are low level languages hence we can say that MSIL and Java Byte Code are low level human readable object oriented programming languages.
References
[1] Kathleen Fisher and John C. Mitchell, What is object oriented language, 1995
[2] Bjarne Stroustrup, AT&T Bell Laboratories, What is ‘‘Object Oriented Programming’’? (1991 revised version)
[3] I. Bate, G. Bernat, G. Murphy, Department of Computer Science, University of York, York, YO10 5DD, UK, Low-Level Analysis of a
Portable Java Byte Code WCET Analysis Framework.
[4] Vedran Juricic, Department of Information Sciences, Faculty of Humanities and Social Sciences, Detecting Source Code Similarity
using Low-level Languages
[5] Programming Languages Design and Implementation, Terrance W.Pratt, Marvin V. Zelkowwitz.
[6] Etienne Payet, IREMIA University France Fausto, Experiments with Non-Termination Analysis for Java Byte code
[7] Jennifer Hamilton, Common language Runtime Development Team, Microsoft, “Language Integration in the Common Language
