Dcspm develop and Compile Subset of pascal language to msil
Conditional Branching Instructions
Yüklə 1,28 Mb.
|
- Bu səhifədəki naviqasiya:
- Comparative Branching Instructions
- Constant Loading
- Logical Condition Check Instructions
- Local Variable Loading
Conditional Branching Instructions:
*
Comparative branching instructions take two values (
Constant loading instructions take at most one parameter (the constant to load) and load it on the evaluation stack. The ILAsm syntax requires explicit specification of the constants (in other words, you cannot use a variable or argument name), in decimal or hexadecimal form: Some instructions have no parameters because the value to be loaded is specified by the opcode itself. Note that for integer and floating-point values, the slots of the evaluation stack are either 4- or 8-bytes wide, so the constants being loaded are converted to the suitable size.
Logical condition check operations are similar to comparative branching instructions except that they result not in branching but in putting the condition check result on the stack. The result type is int32, and its value is equal to 1 if the condition checks and 0 otherwise; in other words, logically the result is a Boolean value. The two operands being compared are taken from the stack, and since no branching is performed, the condition check instructions have no parameters. The logical condition check instructions are useful when you want to store the result of the condition check for multiple use or for later use. If you need the condition check to decide only once and on the spot whether you need to branch, you would be better off using a comparative branching instruction.”[10]
Local variable loading instructions are similar to argument loading instructions except that no “invisible” items appear among the local variables, so local variable number 0 is always the first one specified in the local variable signature.
3.1.5: MSIL (Microsoft Intermediate Language) Design After the source code has been tokenized, the parsing phase commences. At the end of this stage, if the source code is syntactically valid, the compiler has generated: (1) an abstract syntax tree (AST) of the source code and (2) Microsoft Intermediate Language (MSIL). The parser phase starts with the Program Function which the source code has to start with the “Program” keyword. When the parser is calling the nextToken() method to read the next string, MSIL is ready to call the newlabel method that set up a new label and then call the emit method to combine the new label with the opcode. When the Program function matches the “Program” keyword, it is going to call declaration function which matches “Var” keyword then calls “identifier list“ function which has a unique number is 256 and number has a unique number too is 257 after matching “;’ and “Type” function is to recognize the identifier type. After calling declaration function, “Program” function calls “Compound statements” function so, MSIL starts from here for being compiled. The Parser phase has some constructor and many methods. 3.1.5.1. Constructors: Constructors are class methods that are executed when an object of a given type is created. Constructors have the same name as the class, and usually initialize the data members of the new object. 1- ldloc Table: it is used to save the variable with its load local location 2-Stloc Table: it is used for save the variable with its store local location
. ; ID Program
: Var
ID Ldloc.Add( lookahead.attr,”ldloc.jj); Stloc.Add( lookahead.attr,”stloc.jj); jj++;
| ,
< type> Type method Integer | real | ; : ID
Integer| real : Inqueue(“.locals init ( [1] int32, [2] int32,…)
emit(IL_####, " ", "ret", "", "\n") End ; Begin Prgoram function after calling Compand statements function, Compound function matches “Begin” keyword and then calls Statements List function for the other statements such as Writeline statement, if statement, if/else statement,..etc. We will talk about MSIL statements in a bit. Next, matches End of Begin of our program and then it will do emit “IL_####:” and “ret” instruction which return from method, possibly with a value.
; Semicolon After Compound Statements function called Statements list function, Statements list function is going to call Statement function which decides or parses and compiles a statement to MSIL. After that, matching the semicolon of statement and then calling Statements List again for another statement this function is a recursion function because calling itself.
While Writeline | Case | | Begin | If | | For expression <simple expression> <Newlabel>: “<” : emit(“IL_##”,”clt”) “>” : emit(“IL_##”,”cgt”) “<=” : emit(“IL_##”,”cgt”) “>=” : emit(“IL_##”,”clt”) “==” : emit(“IL_##”,”ceq”) “<>” : emit(“IL_##”,”ceq”) simple expression <Newlabel> “+” : emit(“IL_##”,”add”) “-” : emit(“IL_##”,”sub”) <simple expression> <factor> <term> <Newlabel> “*” : emit(“IL_##”,”mul”) “/” : emit(“IL_##”,”div”) <term> <factor> ID : “*” : emit(“IL_##”,”ldloc.##”) <factor> ( <IFlogic> ) NUM : “*” : emit(“IL_##”,”ldc.i4.Num”) IFlogic <AndLogic> OR : <NewLabel> if “bge.s”:emit(IL_##,”blt.s IL_##”) else “ble.s”:emit(IL_##,”bgt.s IL_##”) else “blt.s”:emit(IL_##,”bge.s IL_##”) else “bgt.s”:emit(IL_##,”ble.s IL_##”) else “bne.un.s”:emit(IL_##,”bne.un.s IL_##”) else “beq.s”:emit(IL_##,”beq.s IL_##”) } “brtrue.s”:emit(IL_##,”brtrue.s IL_##”) <expression list> <IFlogic> <ANDlogic> AND: <NewLabel> if “bge.s”:emit(IL_##,”bge.s IL_##”) else “ble.s”:emit(IL_##,”ble.s IL_##”) else “blt.s”:emit(IL_##,”blt.s IL_##”) else “bgt.s”:emit(IL_##,”bgt.s IL_##”) else “bne.un.s”:emit(IL_##,”beq.s IL_##”) else “beq.s”:emit(IL_##,”bne.un.s IL_##”) } “brtrue.s”:emit(IL_##,”brtrue.s IL_##”) <ANDlogic> ID | NUM: <expression> <expression list> ‘,’: <expresson> If stat. If LOGIC==false: <NewLabel> emit(IL_##,”ldc.i4.0”); emit(IL_##,”ceq”); if LOGIC == true: <NewLabel> emit(IL_##,”br.s IL_”count+3”); AND: <NewLabel> emit(IL_##,”ldc.i4.0”); OR: <NewLabel> emit(IL_##,”ldc.i4.1”);
If IFLOGIC==true: <NewLabel> emit(IL_##,”br.s IL_count+3”); <NewLabel> emit(IL_##,”ceq”); <NewLabel> emit(IL_##,”ldc.i4.0”); <NewLabel> emit(IL_##,”stloc.ii.ToString”); <NewLabel> emit(IL_##,”ldloc.ii.Tostring”); ii++;
<NewLabel> emit(IL_##,”brtrue.s IL_”BIF” ”); Then else : Brif =count; <NewLabel> emit(IL_##,”br.s IL_”BrIF” ”); BIF=count; ( While stat. f= lookahead.code; d= lookahead.attr; ) Do Begin If f==NUM; If f==ID; <Newlabel>: “<” : emit(“IL_##”,”clt”); “>” : emit(“IL_##”,”cgt”); “<=” : {emit(“IL_##”,”cgt”); emit(“IL_##,”ldc.i4.0”); emit(“IL_##,”ceq”);} “>=” : {emit(“IL_##”,”clt”); emit(“IL_##,”ldc.i4.0”); emit(“IL_##,”ceq”);} “==” : emit(“IL_##”,”ceq”); “<>” : emit(“IL_##”,”ceq”); <NewLabel> emit(IL_##,”stloc.ii.ToString”); <NewLabel> emit(IL_##,”ldloc.ii.Tostring”); ii++;
<NewLabel> emit(IL_##,”brtrue.s IL_”Brtrue” ”); End ;
DCSPM is programmed in Microsoft visual C# Express 2010 that is contained in the MSDN Library, which you can install locally on your own computer or network, and which is also available on the internet at http://msdn.microsoft.com/library. “C# (pronounced "C sharp") is a programming language that is designed for building a variety of applications that run on the .NET Framework. C# is simple, powerful, type-safe, and object-oriented. The many innovations in C# enable rapid application development while retaining the expressiveness and elegance of C-style languages. Visual C# is an implementation of the C# language by Microsoft. Visual Studio supports Visual C# with a full-featured code editor, compiler, project templates, designers, code wizards, a powerful and easy-to-use debugger, and other tools. The .NET Framework class library provides access to many operating system services and other useful, well-designed classes that speed up the development cycle significantly” [18]. “This effectively reduces the refactoring capabilities of Visual C# Express to Renaming and Extracting Methods. Developers state the reason of this removal as "to simplify the C# Express user experience". However this created a controversy as some end users claim it is an important feature, and instead of simplifying it cripples the user experience. The ability to attach the debugger to an already-running process has also been removed, hindering scenarios such as writing Windows services and re-attaching a debugger under ASP.NET when errors under the original debugging session cause breakpoints to be ignored. Additionally it has been observed that the express version requires that the time between builds be greater than approximately 20 seconds. If a project is rapidly modified and rebuilt the target will not be updated even though the source has been modified and saved.”[19]
The steps required to create a .NET application :
Figure 10: Application Code using .NET
Figure 11: JIT Compilation
Figure 12: .NET CLR Microsoft Visual C# is a programming environment used to create computer applications for the Microsoft Windows family of operating systems. It combines the C# language and the .NET Framework. To test the MSIL, I general used the MSIL Disassembler (Ildasm.exe) tool that is included with the .NET Framework SDK. The Ildasm.exe parses any .NET Framework .exe or .dll assembly, and shows the information in human-readable format. Ildasm.exe shows more than just the Microsoft intermediate language (MSIL) code — it also displays namespaces and types, including their interfaces. You can use Ildasm.exe to examine native .NET Framework assemblies, such as Mscorlib.dll, as well as .NET Framework assemblies provided by others or created yourself. Most .NET Framework developers will find Ildasm.exe indispensable. You can find this tool FrameworkSDK\Bin\ildasm.exe in your computer as I explained that in Background section 2.
In the lexical analysis, the symbol table used the Array list data structure which may not always offer the best performance for a given task. The symbol table is a data structure , where each keyword and identifier in a program's source code is associated with information relating to its declaration or appearance in the source, such as its type, scope level and sometimes its location. public static ArrayList a = new ArrayList(); public static void insertKeyword() {
a.Add(new SymbolTable("And", 301)); a.Add(new SymbolTable("Case", 302)); a.Add(new SymbolTable("Const", 303)); a.Add(new SymbolTable("Div", 304)); . . . }
public static Dictionary public static void insertKeyword() {
a.Add("And", 301); a.Add("Case", 302); a.Add("Const", 303); a.Add("Div", 304); . . . . } So, in dictionary data structure doesn’t have a struct type to represent its objects.
We can optimize “if statement” MSIL by removing ldc.i4.0 instruction and ceq instruction and replacing brtrue.s with brfalse.s and getting same results that before optimization. We can see this in sample code below. Sample code:
if (a == 1) { a = b + c; } Improvement MSIL Of Code: IL_0000: nop IL_0001: ldc.i4.0 IL_0002: stloc.0 IL_0003: ldc.i4.1 IL_0004: stloc.1 IL_0005: ldc.i4.2 IL_0006: stloc.2 IL_0007: ldloc.0 IL_0008: ldc.i4.1
IL_000c: ceq IL_000e: stloc.3 IL_000f: ldloc.3
IL_0013: ldloc.1 IL_0014: ldloc.2 IL_0015: add IL_0016: stloc.0 IL_0017: nop IL_0018: ret
The section describes the evaluation and performance of the DCSPM Compiler in two stages. First stage is the symbol table of lexical analysis and second stage is the MSIL results. I have tested different types of code such as 11,22,33,44,55,66,77,88, and 99 lines in lexical analysis phase which is using array list data structure and lexical analysis phase which is using dictionary data structure. Table 1 is shows the results of the array list and dictionary.
Table 1: Array list data structure vs. Dictionary data structure It’s obvious that when lexical analysis is using dictionary data structure is faster than array list data structure such as the chart shown in Figure 14. Time ms Lines of Program Figure 14: Array list data structure vs. Dictionary data structure “The Dictionary These are differences between dictionary and array list what we've learned in a quick reference table. [23]
“ArrayList resizes dynamically. As elements are added, it grows in capacity to accommodate them. It is most often used in older C# programs. It stores a collection of elements of type object. This makes casting necessary.” [24] Second stage is that comparison between the unimproved if/else MSIL results and improved if/else MSIL results.
Yüklə 1,28 Mb. Dostları ilə paylaş:
|