#include // 1 %external %record (*) %name Null == 0 #line 1 "dhry_1.imp" void /*name*/*NULL = { 0 } /* Initialise all fields of a record to 0. */; // 2 // 3 %external %routine %spec Proc 6 (%integer {Enumeration} Enum Val Par, %integer {Enumeration} %name Enum Ref Par) #line 3 "dhry_1.imp" extern void PROC6( int ENUMVALPAR, int /*name*/*ENUMREFPAR ); // 4 %external %routine %spec Proc 7 (%integer {One Fifty} Int 1 Par Val, #line 4 "dhry_1.imp" extern void PROC7( int INT1PARVAL, int INT2PARVAL, int /*name*/*INTPARREF ); // 5 %integer {One Fifty} Int 2 Par Val, // 6 %integer {One Fifty} %name Int Par Ref) // 7 %external %routine %spec Proc 8 (%integer %array %name Arr 1 Par Ref {(0:49)}, #line 7 "dhry_1.imp" extern void PROC8( int /*arrayname*/*ARR1PARREF, int /*arrayname*/*ARR2PARREF, int INT1PARVAL, int INT2PARVAL ); // 8 %integer %array %name Arr 2 Par Ref {(0:50*50-1)} {(0:49, 0:49)}, // 9 %integer Int 1 Par Val, // 10 %integer Int 2 Par Val) // 11 %external %integer {Enumeration} %fn %spec Func 1 (%integer {Capital Letter} Ch 1 Par Val, #line 11 "dhry_1.imp" extern int FUNC1( int CH1PARVAL, int CH2PARVAL ); // 12 %integer {Capital Letter} Ch 2 Par Val) // 13 %external %predicate %spec Func 2 (%string (30) %name Str 1 Par Ref, %string (30) %name Str 2 Par Ref) #line 13 "dhry_1.imp" extern int /*Boolean*/ FUNC2( _imp_string /*%string(30)*/ /*name*/*STR1PARREF, _imp_string /*%string(30)*/ /*name*/*STR2PARREF ); // 14 %external %predicate %spec Func 3 (%integer {Enumeration} Enum Par Val) #line 14 "dhry_1.imp" extern int /*Boolean*/ FUNC3( int ENUMPARVAL ); // 15 // 16 ! **************************************************************************** // 17 ! * // 18 ! * "DHRYSTONE" Benchmark Program // 19 ! * ----------------------------- // 20 ! * // 21 ! * Version: Imp, Version 2.1 // 22 ! * // 23 ! * File: dhry_1.c (part 2 of 3) // 24 ! * // 25 ! * Date: May 25, 1988 & Mar 30, 2026 // 26 ! * // 27 ! * Author: Reinhold P. Weicker, translated from C to Imp by Graham Toal // 28 ! * // 29 ! **************************************************************************** // 30 // 31 %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 // 100 ! changed, the numbers defining the "Dhrystone distribution" // 101 ! (distribution of statements, operand types and locality) // 102 ! still hold. Except for sophisticated optimizing compilers, // 103 ! execution times for this version should be the same as // 104 ! for previous versions. // 105 ! // 106 ! Since it has proven difficult to subtract the time for the // 107 ! measurement loop overhead in a correct way, the loop check // 108 ! has been made a part of the benchmark. This does have // 109 ! an impact - though a very minor one - on the distribution // 110 ! statistics which have been updated for this version. // 111 ! // 112 ! All changes within the measurement loop are described // 113 ! and discussed in the companion paper "Rationale for // 114 ! Dhrystone version 2". // 115 ! // 116 ! Because of the self-imposed limitation that the order and // 117 ! distribution of the executed statements should not be // 118 ! changed, there are still cases where optimizing compilers // 119 ! may not generate code for some statements. To a certain // 120 ! degree, this is unavoidable for small synthetic benchmarks. // 121 ! Users of the benchmark are advised to check code listings // 122 ! whether code is generated for all statements of Dhrystone. // 123 ! // 124 ! Version 2.1 is identical to version 2.0 distributed via // 125 ! the UNIX network Usenet in March 1988 except that it corrects // 126 ! some minor deficiencies that were found by users of version 2.0. // 127 ! The only change within the measurement loop is that a // 128 ! non-executed "else" part was added to the "if" statement in // 129 ! Func_3, and a non-executed "else" part removed from Proc_3. // 130 ! // 131 ! ************************************************************************** // 132 ! // 133 ! Defines: The following "Defines" are possible: // 134 ! -DREG=register (default: Not defined) // 135 ! As an approximation to what an average C programmer // 136 ! might do, the "register" storage class is applied // 137 ! (if enabled by -DREG=register) // 138 ! - for local variables, if they are used (dynamically) // 139 ! five or more times // 140 ! - for parameters if they are used (dynamically) // 141 ! six or more times // 142 ! Note that an optimal "register" strategy is // 143 ! compiler-dependent, and that "register" declarations // 144 ! do not necessarily lead to faster execution. // 145 ! -DNOSTRUCTASSIGN (default: Not defined) // 146 ! Define if the C compiler does not support // 147 ! assignment of structures. // 148 ! -DNOENUMS (default: Not defined) // 149 ! Define if the C compiler does not support // 150 ! enumeration types. // 151 ! -DTIMES (default) // 152 ! -DTIME // 153 ! The "times" function of UNIX (returning process times) // 154 ! or the "time" function (returning wallclock time) // 155 ! is used for measurement. // 156 ! For single user machines, "time ()" is adequate. For // 157 ! multi-user machines where you cannot get single-user // 158 ! access, use the "times ()" function. If you have // 159 ! neither, use a stopwatch in the dead of night. // 160 ! "printf"s are provided marking the points "Start Timer" // 161 ! and "Stop Timer". DO NOT use the UNIX "time(1)" // 162 ! command, as this will measure the total time to // 163 ! run this program, which will (erroneously) include // 164 ! the time to allocate storage (malloc) and to perform // 165 ! the initialization. // 166 ! -DHZ=nnn // 167 ! In Berkeley UNIX, the function "times" returns process // 168 ! time in 1/HZ seconds, with HZ = 60 for most systems. // 169 ! CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY // 170 ! A VALUE. // 171 ! // 172 ! ************************************************************************** // 173 ! // 174 ! Compilation model and measurement (IMPORTANT): // 175 ! // 176 ! This C version of Dhrystone consists of three files: // 177 ! - dhry.h (this file, containing global definitions and comments) // 178 ! - dhry_1.c (containing the code corresponding to Ada package Pack_1) // 179 ! - dhry_2.c (containing the code corresponding to Ada package Pack_2) // 180 ! // 181 ! The following "ground rules" apply for measurements: // 182 ! - Separate compilation // 183 ! - No procedure merging // 184 ! - Otherwise, compiler optimizations are allowed but should be indicated // 185 ! - Default results are those without register declarations // 186 ! See the companion paper "Rationale for Dhrystone Version 2" for a more // 187 ! detailed discussion of these ground rules. // 188 ! // 189 ! For 16-Bit processors (e.g. 80186, 80286), times for all compilation // 190 ! models ("small", "medium", "large" etc.) should be given if possible, // 191 ! together with a definition of these models for the compiler system used. // 192 ! // 193 ! ************************************************************************* // 194 ! // 195 ! Dhrystone (C version) statistics: // 196 ! // 197 ! [Comment from the first distribution, updated for version 2. // 198 ! Note that because of language differences, the numbers are slightly // 199 ! different from the Ada version.] // 200 ! // 201 ! The following program contains statements of a high level programming // 202 ! language (here: C) in a distribution considered representative: // 203 ! // 204 ! assignments 52 (51.0 %) // 205 ! control statements 33 (32.4 %) // 206 ! procedure, function calls 17 (16.7 %) // 207 ! // 208 ! 103 statements are dynamically executed. The program is balanced with // 209 ! respect to the three aspects: // 210 ! // 211 ! - statement type // 212 ! - operand type // 213 ! - operand locality // 214 ! operand global, local, parameter, or constant. // 215 ! // 216 ! The combination of these three aspects is balanced only approximately. // 217 ! // 218 ! 1. Statement Type: // 219 ! ----------------- number // 220 ! // 221 ! V1 = V2 9 // 222 ! (incl. V1 = F(..) // 223 ! V = Constant 12 // 224 ! Assignment, 7 // 225 ! with array element // 226 ! Assignment, 6 // 227 ! with record component // 228 ! -- // 229 ! 34 34 // 230 ! // 231 ! X = Y +|-|"&&"|"|" Z 5 // 232 ! X = Y +|-|"==" Constant 6 // 233 ! X = X +|- 1 3 // 234 ! X = Y *|/ Z 2 // 235 ! X = Expression, 1 // 236 ! two operators // 237 ! X = Expression, 1 // 238 ! three operators // 239 ! -- // 240 ! 18 18 // 241 ! // 242 ! if .... 14 // 243 ! with "else" 7 // 244 ! without "else" 7 // 245 ! executed 3 // 246 ! not executed 4 // 247 ! for ... 7 | counted every time // 248 ! while ... 4 | the loop condition // 249 ! do ... while 1 | is evaluated // 250 ! switch ... 1 // 251 ! break 1 // 252 ! declaration with 1 // 253 ! initialization // 254 ! -- // 255 ! 34 34 // 256 ! // 257 ! P (...) procedure call 11 // 258 ! user procedure 10 // 259 ! library procedure 1 // 260 ! X = F (...) // 261 ! function call 6 // 262 ! user function 5 // 263 ! library function 1 // 264 ! -- // 265 ! 17 17 // 266 ! --- // 267 ! 103 // 268 ! // 269 ! The average number of parameters in procedure or function calls // 270 ! is 1.82 (not counting the function values aX * // 271 ! // 272 ! 2. Operators // 273 ! ------------ // 274 ! number approximate // 275 ! percentage // 276 ! // 277 ! Arithmetic 32 50.8 // 278 ! // 279 ! + 21 33.3 // 280 ! - 7 11.1 // 281 ! * 3 4.8 // 282 ! / (int div) 1 1.6 // 283 ! // 284 ! Comparison 27 42.8 // 285 ! // 286 ! == 9 14.3 // 287 ! /= 4 6.3 // 288 ! > 1 1.6 // 289 ! < 3 4.8 // 290 ! >= 1 1.6 // 291 ! <= 9 14.3 // 292 ! // 293 ! Logic 4 6.3 // 294 ! // 295 ! && (AND-THEN) 1 1.6 // 296 ! | (OR) 1 1.6 // 297 ! ! (NOT) 2 3.2 // 298 ! // 299 ! -- ----- // 300 ! 63 100.1 // 301 ! // 302 ! // 303 ! 3. Operand Type (counted once per operand reference): // 304 ! --------------- // 305 ! number approximate // 306 ! percentage // 307 ! // 308 ! Integer 175 72.3 % // 309 ! Character 45 18.6 % // 310 ! Pointer 12 5.0 % // 311 ! String30 6 2.5 % // 312 ! Array 2 0.8 % // 313 ! Record 2 0.8 % // 314 ! --- ------- // 315 ! 242 100.0 % // 316 ! // 317 ! When there is an access path leading to the final operand (e.g. a record // 318 ! component), only the final data type on the access path is counted. // 319 ! // 320 ! // 321 ! 4. Operand Locality: // 322 ! ------------------- // 323 ! number approximate // 324 ! percentage // 325 ! // 326 ! local variable 114 47.1 % // 327 ! global variable 22 9.1 % // 328 ! parameter 45 18.6 % // 329 ! value 23 9.5 % // 330 ! reference 22 9.1 % // 331 ! function result 6 2.5 % // 332 ! constant 55 22.7 % // 333 ! --- ------- // 334 ! 242 100.0 % // 335 ! // 336 ! // 337 ! The program does not compute anything meaningful, but it is syntactically // 338 ! and semantically correct. All variables have a value assigned to them // 339 ! before they are used as a source operand. // 340 ! // 341 ! There has been no explicit effort to account for the effects of a // 342 ! cache, or to balance the use of long or short displacements for code or // 343 ! data. // 344 ! // 345 ! ************************************************************************** // 346 // 347 { Compiler and system dependent definitions: } // 348 // 349 { Use times(2) time function unless } // 350 { explicitly defined otherwise } // 351 // 352 { Use Microsoft C hi-res clock } // 353 // 354 %const %integer Mic secs Per Second = 1000000 { Berkeley UNIX C returns process times in seconds/HZ } // 355 // 356 !! If using gtcpp: // 357 !! $define structassign(d, s) d = s // 358 // 359 %const %integer Ident 1 = 0 // 360 %const %integer Ident 2 = 1 // 361 %const %integer Ident 3 = 2 // 362 %const %integer Ident 4 = 3 // 363 %const %integer Ident 5 = 4 // 364 ! typedef int Enumeration; // 365 // 366 { for boolean and enumeration types in Ada, Pascal } // 367 // 368 { General definitions: } // 369 // 370 { Value of a Null pointer } // 371 !!%external %record (*) %name %spec Null // 372 %const %integer true = 1 // 373 %const %integer false = 0 // 374 // 375 ! typedef int One Thirty; // 376 ! typedef int One Fifty; // 377 ! typedef char Capital Letter; // 378 ! typedef int Boolean; // 379 ! typedef char Str 30 [31]; // 380 ! typedef int Arr 1 Dim [50]; // 381 ! typedef int Arr 2 Dim [50] [50]; // 382 // 383 // 384 %recordformat var 1 fm (%integer {Enumeration} Enum Comp, %integer Int Comp, %string (30) Str Comp) #line 384 "dhry.inc" typedef struct VAR1FM VAR1FM; struct VAR1FM { int ENUMCOMP; int INTCOMP; _imp_string /*%string(30)*/ STRCOMP; }; // 385 %recordformat var 2 fm (%integer {Enumeration} E Comp 2, %string (30) Str 2 Comp) #line 385 "dhry.inc" typedef struct VAR2FM VAR2FM; struct VAR2FM { int ECOMP2; _imp_string /*%string(30)*/ STR2COMP; }; // 386 %recordformat var 3 fm (%byteinteger Ch 1 Comp, %byteinteger Ch 2 Comp) #line 386 "dhry.inc" typedef struct VAR3FM VAR3FM; struct VAR3FM { unsigned char CH1COMP; unsigned char CH2COMP; }; // 387 %recordformat variant fm (%record (var 1 fm) var 1 %or %record (var 2 fm) var 2 %or %record (var 3 fm) var 3) #line 387 "dhry.inc" typedef struct VARIANTFM VARIANTFM; struct VARIANTFM { VAR1FM VAR1; VAR2FM VAR2; VAR3FM VAR3; }; // 388 %recordformat Rec Type fm (%record (Rec Type fm) %name Ptr Comp, #line 388 "dhry.inc" typedef struct RECTYPEFM RECTYPEFM; struct RECTYPEFM { RECTYPEFM /*name*/*PTRCOMP; int DISCR; VARIANTFM VARIANT; }; // 389 %integer {Enumeration} Discr, // 390 %record (variant fm) variant) // 391 // 392 %external %record (Rec Type fm) %spec Rec Type #line 392 "dhry.inc" extern RECTYPEFM RECTYPE; // 393 %external %record (Rec Type fm) %name %spec Rec Pointer; #line 393 "dhry.inc" extern RECTYPEFM /*name*/*RECPOINTER; // 394 // 395 %endoffile // 32 // 33 %const %integer DHRY ITERS = 100000 // 34 // 35 { Global Variables: } // 36 // 37 %external %record (Rec Type fm) %name Ptr Glob, #line 37 "dhry_1.imp" RECTYPEFM /*name*/*PTRGLOB; #line 37 "dhry_1.imp" RECTYPEFM /*name*/*NEXTPTRGLOB; // 38 Next Ptr Glob // 39 %external %integer Int Glob #line 39 "dhry_1.imp" int INTGLOB; // 40 %external %integer {Boolean} Bool Glob #line 40 "dhry_1.imp" int BOOLGLOB; // 41 %external %byte %integer Ch 1 Glob, #line 41 "dhry_1.imp" unsigned char CH1GLOB; #line 41 "dhry_1.imp" unsigned char CH2GLOB; // 42 Ch 2 Glob // 43 %external %integer %array Arr 1 Glob (0:49) #line 43 "dhry_1.imp" int ARR1GLOB[50]; // 44 // 45 !!! PROBLEM! Imp77 doesn't allow N-D external arrays, only local ones! // 46 %external %integer %array Arr 2 Glob (0:50*50-1) {(0:49, 0:49)} #line 46 "dhry_1.imp" int ARR2GLOB[2500]; // 47 // 48 !extern char *malloc () // 49 !!%external %integer {Enumeration} %fn %spec Func 1 // 50 { forward declaration necessary since Enumeration may not simply be int } // 51 // 52 !#ifndef REG // 53 %external %integer {Boolean} Reg = false #line 53 "dhry_1.imp" int REG = 0; // 54 !#define REG // 55 { REG becomes defined as empty } // 56 { i.e. no register variables } // 57 !#else // 58 ! %integer {Boolean} Reg = true // 59 !#endif // 60 // 61 { variables for time measurement: } // 62 // 63 !#ifdef TIMES // 64 !struct tms time info // 65 !extern int times () // 66 ! { see library function "times" } // 67 !#define Too Small Time (2*HZ) // 68 ! { Measurements should last at least about 2 seconds } // 69 !#endif // 70 !#ifdef TIME // 71 !extern long time() // 72 ! { see library function "time" } // 73 !#define Too Small Time 2 // 74 ! { Measurements should last at least 2 seconds } // 75 !#endif // 76 !#ifdef MSC CLOCK // 77 !extern clock t clock() // 78 !#define Too Small Time (2*HZ) // 79 !#endif // 80 // 81 %const %integer Too Small Time = 2 * 1000000 {must run at least 2 seconds} // 82 // 83 %external {%long} %integer Begin Time, %c #line 83 "dhry_1.imp" int BEGINTIME; #line 83 "dhry_1.imp" int ENDTIME; #line 83 "dhry_1.imp" int USERTIME; // 84 End Time, %c // 85 User Time // 86 // 87 %external %real Microseconds, %c #line 87 "dhry_1.imp" float MICROSECONDS; #line 87 "dhry_1.imp" float DHRYSTONESPERSECOND; // 88 Dhrystones Per Second // 89 // 90 { end of variables for time measurement } // 91 // 92 // 93 %begin #line 93 "dhry_1.imp" int main(int argc, char **argv) { _imp_initialise(argc, argv); // 94 {***} // 95 %routinespec Proc 1 (%record (Rec Type fm) %name Ptr Val Par) #line 95 "dhry_1.imp" auto void PROC1( RECTYPEFM /*name*/*PTRVALPAR ); // 96 %routinespec Proc 2 (%integer {One Fifty} %name Int Par Ref) #line 96 "dhry_1.imp" auto void PROC2( int /*name*/*INTPARREF ); // 97 %routinespec Proc 3 (%record (Rec Type fm) %name Ptr Ref Par) #line 97 "dhry_1.imp" auto void PROC3( RECTYPEFM /*name*/*PTRREFPAR ); // 98 %routinespec Proc 4 #line 98 "dhry_1.imp" auto void PROC4( void ); // 99 %routinespec Proc 5 #line 99 "dhry_1.imp" auto void PROC5( void ); // 100 // 101 { main program, corresponds to procedures } // 102 { Main and Proc 0 in the Ada version } // 103 // 104 %integer {One Fifty} Int 1 Loc #line 104 "dhry_1.imp" int INT1LOC; // 105 %integer {One Fifty} Int 2 Loc #line 105 "dhry_1.imp" int INT2LOC; // 106 %integer {One Fifty} Int 3 Loc #line 106 "dhry_1.imp" int INT3LOC; // 107 %byte %integer Ch Index #line 107 "dhry_1.imp" unsigned char CHINDEX; // 108 %integer {Enumeration} Enum Loc #line 108 "dhry_1.imp" int ENUMLOC; // 109 %string (30) Str 1 Loc #line 109 "dhry_1.imp" _imp_string /*%string(30)*/ STR1LOC; // 110 %string (30) Str 2 Loc #line 110 "dhry_1.imp" _imp_string /*%string(30)*/ STR2LOC; // 111 %integer Run Index #line 111 "dhry_1.imp" int RUNINDEX; // 112 %integer Number Of Runs #line 112 "dhry_1.imp" int NUMBEROFRUNS; // 113 // 114 { Initializations } // 115 // 116 %record (Rec Type fm) Next Ptr Glob #line 116 "dhry_1.imp" RECTYPEFM NEXTPTRGLOB; // 117 %record (Rec Type fm) Ptr Glob {= (Rec Pointer) malloc (sizeof (Rec Type))} #line 117 "dhry_1.imp" RECTYPEFM PTRGLOB; // 118 // 119 Ptr Glob_Ptr Comp == Next Ptr Glob #line 119 "dhry_1.imp" PTRGLOB.PTRCOMP = &NEXTPTRGLOB; // 120 Ptr Glob_Discr = Ident 1 #line 120 "dhry_1.imp" PTRGLOB.DISCR = 0; // 121 Ptr Glob_variant_var 1_Enum Comp = Ident 3 #line 121 "dhry_1.imp" PTRGLOB.VARIANT.VAR1.ENUMCOMP = 2; // 122 Ptr Glob_variant_var 1_Int Comp = 40 #line 122 "dhry_1.imp" PTRGLOB.VARIANT.VAR1.INTCOMP = 40; // 123 Ptr Glob_variant_var 1_Str Comp = "DHRYSTONE PROGRAM, SOME STRING" #line 123 "dhry_1.imp" PTRGLOB.VARIANT.VAR1.STRCOMP = _imp_str_literal("DHRYSTONE PROGRAM, SOME STRING"); // 124 Str 1 Loc = "DHRYSTONE PROGRAM, 1'ST STRING" #line 124 "dhry_1.imp" STR1LOC = _imp_str_literal("DHRYSTONE PROGRAM, 1'ST STRING"); // 125 // 126 Arr 2 Glob (8*50+7){(8,7)} = 10 #line 126 "dhry_1.imp" ARR2GLOB[(((int)((((int)(8)) * (50)))) + (7))] = 10; // 127 { Was missing in published program. Without this statement, } // 128 { Arr 2 Glob [8][7] would have an undefined value. } // 129 { Warning: With 16-Bit processors and Number Of Runs > 32000, } // 130 { overflow may occur for this array element. } // 131 // 132 newline #line 132 "dhry_1.imp" _imp_NEWLINE(); // 133 printstring ("Dhrystone Benchmark, Version 2.1 (Language: Imp)") #line 133 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Dhrystone Benchmark, Version 2.1 (Language: Imp)")); // 134 newlines(2) #line 134 "dhry_1.imp" _imp_NEWLINES(2); // 135 // 136 %if Reg # 0 %start #line 136 "dhry_1.imp" if (((REG) == (0))) goto L_0002; // 137 printstring ("Program compiled with 'register' attribute") #line 137 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Program compiled with 'register' attribute")); // 138 newlines(2) #line 138 "dhry_1.imp" _imp_NEWLINES(2); // 139 %else #line 139 "dhry_1.imp" goto L_0003; #line 139 "dhry_1.imp" L_0002:; // 140 printstring ("Program compiled without 'register' attribute") #line 140 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Program compiled without 'register' attribute")); // 141 newlines(2) #line 141 "dhry_1.imp" _imp_NEWLINES(2); // 142 %finish #line 142 "dhry_1.imp" L_0003:; // 143 // 144 Number Of Runs = DHRY ITERS #line 144 "dhry_1.imp" NUMBEROFRUNS = 100000; // 145 // 146 ! printstring ("Please give the number of runs through the benchmark: ") // 147 ! %begin // 148 ! %integer n // 149 ! read(n) // 150 ! Number Of Runs = n // 151 ! %end // 152 ! newline // 153 // 154 printstring ("Execution starts, ") #line 154 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Execution starts, ")); // 155 write(Number Of Runs, -1) #line 155 "dhry_1.imp" _imp_WRITE(NUMBEROFRUNS, (-1)); // 156 printstring (" runs through Dhrystone") #line 156 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" runs through Dhrystone")); // 157 newline #line 157 "dhry_1.imp" _imp_NEWLINE(); // 158 // 159 {*************} // 160 { Start timer } // 161 {*************} // 162 // 163 !#ifdef TIMES // 164 ! times (&time info) // 165 ! Begin Time = (long) time info.tms utime // 166 !#endif // 167 !#ifdef TIME // 168 ! Begin Time = time ( (long *) 0) // 169 !#endif // 170 !#ifdef MSC CLOCK // 171 ! Begin Time = clock() // 172 !#endif // 173 // 174 Begin Time = cpu time #line 174 "dhry_1.imp" BEGINTIME = _imp_CPUTIME(); // 175 // 176 %for Run Index = 1, 1, Number Of Runs %cycle #line 176 "dhry_1.imp" {static int _initial, _increment, _final, _control; _initial = 1; _increment = 1; _final = NUMBEROFRUNS; RUNINDEX = _control = _initial; if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle RUNINDEX = 1, 1, NUMBEROFRUNS"); RUNINDEX -= _increment; _control -= _increment; L_0004:; if (RUNINDEX == _final) goto L_0005; RUNINDEX += _increment; _control += _increment; if (RUNINDEX != _control) _imp_signal(4,2,0,"Corrupt control variable RUNINDEX"); /* FOR loop control variable corrupted */ } // 177 // 178 Proc 5 #line 178 "dhry_1.imp" PROC5(); // 179 Proc 4 #line 179 "dhry_1.imp" PROC4(); // 180 { Ch 1 Glob == 'A', Ch 2 Glob == 'B', Bool Glob == true } // 181 Int 1 Loc = 2 #line 181 "dhry_1.imp" INT1LOC = 2; // 182 Int 2 Loc = 3 #line 182 "dhry_1.imp" INT2LOC = 3; // 183 Str 2 Loc = "DHRYSTONE PROGRAM, 2'ND STRING" #line 183 "dhry_1.imp" STR2LOC = _imp_str_literal("DHRYSTONE PROGRAM, 2'ND STRING"); // 184 Enum Loc = Ident 2 #line 184 "dhry_1.imp" ENUMLOC = 1; // 185 %if %not Func 2 (Str 1 Loc, Str 2 Loc) %then Bool Glob = false %else Bool Glob = true #line 185 "dhry_1.imp" if (FUNC2(&STR1LOC, &STR2LOC)) goto L_0007; #line 185 "dhry_1.imp" BOOLGLOB = 0; #line 185 "dhry_1.imp" goto L_0008; #line 185 "dhry_1.imp" L_0007:; #line 185 "dhry_1.imp" BOOLGLOB = 1; #line 185 "dhry_1.imp" L_0008:; // 186 { Bool Glob == 1 } // 187 %while Int 1 Loc < Int 2 Loc %cycle { loop body executed once } #line 187 "dhry_1.imp" L_0009:; #line 187 "dhry_1.imp" if (((INT1LOC) >= (INT2LOC))) goto L_000a; // 188 Int 3 Loc = 5 * Int 1 Loc - Int 2 Loc #line 188 "dhry_1.imp" INT3LOC = (((int)((((int)(5)) * (INT1LOC)))) - (INT2LOC)); // 189 { Int 3 Loc == 7 } // 190 Proc 7 (Int 1 Loc, Int 2 Loc, Int 3 Loc) #line 190 "dhry_1.imp" PROC7(INT1LOC, INT2LOC, &INT3LOC); // 191 { Int 3 Loc == 7 } // 192 Int 1 Loc = Int 1 Loc + 1 #line 192 "dhry_1.imp" INT1LOC = (((int)(INT1LOC)) + (1)); // 193 %repeat { while } #line 193 "dhry_1.imp" goto L_0009; #line 193 "dhry_1.imp" L_000a:; // 194 { Int 1 Loc == 3, Int 2 Loc == 3, Int 3 Loc == 7 } // 195 Proc 8 (Arr 1 Glob, Arr 2 Glob, Int 1 Loc, Int 3 Loc) #line 195 "dhry_1.imp" PROC8(&ARR1GLOB[0], &ARR2GLOB[0], INT1LOC, INT3LOC); // 196 { Int Glob == 5 } // 197 Proc 1 (Ptr Glob) #line 197 "dhry_1.imp" PROC1(&PTRGLOB); // 198 %for Ch Index = 'A', 1, Ch 2 Glob %cycle #line 198 "dhry_1.imp" {static int _initial, _increment, _final, _control; _initial = 65; _increment = 1; _final = CH2GLOB; CHINDEX = _control = _initial; if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle CHINDEX = 65, 1, CH2GLOB"); CHINDEX -= _increment; _control -= _increment; L_000c:; if (CHINDEX == _final) goto L_000d; CHINDEX += _increment; _control += _increment; if (CHINDEX != _control) _imp_signal(4,2,0,"Corrupt control variable CHINDEX"); /* FOR loop control variable corrupted */ } // 199 { loop body executed twice } // 200 %if Enum Loc = Func 1 (Ch Index, 'C') %start #line 200 "dhry_1.imp" if (((ENUMLOC) != (FUNC1(CHINDEX, 67)))) goto L_000f; // 201 { then, not executed } // 202 Proc 6 (Ident 1, Enum Loc) #line 202 "dhry_1.imp" PROC6(0, &ENUMLOC); // 203 Str 2 Loc = "DHRYSTONE PROGRAM, 3'RD STRING" #line 203 "dhry_1.imp" STR2LOC = _imp_str_literal("DHRYSTONE PROGRAM, 3'RD STRING"); // 204 Int 2 Loc = Run Index #line 204 "dhry_1.imp" INT2LOC = RUNINDEX; // 205 Int Glob = Run Index #line 205 "dhry_1.imp" INTGLOB = RUNINDEX; // 206 %finish #line 206 "dhry_1.imp" L_000f:; // 207 %repeat #line 207 "dhry_1.imp" goto L_000c; #line 207 "dhry_1.imp" L_000d:; // 208 { Int 1 Loc == 3, Int 2 Loc == 3, Int 3 Loc == 7 } // 209 Int 2 Loc = Int 2 Loc * Int 1 Loc #line 209 "dhry_1.imp" INT2LOC = (((int)(INT2LOC)) * (INT1LOC)); // 210 Int 1 Loc = Int 2 Loc // Int 3 Loc #line 210 "dhry_1.imp" INT1LOC = (long)((long)((int)(INT2LOC)) / (long)((int)(_Z(INT3LOC)))); // 211 Int 2 Loc = 7 * (Int 2 Loc - Int 3 Loc) - Int 1 Loc #line 211 "dhry_1.imp" INT2LOC = (((int)(((7) * ((int)((((int)(INT2LOC)) - (INT3LOC))))))) - (INT1LOC)); // 212 { Int 1 Loc == 1, Int 2 Loc == 13, Int 3 Loc == 7 } // 213 Proc 2 (Int 1 Loc) #line 213 "dhry_1.imp" PROC2(&INT1LOC); // 214 { Int 1 Loc == 5 } // 215 // 216 %repeat { loop "for Run Index" } #line 216 "dhry_1.imp" goto L_0004; #line 216 "dhry_1.imp" L_0005:; // 217 // 218 {************} // 219 { Stop timer } // 220 {************} // 221 // 222 !#ifdef TIMES // 223 ! times (&time info) // 224 ! End Time = (long) time info.tms utime // 225 !#endif // 226 !#ifdef TIME // 227 ! End Time = time ( (long *) 0) // 228 !#endif // 229 !#ifdef MSC CLOCK // 230 ! End Time = clock() // 231 !#endif // 232 // 233 End Time = cpu time #line 233 "dhry_1.imp" ENDTIME = _imp_CPUTIME(); // 234 // 235 printstring ("Execution ends"); newline #line 235 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Execution ends")); #line 235 "dhry_1.imp" _imp_NEWLINE(); // 236 printstring (""); newline #line 236 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("")); #line 236 "dhry_1.imp" _imp_NEWLINE(); // 237 printstring ("Final values of the variables used in the benchmark:"); newline #line 237 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Final values of the variables used in the benchmark:")); #line 237 "dhry_1.imp" _imp_NEWLINE(); // 238 printstring (""); newline #line 238 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("")); #line 238 "dhry_1.imp" _imp_NEWLINE(); // 239 printstring ("Int_Glob: "); write( Int Glob, -1); newline #line 239 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Int_Glob: ")); #line 239 "dhry_1.imp" _imp_WRITE(INTGLOB, (-1)); #line 239 "dhry_1.imp" _imp_NEWLINE(); // 240 printstring (" should be: "); write( 5, -1); newline #line 240 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 240 "dhry_1.imp" _imp_WRITE(5, (-1)); #line 240 "dhry_1.imp" _imp_NEWLINE(); // 241 printstring ("Bool_Glob: "); write( Bool Glob, -1); newline #line 241 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Bool_Glob: ")); #line 241 "dhry_1.imp" _imp_WRITE(BOOLGLOB, (-1)); #line 241 "dhry_1.imp" _imp_NEWLINE(); // 242 printstring (" should be: "); write( 1, -1); newline #line 242 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 242 "dhry_1.imp" _imp_WRITE(1, (-1)); #line 242 "dhry_1.imp" _imp_NEWLINE(); // 243 printstring ("Ch_1_Glob: "); print symbol(Ch 1 Glob); newline #line 243 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Ch_1_Glob: ")); #line 243 "dhry_1.imp" _imp_PRINTSYMBOL(CH1GLOB); #line 243 "dhry_1.imp" _imp_NEWLINE(); // 244 printstring (" should be: "); print symbol('A'); newline #line 244 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 244 "dhry_1.imp" _imp_PRINTSYMBOL(65); #line 244 "dhry_1.imp" _imp_NEWLINE(); // 245 printstring ("Ch_2_Glob: "); print symbol(Ch 2 Glob); newline #line 245 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Ch_2_Glob: ")); #line 245 "dhry_1.imp" _imp_PRINTSYMBOL(CH2GLOB); #line 245 "dhry_1.imp" _imp_NEWLINE(); // 246 printstring (" should be: "); print symbol('B'); newline #line 246 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 246 "dhry_1.imp" _imp_PRINTSYMBOL(66); #line 246 "dhry_1.imp" _imp_NEWLINE(); // 247 printstring ("Arr_1_Glob[8]: "); write( Arr 1 Glob(8), -1); newline #line 247 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Arr_1_Glob[8]: ")); #line 247 "dhry_1.imp" _imp_WRITE(ARR1GLOB[8], (-1)); #line 247 "dhry_1.imp" _imp_NEWLINE(); // 248 printstring (" should be: "); write( 7, -1); newline #line 248 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 248 "dhry_1.imp" _imp_WRITE(7, (-1)); #line 248 "dhry_1.imp" _imp_NEWLINE(); // 249 printstring ("Arr_2_Glob[8][7]: "); write( Arr 2 Glob(8*50+7){(8,7)}, -1); newline #line 249 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Arr_2_Glob[8][7]: ")); #line 249 "dhry_1.imp" _imp_WRITE(ARR2GLOB[(((int)((((int)(8)) * (50)))) + (7))], (-1)); #line 249 "dhry_1.imp" _imp_NEWLINE(); // 250 printstring (" should be: Number_Of_Runs + 10"); newline #line 250 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: Number_Of_Runs + 10")); #line 250 "dhry_1.imp" _imp_NEWLINE(); // 251 printstring ("Ptr_Glob->"); newline #line 251 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Ptr_Glob->")); #line 251 "dhry_1.imp" _imp_NEWLINE(); // 252 printstring (" Ptr_Comp: "); write(ADDR(Ptr Glob_Ptr Comp), -1); newline #line 252 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" Ptr_Comp: ")); #line 252 "dhry_1.imp" _imp_WRITE(_imp_ADDR(PTRGLOB.PTRCOMP), (-1)); #line 252 "dhry_1.imp" _imp_NEWLINE(); // 253 printstring (" should be: (implementation-dependent)"); newline #line 253 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: (implementation-dependent)")); #line 253 "dhry_1.imp" _imp_NEWLINE(); // 254 printstring (" Discr: "); write( Ptr Glob_Discr, -1); newline #line 254 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" Discr: ")); #line 254 "dhry_1.imp" _imp_WRITE(PTRGLOB.DISCR, (-1)); #line 254 "dhry_1.imp" _imp_NEWLINE(); // 255 printstring (" should be: "); write( 0, -1); newline #line 255 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 255 "dhry_1.imp" _imp_WRITE(0, (-1)); #line 255 "dhry_1.imp" _imp_NEWLINE(); // 256 printstring (" Enum_Comp: "); write( Ptr Glob_variant_var 1_Enum Comp, -1); newline #line 256 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" Enum_Comp: ")); #line 256 "dhry_1.imp" _imp_WRITE(PTRGLOB.VARIANT.VAR1.ENUMCOMP, (-1)); #line 256 "dhry_1.imp" _imp_NEWLINE(); // 257 printstring (" should be: "); write( 2, -1); newline #line 257 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 257 "dhry_1.imp" _imp_WRITE(2, (-1)); #line 257 "dhry_1.imp" _imp_NEWLINE(); // 258 printstring (" Int_Comp: "); write( Ptr Glob_variant_var 1_Int Comp, -1); newline #line 258 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" Int_Comp: ")); #line 258 "dhry_1.imp" _imp_WRITE(PTRGLOB.VARIANT.VAR1.INTCOMP, (-1)); #line 258 "dhry_1.imp" _imp_NEWLINE(); // 259 printstring (" should be: "); write( 17, -1); newline #line 259 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 259 "dhry_1.imp" _imp_WRITE(17, (-1)); #line 259 "dhry_1.imp" _imp_NEWLINE(); // 260 printstring (" Str_Comp: "); print string(Ptr Glob_variant_var 1_Str Comp); newline #line 260 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" Str_Comp: ")); #line 260 "dhry_1.imp" _imp_PRINTSTRING(PTRGLOB.VARIANT.VAR1.STRCOMP); #line 260 "dhry_1.imp" _imp_NEWLINE(); // 261 printstring (" should be: DHRYSTONE PROGRAM, SOME STRING"); newline #line 261 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: DHRYSTONE PROGRAM, SOME STRING")); #line 261 "dhry_1.imp" _imp_NEWLINE(); // 262 printstring ("Next_Ptr_Glob->"); newline #line 262 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Next_Ptr_Glob->")); #line 262 "dhry_1.imp" _imp_NEWLINE(); // 263 printstring (" Ptr_Comp: "); write(ADDR(Next Ptr Glob_Ptr Comp), -1); newline #line 263 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" Ptr_Comp: ")); #line 263 "dhry_1.imp" _imp_WRITE(_imp_ADDR(NEXTPTRGLOB.PTRCOMP), (-1)); #line 263 "dhry_1.imp" _imp_NEWLINE(); // 264 printstring (" should be: (implementation-dependent), same as above"); newline #line 264 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: (implementation-dependent), same as above")); #line 264 "dhry_1.imp" _imp_NEWLINE(); // 265 printstring (" Discr: "); write( Next Ptr Glob_Discr, -1); newline #line 265 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" Discr: ")); #line 265 "dhry_1.imp" _imp_WRITE(NEXTPTRGLOB.DISCR, (-1)); #line 265 "dhry_1.imp" _imp_NEWLINE(); // 266 printstring (" should be: "); write( 0, -1); newline #line 266 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 266 "dhry_1.imp" _imp_WRITE(0, (-1)); #line 266 "dhry_1.imp" _imp_NEWLINE(); // 267 printstring (" Enum_Comp: "); write( Next Ptr Glob_variant_var 1_Enum Comp, -1); newline #line 267 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" Enum_Comp: ")); #line 267 "dhry_1.imp" _imp_WRITE(NEXTPTRGLOB.VARIANT.VAR1.ENUMCOMP, (-1)); #line 267 "dhry_1.imp" _imp_NEWLINE(); // 268 printstring (" should be: "); write( 1, -1); newline #line 268 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 268 "dhry_1.imp" _imp_WRITE(1, (-1)); #line 268 "dhry_1.imp" _imp_NEWLINE(); // 269 printstring (" Int_Comp: "); write( Next Ptr Glob_variant_var 1_Int Comp, -1); newline #line 269 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" Int_Comp: ")); #line 269 "dhry_1.imp" _imp_WRITE(NEXTPTRGLOB.VARIANT.VAR1.INTCOMP, (-1)); #line 269 "dhry_1.imp" _imp_NEWLINE(); // 270 printstring (" should be: "); write( 18, -1); newline #line 270 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 270 "dhry_1.imp" _imp_WRITE(18, (-1)); #line 270 "dhry_1.imp" _imp_NEWLINE(); // 271 printstring (" Str_Comp: "); print string(Next Ptr Glob_variant_var 1_Str Comp); newline #line 271 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" Str_Comp: ")); #line 271 "dhry_1.imp" _imp_PRINTSTRING(NEXTPTRGLOB.VARIANT.VAR1.STRCOMP); #line 271 "dhry_1.imp" _imp_NEWLINE(); // 272 printstring (" should be: DHRYSTONE PROGRAM, SOME STRING"); newline #line 272 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: DHRYSTONE PROGRAM, SOME STRING")); #line 272 "dhry_1.imp" _imp_NEWLINE(); // 273 printstring ("Int_1_Loc: "); write( Int 1 Loc, -1); newline #line 273 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Int_1_Loc: ")); #line 273 "dhry_1.imp" _imp_WRITE(INT1LOC, (-1)); #line 273 "dhry_1.imp" _imp_NEWLINE(); // 274 printstring (" should be: "); write( 5, -1); newline #line 274 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 274 "dhry_1.imp" _imp_WRITE(5, (-1)); #line 274 "dhry_1.imp" _imp_NEWLINE(); // 275 printstring ("Int_2_Loc: "); write( Int 2 Loc, -1); newline #line 275 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Int_2_Loc: ")); #line 275 "dhry_1.imp" _imp_WRITE(INT2LOC, (-1)); #line 275 "dhry_1.imp" _imp_NEWLINE(); // 276 printstring (" should be: "); write( 13, -1); newline #line 276 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 276 "dhry_1.imp" _imp_WRITE(13, (-1)); #line 276 "dhry_1.imp" _imp_NEWLINE(); // 277 printstring ("Int_3_Loc: "); write( Int 3 Loc, -1); newline #line 277 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Int_3_Loc: ")); #line 277 "dhry_1.imp" _imp_WRITE(INT3LOC, (-1)); #line 277 "dhry_1.imp" _imp_NEWLINE(); // 278 printstring (" should be: "); write( 7, -1); newline #line 278 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 278 "dhry_1.imp" _imp_WRITE(7, (-1)); #line 278 "dhry_1.imp" _imp_NEWLINE(); // 279 printstring ("Enum_Loc: "); write( Enum Loc, -1); newline #line 279 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Enum_Loc: ")); #line 279 "dhry_1.imp" _imp_WRITE(ENUMLOC, (-1)); #line 279 "dhry_1.imp" _imp_NEWLINE(); // 280 printstring (" should be: "); write( 1, -1); newline #line 280 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: ")); #line 280 "dhry_1.imp" _imp_WRITE(1, (-1)); #line 280 "dhry_1.imp" _imp_NEWLINE(); // 281 printstring ("Str_1_Loc: "); print string(Str 1 Loc); newline #line 281 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Str_1_Loc: ")); #line 281 "dhry_1.imp" _imp_PRINTSTRING(STR1LOC); #line 281 "dhry_1.imp" _imp_NEWLINE(); // 282 printstring (" should be: DHRYSTONE PROGRAM, 1'ST STRING"); newline #line 282 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: DHRYSTONE PROGRAM, 1'ST STRING")); #line 282 "dhry_1.imp" _imp_NEWLINE(); // 283 printstring ("Str_2_Loc: "); print string(Str 2 Loc); newline #line 283 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Str_2_Loc: ")); #line 283 "dhry_1.imp" _imp_PRINTSTRING(STR2LOC); #line 283 "dhry_1.imp" _imp_NEWLINE(); // 284 printstring (" should be: DHRYSTONE PROGRAM, 2'ND STRING"); newline #line 284 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal(" should be: DHRYSTONE PROGRAM, 2'ND STRING")); #line 284 "dhry_1.imp" _imp_NEWLINE(); // 285 newline #line 285 "dhry_1.imp" _imp_NEWLINE(); // 286 // 287 User Time = End Time - Begin Time #line 287 "dhry_1.imp" USERTIME = (((int)(ENDTIME)) - (BEGINTIME)); // 288 // 289 !! %if User Time < Too Small Time %start // 290 !! printf ("Measured time too small to obtain meaningful results"); newline // 291 !! printf ("Please increase number of runs"); newline // 292 !! newline // 293 !! %else // 294 !#ifdef TIME // 295 ! Microseconds = (float) User Time * Mic secs Per Second // 296 ! / (float) Number Of Runs // 297 ! Dhrystones Per Second = (float) Number Of Runs / (float) User Time // 298 !#else // 299 ! Microseconds = (float) User Time * Mic secs Per Second // 300 ! / ((float) HZ * ((float) Number Of Runs)) // 301 ! Dhrystones Per Second = ((float) HZ * (float) Number Of Runs) // 302 ! / (float) User Time // 303 !#endif // 304 // 305 Microseconds = User Time / Number Of Runs {CPU TIME function has been adjusted to return microseconds!} #line 305 "dhry_1.imp" MICROSECONDS = (double)((double)((float)(USERTIME)) / (double)((float)(NUMBEROFRUNS))); /*promote*/ // 306 Dhrystones Per Second = (Number Of Runs * 1000000.0) / User Time {need to scale down by 1000 to fit in 32-bit %integer} #line 306 "dhry_1.imp" DHRYSTONESPERSECOND = (double)((double)(((((double)(NUMBEROFRUNS)) * (1000000.0)))) / (double)((float)(USERTIME))); // 307 // 308 printstring ("Microseconds for one run through Dhrystone: ") #line 308 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Microseconds for one run through Dhrystone: ")); // 309 !write(INT(Microseconds), -1); space; newline // 310 print fl(Microseconds, 6); space; newline #line 310 "dhry_1.imp" _imp_PRINTFL(MICROSECONDS, 6); #line 310 "dhry_1.imp" _imp_SPACE(); #line 310 "dhry_1.imp" _imp_NEWLINE(); // 311 printstring ("Dhrystones per Second: ") #line 311 "dhry_1.imp" _imp_PRINTSTRING(_imp_str_literal("Dhrystones per Second: ")); // 312 write(INT(Dhrystones Per Second), -1); space; newline #line 312 "dhry_1.imp" _imp_WRITE(_imp_INT(DHRYSTONESPERSECOND), (-1)); #line 312 "dhry_1.imp" _imp_SPACE(); #line 312 "dhry_1.imp" _imp_NEWLINE(); // 313 newline #line 313 "dhry_1.imp" _imp_NEWLINE(); // 314 !! %finish // 315 // 316 !%end // 317 // 318 // 319 %routine Proc 1 (%record (Rec Type fm) %name Ptr Val Par) #line 319 "dhry_1.imp" void PROC1( RECTYPEFM /*name*/*PTRVALPAR ) #line 319 "dhry_1.imp" { // 320 {****************} // 321 { executed once } // 322 %record (Rec Type fm) %name Next Record == Ptr Val Par_Ptr Comp {or '='???} #line 322 "dhry_1.imp" RECTYPEFM /*name*/*NEXTRECORD; #line 322 "dhry_1.imp" NEXTRECORD = PTRVALPAR->PTRCOMP; // 323 { == Ptr Glob Next } // 324 { Local variable, initialized with Ptr Val Par->Ptr Comp, } // 325 { corresponds to "rename" in Ada, "with" in Pascal } // 326 // 327 {structassign} Ptr Val Par_Ptr Comp = Ptr Glob #line 327 "dhry_1.imp" *PTRVALPAR->PTRCOMP = PTRGLOB; // 328 Ptr Val Par_variant_var 1_Int Comp = 5 #line 328 "dhry_1.imp" PTRVALPAR->VARIANT.VAR1.INTCOMP = 5; // 329 Next Record_variant_var 1_Int Comp = Ptr Val Par_variant_var 1_Int Comp #line 329 "dhry_1.imp" NEXTRECORD->VARIANT.VAR1.INTCOMP = PTRVALPAR->VARIANT.VAR1.INTCOMP; // 330 Next Record_Ptr Comp = Ptr Val Par_Ptr Comp #line 330 "dhry_1.imp" *NEXTRECORD->PTRCOMP = *PTRVALPAR->PTRCOMP; // 331 Proc 3 (Next Record_Ptr Comp) #line 331 "dhry_1.imp" PROC3(NEXTRECORD->PTRCOMP); // 332 { Ptr Val Par_Ptr Comp_Ptr Comp = Ptr Glob_Ptr Comp } // 333 %if Next Record_Discr = Ident 1 %start #line 333 "dhry_1.imp" if (((NEXTRECORD->DISCR) != (0))) goto L_0010; // 334 { then, executed } // 335 Next Record_variant_var 1_Int Comp = 6 #line 335 "dhry_1.imp" NEXTRECORD->VARIANT.VAR1.INTCOMP = 6; // 336 Proc 6 (Ptr Val Par_variant_var 1_Enum Comp, Next Record_variant_var 1_Enum Comp) #line 336 "dhry_1.imp" PROC6(PTRVALPAR->VARIANT.VAR1.ENUMCOMP, &NEXTRECORD->VARIANT.VAR1.ENUMCOMP); // 337 Next Record_Ptr Comp = Ptr Glob_Ptr Comp #line 337 "dhry_1.imp" *NEXTRECORD->PTRCOMP = *PTRGLOB.PTRCOMP; // 338 Proc 7 (Next Record_variant_var 1_Int Comp, 10, Next Record_variant_var 1_Int Comp) #line 338 "dhry_1.imp" PROC7(NEXTRECORD->VARIANT.VAR1.INTCOMP, 10, &NEXTRECORD->VARIANT.VAR1.INTCOMP); // 339 %else { not executed } #line 339 "dhry_1.imp" goto L_0011; #line 339 "dhry_1.imp" L_0010:; // 340 {structassign} Ptr Val Par = Ptr Val Par_Ptr Comp #line 340 "dhry_1.imp" *PTRVALPAR = *PTRVALPAR->PTRCOMP; // 341 %finish #line 341 "dhry_1.imp" L_0011:; // 342 %end { Proc 1 } #line 342 "dhry_1.imp" /* Remove %on %event handler here if present for this block */ return; } // End of block PROC1 at level 2 // 343 // 344 // 345 %routine Proc 2 (%integer {One Fifty} %name Int Par Ref) #line 345 "dhry_1.imp" void PROC2( int /*name*/*INTPARREF ) #line 345 "dhry_1.imp" { // 346 {****************} // 347 { executed once } // 348 { *Int Par Ref == 1, becomes 4 } // 349 %integer {One Fifty} Int Loc #line 349 "dhry_1.imp" int INTLOC; // 350 %integer {Enumeration} Enum Loc #line 350 "dhry_1.imp" int ENUMLOC; // 351 // 352 Int Loc = Int Par Ref + 10 #line 352 "dhry_1.imp" INTLOC = ((*(int *)(INTPARREF)) + (10)); // 353 %cycle { executed once } #line 353 "dhry_1.imp" L_0012:; // 354 %if Ch 1 Glob = 'A' %start #line 354 "dhry_1.imp" if (((CH1GLOB) != (65))) goto L_0015; // 355 { then, executed } // 356 Int Loc = Int Loc - 1 #line 356 "dhry_1.imp" INTLOC = (((int)(INTLOC)) - (1)); // 357 Int Par Ref = Int Loc - Int Glob #line 357 "dhry_1.imp" *INTPARREF = (((int)(INTLOC)) - (INTGLOB)); // 358 Enum Loc = Ident 1 #line 358 "dhry_1.imp" ENUMLOC = 0; // 359 %finish { if } #line 359 "dhry_1.imp" L_0015:; // 360 %repeat %until Enum Loc = Ident 1 { true } #line 360 "dhry_1.imp" if (((ENUMLOC) == (0))) goto L_0013; #line 360 "dhry_1.imp" goto L_0012; #line 360 "dhry_1.imp" L_0013:; // 361 %end { Proc 2 } #line 361 "dhry_1.imp" /* Remove %on %event handler here if present for this block */ return; } // End of block PROC2 at level 2 // 362 // 363 // 364 %routine Proc 3 (%record (Rec Type fm) %name Ptr Ref Par) #line 364 "dhry_1.imp" void PROC3( RECTYPEFM /*name*/*PTRREFPAR ) #line 364 "dhry_1.imp" { // 365 {****************} // 366 { executed once } // 367 { Ptr Ref Par becomes Ptr Glob } // 368 // 369 %if Ptr Glob ## Null %then { then, executed } Ptr Ref Par == Ptr Glob_Ptr Comp #line 369 "dhry_1.imp" if (((&PTRGLOB) == (NULL))) goto L_0016; #line 369 "dhry_1.imp" PTRREFPAR = PTRGLOB.PTRCOMP; #line 369 "dhry_1.imp" L_0016:; // 370 Proc 7 (10, Int Glob, Ptr Glob_variant_var 1_Int Comp) #line 370 "dhry_1.imp" PROC7(10, INTGLOB, &PTRGLOB.VARIANT.VAR1.INTCOMP); // 371 %end { Proc 3 } #line 371 "dhry_1.imp" /* Remove %on %event handler here if present for this block */ return; } // End of block PROC3 at level 2 // 372 // 373 // 374 %routine Proc 4 { without parameters } #line 374 "dhry_1.imp" void PROC4( void ) #line 374 "dhry_1.imp" { // 375 {*****} // 376 { executed once } // 377 %integer {Boolean} Bool Loc #line 377 "dhry_1.imp" int BOOLLOC; // 378 // 379 %if Ch 1 Glob = 'A' %then Bool Loc = true %else Bool Loc = false #line 379 "dhry_1.imp" if (((CH1GLOB) != (65))) goto L_0017; #line 379 "dhry_1.imp" BOOLLOC = 1; #line 379 "dhry_1.imp" goto L_0018; #line 379 "dhry_1.imp" L_0017:; #line 379 "dhry_1.imp" BOOLLOC = 0; #line 379 "dhry_1.imp" L_0018:; // 380 Bool Glob = Bool Loc ! Bool Glob #line 380 "dhry_1.imp" BOOLGLOB = ((BOOLLOC) | (BOOLGLOB)); // 381 Ch 2 Glob = 'B' #line 381 "dhry_1.imp" CH2GLOB = 66; // 382 %end { Proc 4 } #line 382 "dhry_1.imp" /* Remove %on %event handler here if present for this block */ return; } // End of block PROC4 at level 2 // 383 // 384 // 385 %routine Proc 5 { without parameters } #line 385 "dhry_1.imp" void PROC5( void ) #line 385 "dhry_1.imp" { // 386 {*****} // 387 { executed once } // 388 Ch 1 Glob = 'A' #line 388 "dhry_1.imp" CH1GLOB = 65; // 389 Bool Glob = false #line 389 "dhry_1.imp" BOOLGLOB = 0; // 390 %end { Proc 5 } #line 390 "dhry_1.imp" /* Remove %on %event handler here if present for this block */ return; } // End of block PROC5 at level 2 // 391 // 392 // 393 { Procedure for the assignment of structures, } // 394 { if the C compiler doesn't support this feature } // 395 // 396 %endofprogram #line 396 "dhry_1.imp" /* Remove %on %event handler here if present for this block */ return 0; } // End of block _imp_main at level 1 #line 396 "dhry_1.imp" // End of file