Edinburgh IMP77 Compiler - Version 8.4 1 %external %routine %spec Proc 6 (%integer {Enumeration} Enum Val Par, %integer {Enumeration} %name Enum Ref Par) .Ltext0: .section .rodata .LC1: .string "test-in/dhry_2.imp" .align 4 .LC2: .string "->EV(%d) out of bounds at %s line %d" .align 4 .LC3: .string "switch jump to undefined label EV(%d): at %s line %d" .align 32 .LC0: .byte 18 .string "test-in/dhry_2.imp" .zero 236 .globl PROC6 PROC6: .LFB189: 2 %external %routine %spec Proc 7 (%integer {One Fifty} Int 1 Par Val, 3 %integer {One Fifty} Int 2 Par Val, 4 %integer {One Fifty} %name Int Par Ref) 5 %external %routine %spec Proc 8 (%integer %array %name Arr 1 Par Ref {(0:49)}, 6 %integer %array %name Arr 2 Par Ref {(0:50*50-1)} {(0:49, 0:49)}, 7 %integer Int 1 Par Val, 8 %integer Int 2 Par Val) 9 %external %integer {Enumeration} %fn %spec Func 1 (%integer {Capital Letter} Ch 1 Par Val, 10 %integer {Capital Letter} Ch 2 Par Val) 11 %external %predicate %spec Func 2 (%string (30) %name Str 1 Par Ref, %string (30) %name Str 2 Par Ref) 12 %external %predicate %spec Func 3 (%integer {Enumeration} Enum Par Val) 13 14 ! **************************************************************************** 15 ! * 16 ! * "DHRYSTONE" Benchmark Program 17 ! * ----------------------------- 18 ! * 19 ! * Version: Imp, Version 2.1 20 ! * 21 ! * File: dhry_2.c (part 3 of 3) 22 ! * 23 ! * Date: May 25, 1988 & Mar 30, 2026 24 ! * 25 ! * Author: Reinhold P. Weicker, translated from C to Imp by Graham Toal 26 ! * 27 ! **************************************************************************** 28 29 %include "dhry.inc" &1 ! This translation to Imp derived from https://github.com/sifive/benchmark-dhrystone/ &2 &3 ! *************************************************************************** &4 ! &5 ! "DHRYSTONE" Benchmark Program &6 ! ----------------------------- &7 ! &8 ! Version: C, Version 2.1 &9 ! &10 ! File: dhry.h (part 1 of 3) &11 ! &12 ! Date: May 25, 1988 &13 ! &14 ! Author: Reinhold P. Weicker &15 ! Siemens AG, E STE 35 &16 ! Postfach 3240 &17 ! 8520 Erlangen &18 ! Germany (West) &19 ! Phone: [xxx-49]-9131-7-20330 &20 ! (8-17 Central European Time) &21 ! Usenet: ..!mcvax!unido!estevax!weicker &22 ! &23 ! Original Version (in Ada) published in &24 ! "Communications of the ACM" vol. 27., no. 10 (Oct. 1984), &25 ! pp. 1013 - 1030, together with the statistics &26 ! on which the distribution of statements etc. is based. &27 ! &28 ! In this C version, the following C library functions are used: &29 ! - strcpy, strcmp (inside the measurement loop) &30 ! - printf, scanf (outside the measurement loop) &31 ! In addition, Berkeley UNIX system calls "times ()" or "time ()" &32 ! are used for execution time measurement. For measurements &33 ! on other systems, these calls have to be changed. &34 ! &35 ! Collection of Results: &36 ! Reinhold Weicker (address see above) and &37 ! &38 ! Rick Richardson &39 ! PC Research. Inc. &40 ! 94 Apple Orchard Drive &41 ! Tinton Falls, NJ 07724 &42 ! Phone: (201) 389-8963 (9-17 EST) &43 ! Usenet: ...!uunet!pcrat!rick &44 ! &45 ! Please send results to Rick Richardson and/or Reinhold Weicker. &46 ! Complete information should be given on hardware and software used. &47 ! Hardware information includes: Machine type, CPU, type and size &48 ! of caches; for microprocessors: clock frequency, memory speed &49 ! (number of wait states). &50 ! Software information includes: Compiler (and runtime library) &51 ! manufacturer and version, compilation switches, OS version. &52 ! The Operating System version may give an indication about the &53 ! compiler; Dhrystone itself performs no OS calls in the measurement loop. &54 ! &55 ! The complete output generated by the program should be mailed &56 ! such that at least some checks for correctness can be made. &57 ! &58 ! ************************************************************************** &59 ! &60 ! History: This version C/2.1 has been made for two reasons: &61 ! &62 ! 1) There is an obvious need for a common C version of &63 ! Dhrystone, since C is at present the most popular system &64 ! programming language for the class of processors &65 ! (microcomputers, minicomputers) where Dhrystone is used most. &66 ! There should be, as far as possible, only one C version of &67 ! Dhrystone such that results can be compared without &68 ! restrictions. In the past, the C versions distributed &69 ! by Rick Richardson (Version 1.1) and by Reinhold Weicker &70 ! had small (though not significant) differences. &71 ! &72 ! 2) As far as it is possible without changes to the Dhrystone &73 ! statistics, optimizing compilers should be prevented from &74 ! removing significant statements. &75 ! &76 ! This C version has been developed in cooperation with &77 ! Rick Richardson (Tinton Falls, NJ), it incorporates many &78 ! ideas from the "Version 1.1" distributed previously by &79 ! him over the UNIX network Usenet. &80 ! I also thank Chaim Benedelac (National Semiconductor), &81 ! David Ditzel (SUN), Earl Killian and John Mashey (MIPS), &82 ! Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley) &83 ! for their help with comments on earlier versions of the &84 ! benchmark. &85 ! &86 ! Changes: In the initialization part, this version follows mostly &87 ! Rick Richardson's version distributed via Usenet, not the &88 ! version distributed earlier via floppy disk by Reinhold Weicker. &89 ! As a concession to older compilers, names have been made &90 ! unique within the first 8 characters. &91 ! Inside the measurement loop, this version follows the &92 ! version previously distributed by Reinhold Weicker. &93 ! &94 ! At several places in the benchmark, code has been added, &95 ! but within the measurement loop only in branches that &96 ! are not executed. The intention is that optimizing compilers &97 ! should be prevented from moving code out of the measurement &98 ! loop, or from removing code altogether. Since the statements &99 ! that are executed within the measurement loop have NOT been 0 ! changed, the numbers defining the "Dhrystone distribution" 0 ! (distribution of statements, operand types and locality) 0 ! still hold. Except for sophisticated optimizing compilers, 0 ! execution times for this version should be the same as 0 ! for previous versions. 0 ! 0 ! Since it has proven difficult to subtract the time for the 0 ! measurement loop overhead in a correct way, the loop check 0 ! has been made a part of the benchmark. This does have 0 ! an impact - though a very minor one - on the distribution 0 ! statistics which have been updated for this version. 0 ! 0 ! All changes within the measurement loop are described 0 ! and discussed in the companion paper "Rationale for 0 ! Dhrystone version 2". 0 ! 0 ! Because of the self-imposed limitation that the order and 0 ! distribution of the executed statements should not be 0 ! changed, there are still cases where optimizing compilers 0 ! may not generate code for some statements. To a certain 0 ! degree, this is unavoidable for small synthetic benchmarks. 0 ! Users of the benchmark are advised to check code listings 0 ! whether code is generated for all statements of Dhrystone. 0 ! 0 ! Version 2.1 is identical to version 2.0 distributed via 0 ! the UNIX network Usenet in March 1988 except that it corrects 0 ! some minor deficiencies that were found by users of version 2.0. 0 ! The only change within the measurement loop is that a 0 ! non-executed "else" part was added to the "if" statement in 0 ! Func_3, and a non-executed "else" part removed from Proc_3. 0 ! 0 ! ************************************************************************** 0 ! 0 ! Defines: The following "Defines" are possible: 0 ! -DREG=register (default: Not defined) 0 ! As an approximation to what an average C programmer 0 ! might do, the "register" storage class is applied 0 ! (if enabled by -DREG=register) 0 ! - for local variables, if they are used (dynamically) 0 ! five or more times 0 ! - for parameters if they are used (dynamically) 0 ! six or more times 0 ! Note that an optimal "register" strategy is 0 ! compiler-dependent, and that "register" declarations 0 ! do not necessarily lead to faster execution. 0 ! -DNOSTRUCTASSIGN (default: Not defined) 0 ! Define if the C compiler does not support 0 ! assignment of structures. 0 ! -DNOENUMS (default: Not defined) 0 ! Define if the C compiler does not support 0 ! enumeration types. 0 ! -DTIMES (default) 0 ! -DTIME 0 ! The "times" function of UNIX (returning process times) 0 ! or the "time" function (returning wallclock time) 0 ! is used for measurement. 0 ! For single user machines, "time ()" is adequate. For 0 ! multi-user machines where you cannot get single-user 0 ! access, use the "times ()" function. If you have 0 ! neither, use a stopwatch in the dead of night. 0 ! "printf"s are provided marking the points "Start Timer" 0 ! and "Stop Timer". DO NOT use the UNIX "time(1)" 0 ! command, as this will measure the total time to 0 ! run this program, which will (erroneously) include 0 ! the time to allocate storage (malloc) and to perform 0 ! the initialization. 0 ! -DHZ=nnn 0 ! In Berkeley UNIX, the function "times" returns process 0 ! time in 1/HZ seconds, with HZ = 60 for most systems. 0 ! CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY 0 ! A VALUE. 0 ! 0 ! ************************************************************************** 0 ! 0 ! Compilation model and measurement (IMPORTANT): 0 ! 0 ! This C version of Dhrystone consists of three files: 0 ! - dhry.h (this file, containing global definitions and comments) 0 ! - dhry_1.c (containing the code corresponding to Ada package Pack_1) 0 ! - dhry_2.c (containing the code corresponding to Ada package Pack_2) 0 ! 0 ! The following "ground rules" apply for measurements: 0 ! - Separate compilation 0 ! - No procedure merging 0 ! - Otherwise, compiler optimizations are allowed but should be indicated 0 ! - Default results are those without register declarations 0 ! See the companion paper "Rationale for Dhrystone Version 2" for a more 0 ! detailed discussion of these ground rules. 0 ! 0 ! For 16-Bit processors (e.g. 80186, 80286), times for all compilation 0 ! models ("small", "medium", "large" etc.) should be given if possible, 0 ! together with a definition of these models for the compiler system used. 0 ! 0 ! ************************************************************************* 0 ! 0 ! Dhrystone (C version) statistics: 0 ! 0 ! [Comment from the first distribution, updated for version 2. 0 ! Note that because of language differences, the numbers are slightly 0 ! different from the Ada version.] 0 ! 0 ! The following program contains statements of a high level programming 0 ! language (here: C) in a distribution considered representative: 0 ! 0 ! assignments 52 (51.0 %) 0 ! control statements 33 (32.4 %) 0 ! procedure, function calls 17 (16.7 %) 0 ! 0 ! 103 statements are dynamically executed. The program is balanced with 0 ! respect to the three aspects: 0 ! 0 ! - statement type 0 ! - operand type 0 ! - operand locality 0 ! operand global, local, parameter, or constant. 0 ! 0 ! The combination of these three aspects is balanced only approximately. 0 ! 0 ! 1. Statement Type: 0 ! ----------------- number 0 ! 0 ! V1 = V2 9 0 ! (incl. V1 = F(..) 0 ! V = Constant 12 0 ! Assignment, 7 0 ! with array element 0 ! Assignment, 6 0 ! with record component 0 ! -- 0 ! 34 34 0 ! 0 ! X = Y +|-|"&&"|"|" Z 5 0 ! X = Y +|-|"==" Constant 6 0 ! X = X +|- 1 3 0 ! X = Y *|/ Z 2 0 ! X = Expression, 1 0 ! two operators 0 ! X = Expression, 1 0 ! three operators 0 ! -- 0 ! 18 18 0 ! 0 ! if .... 14 0 ! with "else" 7 0 ! without "else" 7 0 ! executed 3 0 ! not executed 4 0 ! for ... 7 | counted every time 0 ! while ... 4 | the loop condition 0 ! do ... while 1 | is evaluated 0 ! switch ... 1 0 ! break 1 0 ! declaration with 1 0 ! initialization 0 ! -- 0 ! 34 34 0 ! 0 ! P (...) procedure call 11 0 ! user procedure 10 0 ! library procedure 1 0 ! X = F (...) 0 ! function call 6 0 ! user function 5 0 ! library function 1 0 ! -- 0 ! 17 17 0 ! --- 0 ! 103 0 ! 0 ! The average number of parameters in procedure or function calls 0 ! is 1.82 (not counting the function values aX * 0 ! 0 ! 2. Operators 0 ! ------------ 0 ! number approximate 0 ! percentage 0 ! 0 ! Arithmetic 32 50.8 0 ! 0 ! + 21 33.3 0 ! - 7 11.1 0 ! * 3 4.8 0 ! / (int div) 1 1.6 0 ! 0 ! Comparison 27 42.8 0 ! 0 ! == 9 14.3 0 ! /= 4 6.3 0 ! > 1 1.6 0 ! < 3 4.8 0 ! >= 1 1.6 0 ! <= 9 14.3 0 ! 0 ! Logic 4 6.3 0 ! 0 ! && (AND-THEN) 1 1.6 0 ! | (OR) 1 1.6 0 ! ! (NOT) 2 3.2 0 ! 0 ! -- ----- 0 ! 63 100.1 0 ! 0 ! 0 ! 3. Operand Type (counted once per operand reference): 0 ! --------------- 0 ! number approximate 0 ! percentage 0 ! 0 ! Integer 175 72.3 % 0 ! Character 45 18.6 % 0 ! Pointer 12 5.0 % 0 ! String30 6 2.5 % 0 ! Array 2 0.8 % 0 ! Record 2 0.8 % 0 ! --- ------- 0 ! 242 100.0 % 0 ! 0 ! When there is an access path leading to the final operand (e.g. a record 0 ! component), only the final data type on the access path is counted. 0 ! 0 ! 0 ! 4. Operand Locality: 0 ! ------------------- 0 ! number approximate 0 ! percentage 0 ! 0 ! local variable 114 47.1 % 0 ! global variable 22 9.1 % 0 ! parameter 45 18.6 % 0 ! value 23 9.5 % 0 ! reference 22 9.1 % 0 ! function result 6 2.5 % 0 ! constant 55 22.7 % 0 ! --- ------- 0 ! 242 100.0 % 0 ! 0 ! 0 ! The program does not compute anything meaningful, but it is syntactically 0 ! and semantically correct. All variables have a value assigned to them 0 ! before they are used as a source operand. 0 ! 0 ! There has been no explicit effort to account for the effects of a 0 ! cache, or to balance the use of long or short displacements for code or 0 ! data. 0 ! 0 ! ************************************************************************** 0 0 { Compiler and system dependent definitions: } 0 0 { Use times(2) time function unless } 0 { explicitly defined otherwise } 0 0 { Use Microsoft C hi-res clock } 0 0 %const %integer Mic secs Per Second = 1000000 { Berkeley UNIX C returns process times in seconds/HZ } 0 0 !! If using gtcpp: 0 !! $define structassign(d, s) d = s 0 0 %const %integer Ident 1 = 0 0 %const %integer Ident 2 = 1 0 %const %integer Ident 3 = 2 0 %const %integer Ident 4 = 3 0 %const %integer Ident 5 = 4 0 ! typedef int Enumeration; 0 0 { for boolean and enumeration types in Ada, Pascal } 0 0 { General definitions: } 0 0 { Value of a Null pointer } 0 !!%external %record (*) %name %spec Null 0 %const %integer true = 1 0 %const %integer false = 0 0 0 ! typedef int One Thirty; 0 ! typedef int One Fifty; 0 ! typedef char Capital Letter; 0 ! typedef int Boolean; 0 ! typedef char Str 30 [31]; 0 ! typedef int Arr 1 Dim [50]; 0 ! typedef int Arr 2 Dim [50] [50]; 0 0 0 %recordformat var 1 fm (%integer {Enumeration} Enum Comp, %integer Int Comp, %string (30) Str Comp) 0 %recordformat var 2 fm (%integer {Enumeration} E Comp 2, %string (30) Str 2 Comp) 0 %recordformat var 3 fm (%byteinteger Ch 1 Comp, %byteinteger Ch 2 Comp) 0 %recordformat variant fm (%record (var 1 fm) var 1 %or %record (var 2 fm) var 2 %or %record (var 3 fm) var 3) 0 %recordformat Rec Type fm (%record (Rec Type fm) %name Ptr Comp, 0 %integer {Enumeration} Discr, 0 %record (variant fm) variant) 0 0 %external %record (Rec Type fm) %spec Rec Type 0 %external %record (Rec Type fm) %name %spec Rec Pointer; 0 0 %endoffile 30 31 %external %integer %spec Int Glob 32 %external %byte %integer %spec Ch 1 Glob 33 34 35 %external %routine Proc 6 (%integer {Enumeration} Enum Val Par, %integer {Enumeration} %name Enum Ref Par) pushl %ebp movl %esp, %ebp pushl %edi pushl %esi pushl %ebx subl $1068, %esp call __x86.get_pc_thunk.bx addl $_GLOBAL_OFFSET_TABLE_, %ebx movl 12(%ebp), %eax movl %eax, -1068(%ebp) movl %gs:20, %eax movl %eax, -28(%ebp) xorl %eax, %eax 36 {*******************************} 37 { executed once } 38 { Enum Val Par == Ident 3, Enum Ref Par becomes Ident 2 } 39 %switch EV(Ident 1:Ident 5) 40 41 Enum Ref Par = Enum Val Par movl -1068(%ebp), %eax movl 8(%ebp), %edx movl %edx, (%eax) 42 Enum Ref Par = Ident 4 %if %not Func 3 (Enum Val Par) { then, not executed } subl $12, %esp pushl 8(%ebp) call FUNC3 addl $16, %esp testl %eax, %eax jne .L21 movl -1068(%ebp), %eax movl $3, (%eax) jmp .L3 .L21: nop .L3: 43 44 ->EV(Enum Val Par) movl $44, -1064(%ebp) leal .LC1@GOTOFF(%ebx), %eax movl %eax, -1060(%ebp) movl 8(%ebp), %eax movl %eax, -1056(%ebp) nop .L4: 45 46 EV(Ident 1): 47 Enum Ref Par = Ident 1 48 ->end 49 50 EV(Ident 2): 51 %if Int Glob > 100 %then Enum Ref Par = Ident 1 %c 52 %else Enum Ref Par = Ident 4 53 ->end 54 55 EV(Ident 3): { executed } 56 Enum Ref Par = Ident 2 57 ->end 58 59 EV(Ident 4): ->end 60 61 EV(Ident 5): 62 Enum Ref Par = Ident 3 63 ->end 64 65 end: { switch } 66 %end { Proc 6 } cmpl $0, -1056(%ebp) js .L5 cmpl $4, -1056(%ebp) jle .L6 .L5: movl _imp_current_line@GOT(%ebx), %eax movl (%eax), %eax testl %eax, %eax je .L7 movl _imp_current_line@GOT(%ebx), %eax movl (%eax), %eax movl %eax, -1072(%ebp) jmp .L8 .L7: movl $66, -1072(%ebp) .L8: movl _imp_current_file@GOT(%ebx), %eax movl (%eax), %eax testl %eax, %eax je .L9 movl _imp_current_file@GOT(%ebx), %eax movl (%eax), %edx leal -540(%ebp), %eax subl $8, %esp pushl %edx pushl %eax call _imp_c2istr@PLT addl $12, %esp jmp .L10 .L9: .LBB7: leal -284(%ebp), %eax leal .LC0@GOTOFF(%ebx), %edx movl $64, %ecx movl %eax, %edi movl %edx, %esi rep movsl leal -1052(%ebp), %eax leal -284(%ebp), %edx movl $64, %ecx movl %eax, %edi movl %edx, %esi rep movsl .LBE7: leal -540(%ebp), %eax leal -1052(%ebp), %edx movl $64, %ecx movl %eax, %edi movl %edx, %esi rep movsl .L10: pushl -1064(%ebp) pushl -1060(%ebp) pushl -1056(%ebp) leal .LC2@GOTOFF(%ebx), %eax pushl %eax pushl -1056(%ebp) pushl $3 pushl $6 pushl -1072(%ebp) subl $256, %esp movl %esp, %eax movl %eax, %edi leal -540(%ebp), %eax movl $64, %edx movl %eax, %esi movl %edx, %ecx rep movsl call _signal_eventf@PLT addl $288, %esp .L6: nop .L12: movl _imp_current_line@GOT(%ebx), %eax movl (%eax), %eax testl %eax, %eax je .L20 movl _imp_current_line@GOT(%ebx), %eax movl (%eax), %eax movl %eax, -1072(%ebp) jmp .L15 .L20: movl $66, -1072(%ebp) .L15: movl _imp_current_file@GOT(%ebx), %eax movl (%eax), %eax testl %eax, %eax je .L16 movl _imp_current_file@GOT(%ebx), %eax movl (%eax), %edx leal -284(%ebp), %eax subl $8, %esp pushl %edx pushl %eax call _imp_c2istr@PLT addl $12, %esp jmp .L17 .L16: .LBB8: leal -284(%ebp), %eax leal .LC0@GOTOFF(%ebx), %edx movl $64, %ecx movl %eax, %edi movl %edx, %esi rep movsl leal -796(%ebp), %eax leal -284(%ebp), %edx movl $64, %ecx movl %eax, %edi movl %edx, %esi rep movsl .LBE8: leal -284(%ebp), %eax leal -796(%ebp), %edx movl $64, %ecx movl %eax, %edi movl %edx, %esi rep movsl .L17: pushl -1064(%ebp) pushl -1060(%ebp) pushl -1056(%ebp) leal .LC3@GOTOFF(%ebx), %eax pushl %eax pushl -1056(%ebp) pushl $2 pushl $8 pushl -1072(%ebp) subl $256, %esp movl %esp, %eax movl %eax, %edi leal -284(%ebp), %eax movl $64, %edx movl %eax, %esi movl %edx, %ecx rep movsl call _signal_eventf@PLT addl $288, %esp movl -28(%ebp), %eax xorl %gs:20, %eax je .L19 call __stack_chk_fail_local .L19: leal -12(%ebp), %esp popl %ebx popl %esi popl %edi popl %ebp ret .LFE189: .globl PROC7 PROC7: .LFB190: 67 68 69 %external %routine Proc 7 (%integer {One Fifty} Int 1 Par Val, pushl %ebp movl %esp, %ebp subl $16, %esp call __x86.get_pc_thunk.ax addl $_GLOBAL_OFFSET_TABLE_, %eax 70 %integer {One Fifty} Int 2 Par Val, 71 %integer {One Fifty} %name Int Par Ref) 72 {********************************************} 73 { executed three times } 74 { first call: Int 1 Par Val == 2, Int 2 Par Val == 3, } 75 { Int Par Ref becomes 7 } 76 { second call: Int 1 Par Val == 10, Int 2 Par Val == 5, } 77 { Int Par Ref becomes 17 } 78 { third call: Int 1 Par Val == 6, Int 2 Par Val == 10, } 79 { Int Par Ref becomes 18 } 80 %integer {One Fifty} Int Loc 81 82 Int Loc = Int 1 Par Val + 2 movl 8(%ebp), %eax addl $2, %eax movl %eax, -4(%ebp) 83 Int Par Ref = Int 2 Par Val + Int Loc movl 12(%ebp), %edx movl -4(%ebp), %eax addl %eax, %edx movl 16(%ebp), %eax movl %edx, (%eax) 84 %end { Proc 7 } nop leave ret .LFE190: .section .rodata .align 4 .LC4: .string "Illegal cycle INTINDEX = INTLOC, 1, INTLOC + 1" .globl PROC8 PROC8: .LFB191: 85 86 87 %external %routine Proc 8 (%integer %array %name Arr 1 Par Ref {(0:49)}, pushl %ebp movl %esp, %ebp pushl %edi pushl %esi pushl %ebx subl $828, %esp call __x86.get_pc_thunk.bx addl $_GLOBAL_OFFSET_TABLE_, %ebx movl 8(%ebp), %eax movl %eax, -828(%ebp) movl 12(%ebp), %eax movl %eax, -832(%ebp) movl %gs:20, %eax movl %eax, -28(%ebp) xorl %eax, %eax 88 %integer %array %name Arr 2 Par Ref {(0:50*50-1)} {(0:49, 0:49)}, 89 %integer Int 1 Par Val, 90 %integer Int 2 Par Val) 91 {*******************************************************************} 92 { executed once } 93 { Int Par Val 1 == 3 } 94 { Int Par Val 2 == 7 } 95 %integer {One Fifty} Int Index 96 %integer {One Fifty} Int Loc 97 98 Int Loc = Int 1 Par Val + 5 movl 16(%ebp), %eax addl $5, %eax movl %eax, -812(%ebp) 99 Arr 1 Par Ref (Int Loc) = Int 2 Par Val movl -812(%ebp), %eax leal 0(,%eax,4), %edx movl -828(%ebp), %eax addl %eax, %edx movl 20(%ebp), %eax movl %eax, (%edx) 100 Arr 1 Par Ref (Int Loc+1) = Arr 1 Par Ref (Int Loc) movl -812(%ebp), %eax leal 0(,%eax,4), %edx movl -828(%ebp), %eax addl %edx, %eax movl -812(%ebp), %edx addl $1, %edx leal 0(,%edx,4), %ecx movl -828(%ebp), %edx addl %ecx, %edx movl (%eax), %eax movl %eax, (%edx) 101 Arr 1 Par Ref (Int Loc+30) = Int Loc movl -812(%ebp), %eax addl $30, %eax leal 0(,%eax,4), %edx movl -828(%ebp), %eax addl %eax, %edx movl -812(%ebp), %eax movl %eax, (%edx) .LBB9: 102 Arr 2 Par Ref (Int Loc*50 + Int Index) {(Int Loc, Int Index)} = Int Loc %for Int Index = Int Loc, 1, Int Loc+1 movl -812(%ebp), %eax movl %eax, -808(%ebp) movl -812(%ebp), %eax addl $1, %eax movl %eax, -804(%ebp) .LBB10: movl -804(%ebp), %eax subl -808(%ebp), %eax movl %eax, -800(%ebp) movl -800(%ebp), %eax xorl $1, %eax shrl $31, %eax movzbl %al, %eax .LBE10: testl %eax, %eax je .L25 leal -540(%ebp), %eax subl $8, %esp leal .LC4@GOTOFF(%ebx), %edx pushl %edx pushl %eax call _imp_c2istr@PLT addl $12, %esp movl _imp_current_line@GOT(%ebx), %eax movl (%eax), %eax testl %eax, %eax je .L26 movl _imp_current_line@GOT(%ebx), %eax movl (%eax), %eax movl %eax, -836(%ebp) jmp .L27 .L26: movl $102, -836(%ebp) .L27: movl _imp_current_file@GOT(%ebx), %eax movl (%eax), %eax testl %eax, %eax je .L28 movl _imp_current_file@GOT(%ebx), %eax movl (%eax), %edx leal -284(%ebp), %eax subl $8, %esp pushl %edx pushl %eax call _imp_c2istr@PLT addl $12, %esp jmp .L29 .L28: .LBB11: leal -284(%ebp), %eax leal .LC0@GOTOFF(%ebx), %edx movl $64, %ecx movl %eax, %edi movl %edx, %esi rep movsl leal -796(%ebp), %eax leal -284(%ebp), %edx movl $64, %ecx movl %eax, %edi movl %edx, %esi rep movsl .LBE11: leal -284(%ebp), %eax leal -796(%ebp), %edx movl $64, %ecx movl %eax, %edi movl %edx, %esi rep movsl .L29: pushl $0 pushl $1 pushl $5 subl $256, %esp movl %esp, %eax movl %eax, %edi leal -540(%ebp), %eax movl $64, %edx movl %eax, %esi movl %edx, %ecx rep movsl pushl -836(%ebp) subl $256, %esp movl %esp, %eax movl %eax, %edi leal -284(%ebp), %eax movl $64, %edx movl %eax, %esi movl %edx, %ecx rep movsl call _signal_event@PLT addl $528, %esp .L25: movl -808(%ebp), %eax subl $1, %eax movl %eax, -816(%ebp) .L30: movl -816(%ebp), %eax cmpl -804(%ebp), %eax je .L36 addl $1, -816(%ebp) movl -812(%ebp), %eax imull $50, %eax, %edx movl -816(%ebp), %eax addl %edx, %eax leal 0(,%eax,4), %edx movl -832(%ebp), %eax addl %eax, %edx movl -812(%ebp), %eax movl %eax, (%edx) jmp .L30 .L36: nop .L32: .LBE9: 103 Arr 2 Par Ref (Int Loc*50 + Int Loc-1) {(Int Loc, Int Loc-1)} = Arr 2 Par Ref (Int Loc*50 + Int Loc-1){(Int Loc, Int Loc-1)} + 1 movl -812(%ebp), %eax imull $204, %eax, %eax leal -4(%eax), %edx movl -832(%ebp), %eax addl %edx, %eax movl (%eax), %edx movl -812(%ebp), %eax imull $204, %eax, %eax leal -4(%eax), %ecx movl -832(%ebp), %eax addl %ecx, %eax addl $1, %edx movl %edx, (%eax) 104 Arr 2 Par Ref ((Int Loc+20)*50 + Int Loc) {(Int Loc+20, Int Loc)} = Arr 1 Par Ref (Int Loc) movl -812(%ebp), %eax leal 0(,%eax,4), %edx movl -828(%ebp), %eax addl %edx, %eax movl -812(%ebp), %edx addl $20, %edx imull $50, %edx, %ecx movl -812(%ebp), %edx addl %ecx, %edx leal 0(,%edx,4), %ecx movl -832(%ebp), %edx addl %ecx, %edx movl (%eax), %eax movl %eax, (%edx) 105 Int Glob = 5 movl INTGLOB@GOT(%ebx), %eax movl $5, (%eax) 106 %end { Proc 8 } nop movl -28(%ebp), %eax xorl %gs:20, %eax je .L34 call __stack_chk_fail_local .L34: leal -12(%ebp), %esp popl %ebx popl %esi popl %edi popl %ebp ret .LFE191: .globl FUNC1 FUNC1: .LFB192: 107 108 109 %external %integer {Enumeration} %fn Func 1 (%integer {Capital Letter} Ch 1 Par Val, pushl %ebp movl %esp, %ebp subl $16, %esp call __x86.get_pc_thunk.ax addl $_GLOBAL_OFFSET_TABLE_, %eax 110 %integer {Capital Letter} Ch 2 Par Val) 111 {***********************************************} 112 { executed three times } 113 { first call: Ch 1 Par Val == 'H', Ch 2 Par Val == 'R' } 114 { second call: Ch 1 Par Val == 'A', Ch 2 Par Val == 'C' } 115 { third call: Ch 1 Par Val == 'B', Ch 2 Par Val == 'C' } 116 117 %integer {Capital Letter} Ch 1 Loc 118 %integer {Capital Letter} Ch 2 Loc 119 120 Ch 1 Loc = Ch 1 Par Val movl 8(%ebp), %edx movl %edx, -8(%ebp) 121 Ch 2 Loc = Ch 1 Loc movl -8(%ebp), %edx movl %edx, -4(%ebp) 122 %if Ch 2 Loc # Ch 2 Par Val %start movl -4(%ebp), %edx cmpl 12(%ebp), %edx je .L42 nop .L39: 123 { then, executed } 124 %result = Ident 1 movl $0, %eax jmp .L40 .L42: 125 %else { not executed } 126 Ch 1 Glob = Ch 1 Loc movl -8(%ebp), %edx movl CH1GLOB@GOT(%eax), %eax movb %dl, (%eax) 127 %result = Ident 2 movl $1, %eax .L40: 128 %finish 129 %end { Func 1 } leave ret .LFE192: .globl FUNC2 FUNC2: .LFB193: 130 131 132 %external %predicate Func 2 (%string (30) %name Str 1 Par Ref, %string (30) %name Str 2 Par Ref) pushl %ebp movl %esp, %ebp pushl %ebx subl $36, %esp call __x86.get_pc_thunk.bx addl $_GLOBAL_OFFSET_TABLE_, %ebx 133 {***********************************************} 134 { executed once } 135 { Str 1 Par Ref == "DHRYSTONE PROGRAM, 1'ST STRING" } 136 { Str 2 Par Ref == "DHRYSTONE PROGRAM, 2'ND STRING" } 137 138 %integer {One Thirty} Int Loc 139 %integer {Capital Letter} Ch Loc 140 141 Int Loc = 2 movl $2, -36(%ebp) .L44: 142 %while Int Loc <= 2 %cycle { loop body executed once } cmpl $2, -36(%ebp) jg .L62 nop .L46: .LBB16: 143 %if Func 1 (CHARNO(Str 1 Par Ref, Int Loc), movl -36(%ebp), %eax leal 1(%eax), %edx movl 12(%ebp), %eax movl %eax, -16(%ebp) movl %edx, -12(%ebp) .LBB12: .LBB13: movl -16(%ebp), %edx movl -12(%ebp), %eax addl %edx, %eax .LBE13: .LBE12: movzbl (%eax), %eax movzbl %al, %edx movl 8(%ebp), %eax movl %eax, -24(%ebp) movl -36(%ebp), %eax movl %eax, -20(%ebp) .LBB14: .LBB15: movl -24(%ebp), %ecx movl -20(%ebp), %eax addl %ecx, %eax .LBE15: .LBE14: movzbl (%eax), %eax movzbl %al, %eax pushl %edx pushl %eax call FUNC1 addl $8, %esp testl %eax, %eax jne .L63 nop .L50: 144 CHARNO(Str 2 Par Ref, Int Loc+1)) = Ident 1 %start { then, executed } 145 Ch Loc = 'A' movl $65, -32(%ebp) 146 Int Loc = Int Loc + 1 addl $1, -36(%ebp) jmp .L44 .L63: 147 %finish { if } 148 %repeat { while } jmp .L44 .L62: 149 Int Loc = 7 %if 'W' <= Ch Loc < 'Z' { then, not executed } movl -32(%ebp), %eax movl %eax, -28(%ebp) cmpl $86, -28(%ebp) jle .L64 cmpl $89, -28(%ebp) jg .L65 .LBE16: movl $7, -36(%ebp) jmp .L52 .L64: .LBB17: nop jmp .L52 .L65: nop .L52: .LBE17: 150 151 %true %if Ch Loc = 'R' { then, not executed } cmpl $82, -32(%ebp) jne .L66 movl $1, %eax jmp .L56 .L66: nop .L55: 152 153 { else executed } 154 %if Str 1 Par Ref > Str 2 Par Ref %start subl $8, %esp pushl 12(%ebp) pushl 8(%ebp) call _imp_strcmp@PLT addl $16, %esp testl %eax, %eax jle .L67 nop .L58: 155 { then, not executed } 156 Int Loc = Int Loc + 7 addl $7, -36(%ebp) 157 Int Glob = Int Loc movl INTGLOB@GOT(%ebx), %eax movl -36(%ebp), %edx movl %edx, (%eax) 158 %true movl $1, %eax jmp .L56 .L67: 159 %finish %else %false { executed } movl $0, %eax .L56: 160 { if Ch Loc } 161 %end { Func 2 } movl -4(%ebp), %ebx leave ret .LFE193: .globl FUNC3 FUNC3: .LFB194: 162 163 164 %external %predicate Func 3 (%integer {Enumeration} Enum Par Val) pushl %ebp movl %esp, %ebp subl $16, %esp call __x86.get_pc_thunk.ax addl $_GLOBAL_OFFSET_TABLE_, %eax 165 {*************************} 166 { executed once } 167 { Enum Par Val == Ident 3 } 168 %integer {Enumeration} Enum Loc 169 Enum Loc = Enum Par Val movl 8(%ebp), %eax movl %eax, -4(%ebp) 170 %true %if Enum Loc = Ident 3 { then, executed } cmpl $2, -4(%ebp) jne .L73 movl $1, %eax jmp .L71 .L73: nop .L70: 171 %false { not executed } movl $0, %eax .L71: 172 %end { Func 3 } leave ret .LFE194: .section .data.rel.local,"aw",@progbits .align 4 EV.6090: .long .L12 .long .L12 .long .L12 .long .L12 .long .L12 .section .text.__x86.get_pc_thunk.ax,"axG",@progbits,__x86.get_pc_thunk.ax,comdat .globl __x86.get_pc_thunk.ax .hidden __x86.get_pc_thunk.ax __x86.get_pc_thunk.ax: .LFB195: movl (%esp), %eax ret .LFE195: .section .text.__x86.get_pc_thunk.bx,"axG",@progbits,__x86.get_pc_thunk.bx,comdat .globl __x86.get_pc_thunk.bx .hidden __x86.get_pc_thunk.bx __x86.get_pc_thunk.bx: .LFB196: movl (%esp), %ebx ret .LFE196: .Letext0: 173 174 %end %of %file 94 Statements compiled