home *** CD-ROM | disk | FTP | other *** search
/ Programmer's ROM - The Computer Language Library / programmersrom.iso / ada / point / compeval.inf < prev    next >
Encoding:
Text File  |  1988-05-03  |  59.6 KB  |  1,733 lines
  1.  
  2.                  EVALUATION CRITERIA FOR ADA COMPILERS
  3.  
  4.                                                      11 September 1984
  5.  
  6.  
  7. Author:  Elizabeth Kean (Rome Air Development Center)  in  support  of
  8. the E&V Team
  9.  
  10. In  June  1983, the AJPO proposed the formation of the E&V (Evaluation
  11. and Validation) Task and a tri-service APSE E&V  Team,  with  the  Air
  12. Force  (Air Force Wright Aeronautical Laboratories (AFWAL)) designated
  13. as the lead service.  The purpose of the E&V Team is  to  develop  the
  14. techniques  and  tools  which  will  provide  a  capability to perform
  15. assessment of APSEs and to determine the conformance of APSEs  to  the
  16. CAIS (Common APSE Interface Set).
  17.  
  18. In  order  to  accomplish  this  goal,  a  criteria  questionnaire was
  19. developed and distributed at the SigAda meeting (30 July  -  1  August
  20. 1984)  in  Hyannis,  MA.   Based upon comments received regarding this
  21. questionnaire, the following  list  of  evaluation  criteria  for  Ada
  22. compilers was composed.
  23.  
  24. The  criteria/tests  are  designed  to  complement  the  Ada  Compiler
  25. Validation Capability (ACVC) test suite.  The criteria  are  collected
  26. according  to  the  set  of attributes defined in the Requirements for
  27. Evaluation and Validation of  Ada  Programming  Support  Environments,
  28. dated  17  October  1984.   Compiler  areas  yet to be covered indepth
  29. include the  run-time  system,  program  library  tools,  linking  and
  30. loading facilities, etc.
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60. AVAILABILITY
  61.  
  62. 1.  Have there been any major software systems  developed  using  this
  63. compiler?
  64.  
  65. 2.   For  each of the compiler's targets, approximately how many users
  66. are there?  To what degree have the targets been exercised?
  67.  
  68. 3.  Can the compiler be invoked in both an  interactive  and  a  batch
  69. mode?
  70.  
  71. 4.   Can the compiler be invoked while using other APSE tools?  (While
  72. in the editor, for example.)
  73.  
  74. 5.  Are there any additional tools supplied with the  compiler  (e.g.,
  75. symbolic debugger, target simulator, downloader, linker, etc.)?
  76.  
  77. 6.   Are  there significant compiler features that could be considered
  78. above and beyond that specified in the Ada language specification?
  79.  
  80.  
  81. CAPACITY
  82.  
  83. 1.  What is the maximum number of errors detectable on a single line?
  84.  
  85. 2.   What  is  the  maximum  number  of  errors detectable in a single
  86. compilation unit?
  87.  
  88. 3.  What is the maximum number of Ada statements allowed for a  single
  89. compilation unit?  How are statements to be counted for this purpose?
  90.  
  91. 4.   What  is  the  maximum  number of compilation units allowed for a
  92. single file?
  93.  
  94. 5.  What is the maximum number  of  symbols  allowed  per  compilation
  95. unit?
  96.  
  97. 6.  What is the maximum length allowed for a source line?
  98. KNOWN TESTS:
  99. (AIE)fen0801a, (AIE)fen0801b
  100.  
  101. 7.   What is the maximum size of the Intermediate Language that can be
  102. generated?
  103.  
  104. 8.  What are the maximum number of elements allowed in an  enumeration
  105. type?
  106.  
  107. 9.   What  is  the maximum level of nesting in packages, loops, cases,
  108. record type declarations, IF-statements, blocks, etc?
  109. KNOWN TESTS:
  110. Packages:  (AIE)fen0807a, (AIE)fen0807b, (AIE)fen0807c
  111. Loops:  (AIE)fen0805a, (AIE)fen0805b, (AIE)fen0805c
  112. IFs:  (AIE)fen0806a, (AIE)fen0806b, (AIE)fen0806c
  113. Blocks:  (AIE)fen0804a, (AIE)fen0804b, (AIE)fen0804c
  114. Subprograms:  (AIE)fen0808a, (AIE)fen0808b, (AIE)fen0808c,
  115. (AIE)fen0809a
  116.  
  117.  
  118.  
  119.                                  - 2 -
  120. 10.  What are the maximum number of operands in expressions?
  121.  
  122. 11.  What is the maximum number of WITHed units allowed?
  123. KNOWN TESTS:
  124. 196-199 WITHs:  (AIE)fen0803a, (AIE)fen0803b, (AIE)fen0803c,
  125. (AIE)fen0803d, (AIE)fen0803e
  126.  
  127. 12.   What  is  the  maximum  number of DIANA structures (i.e., symbol
  128. table entries) imported for a single compilation?
  129.  
  130. 13.  What is the maximum number of tasks that can be in existence?
  131.  
  132. 14.  What is the maximum number of tasks that can  be  spawned  for  a
  133. single program?
  134.  
  135. 15.  What is the maximum length of an identifier?
  136.  
  137. 16.  What is the maximum number of discriminants in a constraint?
  138.  
  139. 17.  What is the maximum number of fields in a record aggregate?
  140.  
  141. 18.  What is the maximum number of formals in a generic unit?
  142.  
  143. 19.  What is the maximum number of nested contexts?
  144.  
  145. 20.  What is the maximum number of indices in an array aggregate?
  146.  
  147. 21.  What is the maximum number of parameters in a call?
  148.  
  149. 22.  What is the maximum depth of expansion of INLINE subprograms?
  150.  
  151. 23.   What is the maximum precision of the fixed point, floating point
  152. and integer arithmetic?
  153. KNOWN TESTS:
  154. (AdaFair84)cauchf1.ada, (AdaFair84)cauchfy.ada,
  155. (AdaFair84)univ_ar.ada, (AdaFair84)cauchun.ada, (AVO)MATHTEST
  156.  
  157.  
  158. 24.   What  is  the  maximum/minimum  size  of  the  run-time   system
  159. with/without tasking?
  160.  
  161. 25.  What is the size of the each of the phases of the compiler?
  162.  
  163. 26.  What is the minimum memory required to execute the compiler?
  164.  
  165. 27.  Is LOW_LEVEL_IO supported?
  166.  
  167. 28.   Do  SEQUENTIAL_IO  and  DIRECT_IO "Work as expected?" Under what
  168. conditions, if any is USE_ERROR raised?
  169.  
  170. 29.  Do the compiler  and  runtimes  implement  non-blocking  I/O  and
  171. non-blocking operating system service calls?
  172.  
  173. 30.   What  is  the  range  of  PRIORITY?   What  is  the runtime task
  174. scheduling algorithm?
  175.  
  176. 31.  Are any limitations imposed on the use  of  pragmas  SYSTEM_NAME,
  177.  
  178.  
  179.                                  - 3 -
  180. STORAGE_UNIT, and MEMORY_SIZE?
  181.  
  182. 32.  What is the maximum number of overloadings per identifier?
  183.  
  184. 33.   Can  generic  bodies   be   compiled   separately   from   their
  185. specifications?
  186.  
  187. 34.  Can any instances of erroneous execution be detected?
  188.  
  189. 35.  Can deadlock be detected?
  190.  
  191. 36.  What overhead is involved in context switching between tasks?
  192. KNOWN TESTS:
  193. (SRI)chain2, (SRI)chain5, (SRI)chain10, (SRI)chain20
  194.  
  195. 37.   How  does  the  Ada  compiler  perform  when  compiling  various
  196. applications programs?
  197. KNOWN TESTS:
  198. (AdaFair84)bsearch.ada, (AdaFair84)random.ada, (AdaFair84)set.ada
  199. (AVO.WORLDOF)directory_utility, (AVO)KPTOOLS, (AVO)FORMATTER,
  200. (AVO)STUBBER
  201.  
  202. 38.  How large is the compiler?
  203.  
  204. 39.  Is the compiler ever completely in memory?
  205.  
  206. 40.  What is the value of each of  the  predefined  attributes  (e.g.,
  207. INTEGER'FIRST, INTEGER'LAST, FLOAT'DIGITS, etc.)
  208.  
  209. 41.   What is the maximum number of users that can invoke the compiler
  210. simultaneously?  Has this number been verified?
  211.  
  212.  
  213. CONFIGURATION MANAGEMENT (CM)
  214.  
  215. 1.  What is the general CM plan?
  216.  
  217. 2.  Who is responsible for CM (for the supplier)?
  218.  
  219. 3.   Are  all  the  source  and  object modules for a complete version
  220. available in one area (e.g., on a tape or a separately controlled disk
  221. area)?   Is  this  area accessible to only one person or anyone on the
  222. project?
  223.  
  224. 4.  How are compiler fixes or enhancements  incorporated  into  a  new
  225. version?
  226.  
  227. 5.   How  are  new  versions  controlled and released?  Which of these
  228. versions will be recertified or revalidated?
  229.  
  230. 6.  If the compiler produces code for more than one  target,  how  are
  231. common  and  machine-dependent  modules  controlled?  For example, are
  232. there conventions for naming common function modules for each target?
  233.  
  234. 7.  How are approved compiler changes incorporated into new  versions?
  235. (The change approval procedures).
  236.  
  237.  
  238.  
  239.                                  - 4 -
  240. 8.  Does there exist a list of all modules  (including  the  run  time
  241. system)  that  are needed for a complete compiler version?  (A version
  242. description document).
  243.  
  244.  
  245. COST
  246.  
  247. 1.   What are the costs of acquiring the compiler?  These costs should
  248. be given in terms of:
  249.  
  250.      a.   Does  the  cost  include  the  installation   and   required
  251. maintenance support?
  252.  
  253.      b.  Is source code or only object code supplied?
  254.  
  255.      c.  Costs of additional (non-supplier developed tools)?
  256.  
  257.      d.  Monthly (or periodic) additional maintenance fees?
  258.  
  259.      e.  Does the cost include receipt of new versions of the compiler
  260. and needed tools?
  261.  
  262.      f.  Various cost options  depending  on  licensing  (proprietary)
  263. arrangements?
  264.  
  265. 2.  What is the estimated cost for a compiler rehost?
  266.  
  267. 3.  What is the estimated cost for a compiler retarget?
  268.  
  269. 4.   What  do  the costs for rehosting and retargetting include (test,
  270. integration, installation, etc.)?
  271.  
  272.  
  273. DOCUMENTATION
  274.  
  275. 1.   Is  a  requirements  document  available?  Verify the content and
  276. quality.
  277.  
  278. 2.  Are complete design specifications available?  Verify the  content
  279. and quality as follows:
  280.  
  281.      a.   An  overview  of  the  compiler  design  showing  the  major
  282. structure and design.
  283.  
  284.      b.  Details of the compiler phases and passes.
  285.  
  286.      c.  Separate sections which outline the design of  the  host  and
  287. each target (to include the run time system(s)).
  288.  
  289.      d.   Is  the  design  detail  sufficient such that an experienced
  290. compiler software engineer could maintain the compiler?
  291.  
  292.      e.  Are compiler design changes updated in the documents?
  293.  
  294. 3.  Is sufficient user documentation available for the host  and  each
  295. target?  Is it on-line?
  296.  
  297.  
  298.  
  299.                                  - 5 -
  300. 4.  Does the users (or reference) manual contain an Appendix  F  which
  301. describes all implementation dependent characteristics?
  302.  
  303. 5.   Is  the  compiler  release and compilation date identified on the
  304. hard copy listing?
  305.  
  306. 6.  Is documentation available for any special tools  that  were  used
  307. for the compiler development?
  308.  
  309. 7.   Is documentation available for any separate tools that are needed
  310. for compiler operation?
  311.  
  312. 8.  What are the procedures used to  update  the  documentation  as  a
  313. result of compiler changes?  Who is responsible to verify that this is
  314. done?
  315.  
  316. 9.  Are there any alternative structures suggested for the  production
  317. of low cost low quality back ends and high quality back ends?
  318.  
  319.  
  320. EFFICIENCY
  321.  
  322. (For the following set of questions, speed is  the  number  of  source
  323. statements per CPU minute.)
  324.  
  325. 1.  What is the speed of object code generation (from the beginning of
  326. compilation)?
  327. KNOWN TESTS:
  328. (AIE)ben0701a
  329.  
  330. 2.  What is the speed of the Front-End if it can be run separately?
  331.  
  332. 3.  What is the speed of the Back-End if it can be run separately?
  333.  
  334. 4.  What is the speed of listing generation?
  335.  
  336. 5.   What  is  the  speed  of  compilation   with   OPTIMIZATION=time?
  337. OPTIMIZATION= space?  OPTIMIZATION=none?
  338.  
  339. 6.   Do  the  pragmas  supported  by  the compiler, if any, impact the
  340. compilation speed?
  341.  
  342.  
  343. 7.   What target machine independent optimizations are performed?  For
  344. example, does the  compiler  perform  constant  propagation,  constant
  345. folding,  common subexpression elimination, expression simplification,
  346. strength reduction, range and constraint checks, removing  unreachable
  347. code,  cross-jumping,  task  context switch minimization, code sharing
  348. between generic instantiations, etc.?
  349. KNOWN TESTS:
  350. (AIE)ben0301a, (AIE)ben0301b, (AIE)ben0302a, (AIE)ben0302b,
  351. (AIE)ben0302c, (AIE)ben0302t, (AIE)ben0302e, (AIE)ben0303a,
  352. (AIE)ben0303b, (AIE)ben0303c, (AIE)ben0303d, (AIE)ben0303e,
  353. (AIE)ben0303f, (AIE)ben0303g, (AIE)ben0303h, (AIE)ben0303i,
  354. (AIE)ben0303j, (AIE)ben0303k, (AIE)ben0303l, (AIE)ben0303m,
  355. (AIE)ben0304a, (AIE)ben0304b, (AIE)ben0304c, (AIE)ben0304d,
  356. (AIE)ben0304e, (AIE)ben0304f, (AIE)ben0304g, (AIE)ben0401a,
  357.  
  358.  
  359.                                  - 6 -
  360. (AIE)ben0401b, (AIE)ben0402a, (AIE)ben0501a, (AIE)ben0501b,
  361. (AIE)ben0501c, (AIE)ben0501d, (AIE)ben0502a, (AIE)ben0502b,
  362. (AIE)ben0502c, (AIE)ben0502d, (AIE)ben0502e, (AIE)ben0502f,
  363. (AIE)ben0502g, (AIE)ben0502h, (AIE)ben0502i, (AIE)ben0503a,
  364. (AIE)ben0504a, (AIE)ben0504b, (AIE)ben0504c, (AIE)ben0504d,
  365. (AIE)ben0504e
  366.  
  367. 8.  What target dependent optimizations are employed?
  368.  
  369. 9.   What  is  the  probable effect of optimization on the raising and
  370. handling of exceptions (ess LRM 11.6)?
  371.  
  372. 10.  To what extent does the user control the optimizations?
  373.  
  374. 11.  Can the user specify the use/non-use of specific optimizations?
  375.  
  376. 12.  How does using select alternatives affect the performance of  the
  377. executable code?
  378. KNOWN TESTS:
  379. (SRI) guard2, (SRI) guard20, (SRI) guard20e, (SRI) guard20et, (SRI)
  380. guards20t, (SRI) guards2e
  381.  
  382. 13.  Do idle tasks impact the performance of the executable code?
  383. KNOWN TESTS:
  384. (SRI)idle1, (SRI)idle5, (SRI)idle10, (SRI)idle20
  385.  
  386. 14.  Is it better to have many small tasks with single  entry  choices
  387. or a few large tasks with many select choices?
  388. KNOWN TESTS:
  389. (SRI)moretasks, (SRI)moretasks1, (SRI)moreselct, (SRI)moreselctr
  390.  
  391. 15.   Does  the ordering of entry clauses in a SELECT impact execution
  392. speed?
  393. KNOWN TESTS:
  394. (SRI)order31, (SRI)order31r, (SRI)order32, (SRI)order100
  395.  
  396. 16.  If multiprocessing is supported by the  implementation,  are  Ada
  397. tasks mapped to a single underlying process, or is each task mapped to
  398. a separate process?
  399.  
  400. 17.  If the target is  a  distributed  system,  how  is  "immediately"
  401. defined for conditional entry calls?
  402.  
  403. 18.  Does the size of a parameter affect performance?
  404. KNOWN TESTS:
  405. (SRI)passarrys, (SRI)passarryb, (SRI)passinout
  406.  
  407. 19.  Does the number of select choices affect performance?
  408. KNOWN TESTS:
  409. (SRI)select2, (SRI)select2e, (SRI)select20, (SRI)select20e
  410.  
  411. 20.  Can the Ada scheduler starve a task?
  412. KNOWN TESTS:
  413. (SRI)schedtest
  414.  
  415. 21.   What is the size of the resulting object code for OPTIMIZE=none?
  416. OPTIMIZE=space?  OPTIMIZE=time?
  417.  
  418.  
  419.                                  - 7 -
  420.  
  421. 22.  What is the CPU time required for execution of code compiled with
  422. OPTIMIZE=none?  OPTIMIZE=time?  OPTIMIZE=space?
  423. KNOWN TESTS:
  424. (AVO.WORLDOF)eratos.r, (AVO.WORLDOF)float_test.r,
  425. (AVO.WORLDOF)generator.r, (AVO.WORLDOF)io_test.r,
  426. (AVO.WORLDOF)item_body.r, (AVO.WORLDOF)item_spec.r,
  427. (AVO.WORLDOF)1f_disk_80.tex, (AVO.WORLDOF)1f_pgmap.text,
  428. (AVO.WORLDOF)list_body.r, (AVO.WORLDOF)sieve_task.r,
  429. (AVO.WORLDOF)stinger.r, (AVO.WORLDOF)timing.r, (AVO.WORLDOF)tower.r,
  430. (AVO.WORLDOF)tran_spec.r, (AVO.WORLDOF.juggling1)e_ball_1.r,
  431. (AVO.WORLDOF.juggling1)1_hand_1.r, (AVO.WORLDOF.juggling1)o_ball_1.r,
  432. (AVO.WORLDOF.juggling1)r_hand_1.r, (AVO.WORLDOF.juggling2)counter.r,
  433. (AVO.WORLDOF.juggling2)even_ball.r, (AVO.WORLDOF.juggling2)get_jug.r,
  434. (AVO.WORLDOF.juggling2)left_hand.r, (AVO.WORLDOF.juggling2)monitor.r
  435. (AVO.WORLDOF.juggling2)odd_ball_1.r,
  436. (AVO.WORLDOF.juggling2)print_pos.r,
  437. (AVO.WORLDOF.juggling2)right_hand.r
  438.  
  439. 23.   What  is the difference in size between object code generated by
  440. an Ada compiler as compared with other languages (e.g., Pascal, COBOL,
  441. C, FORTRAN, Assembler, etc.)?
  442.  
  443. 24.   What  is  the  difference  in execution time between object code
  444. generated by an Ada compiler as compared with other languages?
  445.  
  446. 25.  What is the execution time (in CPU seconds) for  file  operations
  447. (with TEXT_IO, DIRECT_IO, etc.)?
  448. KNOWN TESTS:
  449. (AdaFair84)char_dir.ada, (AdaFair84)char_pnum.ada,
  450. (AdaFair84)int_dir.ada, (AdaFair84)char_text.ada,
  451. (AdaFair84)int_text.ada
  452.  
  453. 26.   What  is  the execution time (in CPU seconds) for arithmetic and
  454. logical operations?
  455. KNOWN TESTS:
  456. (AdaFair84)boolvec.ada, (AdaFair84)floatvec.ada,
  457. (AdaFair84)intvec.ada, (AVO)AHL, (AVO)AUSSIE, (AVO)BASEMATH, (AVO)ADD,
  458. (AVO)MULT, (AVO)PUZZLE, (AVO)SEARCH, (AVO)SIEVE,
  459. (AVO)SYNTHETIC(Whetstone), (AVO.MARK)ADD, (AVO.MARK)MULT,
  460. (AVO.MARK)PUZZLE, (AVO.MARK)SEARCH, (AVO.MARK)SIEVE,
  461. (AVO.MARK)SYNTHETIC(Whetstone)
  462.  
  463. 27.  What is the execution time (in CPU seconds) for simple procedures
  464. with scalar parameters?
  465. KNOWN TESTS:
  466. (AdaFair84)proccal.ada
  467.  
  468. 28.  What is  the  execution  time  (in  CPU  seconds)  for  a  simple
  469. rendezvous?
  470. KNOWN TESTS:
  471. (AdaFair84)rendez.ada
  472.  
  473. 29.   What is the effect on code size and execution time of the pragma
  474. SUPPRESS?
  475.  
  476. 30.  What is the effect on code  size  and  execution  time  of  using
  477.  
  478.  
  479.                                  - 8 -
  480. UNCHECKED_DEALLOCATION vs.  pragma CONTROLLED vs.  neither?
  481.  
  482. 31.  What is the effect on code size of a DEBUG option, if is exists?
  483.  
  484.  
  485. 32.   What  is  the  procedure  calling  overhead  for  procedures and
  486. functions?
  487. KNOWN TESTS:
  488. (AdaFair84)ackerman.ada, (AVO)ACKER, (AVO.WORLDOF)ackerman.r
  489.  
  490. 33.  Are there Ada features that produce more  efficient  object  code
  491. with respect to time and space?
  492. KNOWN TESTS:
  493. (AdaFair84)qsortpar.ada, (AdaFair84)qsortseq.ada
  494.  
  495.  
  496. EXTENDABILITY
  497.  
  498. 1.  What were the original design goals of the compiler?
  499.  
  500.      a.  Was the design intended for a particular class of users?
  501.  
  502.      b.  Are any specific applications envisaged?
  503.  
  504. 2.  Is the compiler is  written  in  Ada,  were  the  use  of  certain
  505. language   constructs   avoided   (e.g.,   tasking,   generics,   real
  506. arithmetic)?  If so, which ones and why?
  507.  
  508. 3.  If the compiler is written in Ada, has it successfully  recompiled
  509. itself?
  510.  
  511. 4.   Were  any  special  tools such as a compiler-compiler, translator
  512. writing systems, etc., used during the development.  If so,  are  they
  513. available to possibly construct additional tools?
  514.  
  515.      a.   Do  these tools generate a source program of the compiler or
  516. do they translate directly into object code?
  517.  
  518.      b.  If these tools do not generate an  Ada  (or  other  language)
  519. program, how can the tools be retargeted?
  520.  
  521.      c.  What languages are the tools written in?
  522.  
  523.  
  524. GRANULARITY
  525.  
  526. 1.  What are the major compiler phases?  What phases are in memory  as
  527. the compilation progresses?
  528.  
  529. 2.   To  what  degree  are  the  components of the compiler separately
  530. executable tools?  Is their use documented?
  531.  
  532. 3.  What parts of the compiler are seen as useful  in  building  other
  533. tools?
  534.  
  535.  
  536. HARDWARE
  537.  
  538.  
  539.                                  - 9 -
  540.  
  541. 1.  What are the host/target pairs for the compiler?
  542.  
  543. 1.   For  each target, does the compiler directly output (relocatable)
  544. object code?
  545.  
  546. 3.  For each target, does the compiler output assembly  language?   Is
  547. it a standard version?
  548.  
  549. 4.  What is the character set of the host?  of the target?
  550.  
  551. 5.   Are  hardware machine dependencies clearly identified in both the
  552. code and documentation?
  553.  
  554. 6.  Is the compiler designed to use virtual memory?
  555.  
  556. 7.  Is the compiler designed to take advantage  of  a  multiprocessing
  557. implementation?  (Was the compiler designed to use multitasking?)
  558.  
  559. 8.  Are hardware dependencies concealed by module interfaces?
  560.  
  561. 9.   Does  the  compiler  support distributed machine targets?  If so,
  562. which ones?
  563.  
  564.  
  565. INTERFACES
  566.  
  567. 1.   Is  the  major  design interface to a KAPSE or the host operating
  568. system?
  569.  
  570. 2.  If the interface is to a KAPSE, what  KAPSE  facilities  does  the
  571. compiler use?
  572.  
  573. 3.   Does the compiler operate in a particular APSE?  If so, what APSE
  574. (or MAPSE) tools does it require, if any?
  575.  
  576. 4.  If not part of an APSE, what characteristics of the host operating
  577. system  does  the  compiler rely on?  Are all such system dependencies
  578. concealed behind module interfaces?
  579.  
  580. 5.  Which interfaces are regarded  as  significant  for  rehosting  or
  581. retargeting?
  582.  
  583. 6.   What  other  tools  (e.g.,  symbolic  debugger) does the compiler
  584. interface with?
  585.  
  586.      a.  To what extent are the interfaces documented?
  587.  
  588.      b.   Can  alternative  tools  be  written  conforming  to   these
  589. interfaces?
  590.  
  591.  
  592. INTEROPERABILITY
  593.  
  594. 1.  What compiler generated information is available to  other  tools?
  595. Symbol  table?   Cross-reference  table?  Intermediate forms?  Listing
  596. outputs?
  597.  
  598.  
  599.                                  - 10 -
  600.  
  601. 2.   Does the compiler share, or make use of, other APSE (or operating
  602. system) tables or information?
  603.  
  604.  
  605. MAINTAINABILITY
  606.  
  607. 1.  What language(s) is the compiler written in?
  608.  
  609. 2.   Are  instructions  available  to  enable a non-compiler person to
  610. install the compiler on an identical host system?
  611.  
  612. 3.  Are the procedures for complete compiler generation  (from  source
  613. to executable) documented?
  614.  
  615. 4.    What   arrangements   are   available   for  maintenance?   Such
  616. arrangements can range from postal service to an  on-call  maintenance
  617. staff.
  618.  
  619. 5.  What is the quality of maintenance support?
  620.  
  621.      a.  Designated persons for maintenance contract?
  622.  
  623.      b.  Availability of maintenance documentation?
  624.  
  625.      c.   Telephone  query service, visits by supplier staff, courses,
  626. etc?
  627.  
  628. 6.  What are the arrangements  for  charging  for  maintenance  and/or
  629. support of the compiler?
  630.  
  631.  
  632. PROPRIETARY
  633.  
  634. 1.  Can a user install the compiler,  or  must  the  supplier  do  the
  635. installation?
  636.  
  637. 2.   Are there any proprietary restrictions on compiler release (e.g.,
  638. no source supplied, data rights, etc.)?
  639.  
  640. 3.  Are there any restrictions  on  special  (non-supplier  developed)
  641. tools  needed  for  compiler  operation?  Also, for any optional tools
  642. that may be useful?
  643.  
  644. 4.  Does the supplier allow others to perform a rehost or retarget?
  645.  
  646. 5.  Under what circumstances may the source be made  available  for  a
  647. rehost or retarget?
  648.  
  649. 6.  What are the licensing arrangements for the compiler (e.g., at how
  650. many sites can the compiler be used)?
  651.  
  652. 7.  What agreement does the user have to sign before the compiler  may
  653. be supplied to others?
  654.  
  655. 8.   Can  a  license to distribute the compiler to others be bought or
  656. leased?  What parts  of  the  compiler  (run  time  system,  packages,
  657.  
  658.  
  659.                                  - 11 -
  660. separate tools, etc.) can be distributed?  Can source be included?
  661.  
  662. 9.  Can a license to use the compiler be bought outright or leased?
  663.  
  664. 10.  What are the arrangements (if any) for the release of information
  665. about the compiler's internal structure?
  666.  
  667. 11.   Are  there  any  restrictions  on the use and/or distribution of
  668. software produced by the  compiler?   It  should  be  noted  that  the
  669. software  produced  often  contains a run time system delivered by the
  670. compiler supplier.
  671.  
  672.  
  673. REHOSTABILITY
  674.  
  675. 1.  Has the compiler been rehosted?
  676.  
  677. 2.   What  module  (or modules) of the front end (machine independent)
  678. need to be modified for the rehost?
  679.  
  680. 3.  Is there a manual which describes the steps  necessary  to  rehost
  681. the compiler?
  682.  
  683. 4.  Are system dependencies adequately isolated and documented?
  684.  
  685. 5.   Is  there a kit of tools and/or components available to help with
  686. the rehosting task?
  687.  
  688. 6.  Is the compiler sufficiently modular to  allow  implementation  of
  689. critical  parts  (such  as major data structures) to be easily altered
  690. for the rehost task?
  691.  
  692. 7.  Is an estimate of time given for the rehost?
  693.  
  694.  
  695. RETARGETABILITY
  696.  
  697. 1.   What  modules  of  the  back  end  (machine dependent) need to be
  698. modified for a retarget?
  699.  
  700. 2.  What modules of the front end need to be modified for  a  retarget
  701. and what are their interfaces?
  702.  
  703.      a.   What techniques are used:  Package standard, parameter file,
  704. a special package that is linked in, etc.)?  Hopefully,  this  is  not
  705. wired in to the compiler.
  706.  
  707. 3.  Are there any automated tools to aid in the retarget process?
  708.  
  709. 4.  Is an estimate of time given for the retarget task?
  710.  
  711. 5.   Is  there  a  manual  describing  the procedures for retargeting?
  712. Possibly with examples.
  713.  
  714. 6.  For  the  intermediate  language  retargeting  interface,  is  the
  715. intermediate language tree structured, linear, etc?
  716.  
  717.  
  718.  
  719.                                  - 12 -
  720. 7.  Is there more than one level of  intermediate  language  at  which
  721. retargetting is carried out?
  722.  
  723. 8.   For the retarget process, what assumptions are made in the design
  724. of, and requirements of, the run time system (e.g.,  tasking  monitor,
  725. storage allocation scheme, etc.)?
  726.  
  727. 9.   For a retarget, do the presence of other tools in the compilation
  728. system or APSE affect the back end?
  729.  
  730.  
  731. ROBUSTNESS
  732.  
  733. 1.   What  safeguards  are  implemented  for  protection  and recovery
  734. against  unforeseen  system,  user  and  its   own   failures?    Data
  735. protection?  Internal exception handlers?  Trace back facility?
  736.  
  737. 2.   As  more  than one simultaneous user invokes the compiler, by how
  738. much does the mininum size  of  memory  needed  to  run  the  compiler
  739. increase?
  740.  
  741. 3.   Are any resources other than primary and secondary storage needed
  742. to invoke the compiler?
  743.  
  744. 4.  Are compiler phases overlaid to reduce memory occupancy?   If  so,
  745. are any requirements placed on the system?
  746.  
  747.  
  748. TEST AVAILABILITY
  749.  
  750. 1.  What tests are available from  the  supplier  to  verify  compiler
  751. operations?
  752.  
  753.      a.  Are the tests documented in a test plan?
  754.  
  755.      b.  Are instructions for use available?
  756.  
  757.  
  758. USABILITY
  759.  
  760. 1.  If the compiler interface is to the host operating  system,  under
  761. which operating system version (or release) does the compiler operate?
  762. Also, which target(s) operating system(s)?
  763.  
  764. 2.  If the compiler interface is to an APSE, under  what  version  (or
  765. release) of the APSE does the compiler operate?
  766.  
  767. 3.   What  are  the  values outside the range of safe numbers for real
  768. types?
  769.  
  770. 4.  Are there any restrictions on the use  of  the  generic  procedure
  771. UNCHECKED_DEALLOCATION?
  772.  
  773. 5.   Are  there  any  restrictions on the use of the generic procedure
  774. UNCHECKED_CONVERSION?
  775.  
  776. 6.  Does the compiler generate a history  file  which  records  source
  777.  
  778.  
  779.                                  - 13 -
  780. file name, compilation unit name, program library  name,  owner(s)  of
  781. each and the date/time of the compilation?
  782.  
  783. 7.   Does  the  compiler  record the versions of all compilation units
  784. used in the compilation?
  785.  
  786. 8.  How many passes over the code (source and IL)  does  the  compiler
  787. make?
  788.  
  789. 9  What  compiler  options  are  available?  For example, can the user
  790. specify the following  options:   no  semantics,  no  code,  comments,
  791. lookahead,  optimize  (off,  space,  time,  etc),  choice  of  runtime
  792. kernels,  compiler  maintenance,  compiler  new  version  of   package
  793. STANDARD,  debug,  main  program  identification,  prettyprint source,
  794. provide user with traceback information for unhandled exceptions, etc?
  795. KNOWN TESTS:
  796. (AIE)fen0501a, (AIE)fen0502a, (AIE)fen0503a, (AIE)fen0503b,
  797. (AIE)fen0503c, (AIE)fen0503d, (AIE)fen0503e, (AIE)fen0503f,
  798. (AIE)fen0504a, (AIE)fen0504b, (AIE)fen0504c, (AIE)fen0504d,
  799. (AIE)fen0504e, (AIE)fen0504f, (AIE)fen0505a, (AIE)fen0505b,
  800. (AIE)fen0506a, (AIE)fen0506b, (AIE)fen0506c, (AIE)fen0506d,
  801. (AIE)mid0501a, (AIE)mid0502b, (AIE)mid0502d, (AIE)mid0503a,
  802. (AIE)ben0201a, (AIE)mid0501b, (AIE)mid0501c, (AIE)mid0502c,
  803. (AIE)ben0102a (AIE)mid0502a, (AIE)ben0101a, (AIE)ben0202a
  804.  
  805. 10.   What control does the user have over listings?  For example, can
  806. the user control:   listing  source  text,  reformatting  the  source,
  807. listing text of an instantiated generic unit, listing private parts of
  808. packages, listing attributes of all symbols in  source  text,  listing
  809. cross    reference    information,    listing    statistics,   listing
  810. machine/assembly code, listing the  intermediate  language  generated,
  811. listing   diagnostics,  listing  use  of  machine-dependent  features,
  812. pragmas, etc.?
  813.  
  814. 11.  Does abnormal termination leave a consistent program library?  If
  815. not,  how  can  a  user restore consistency?  Are checkpointing and/or
  816. transaction updating supported?
  817.  
  818. 12.  Is the intermediate language generated available for other tools?
  819.  
  820. 13.  Can the source be reconstructed from  the  intermediate  language
  821. (e.g., DIANA, or Abstract Syntax Tree)?
  822.  
  823. 14.   Are  all  LRM  pragmas  properly  recognized  or  handled?  What
  824. implementation dependent pragmas are supported, if any?
  825. KNOWN TESTS:
  826. Pragma OPTIMIZE:  (AIE)mid0503a, (AIE)mid0503b
  827. Pragma STATIC:  (AIE)mid0504a, (AIE)mid0504b
  828. Pragma INLINE:  (AIE)mid0505a, (AIE)ben0505a, (AIE)ben0505b
  829.  
  830. 15.  Are the parameter passing methods and  subprogram  calls  handled
  831. efficiently?
  832. KNOWN TESTS:
  833. PASSED BY VALUE (<= 64 BITS):  (AIE)mid0701a, (AIE)mid0701b
  834. PASSED BY VALUE (>= 64 BITS):  (AIE)mid0702a, (AIE)mid0702b
  835. SELECTED PASSING METHODS:  (AIE)mid0703a, (AIE)mid0703b
  836. PASSED BY REFERENCE (DYNAMIC):  (AIE)mid0704a, (AIE)mid0704b
  837.  
  838.  
  839.                                  - 14 -
  840.  
  841. 16.    Are  there  any  restrictions  on  unchecked  conversions?   on
  842. unchecked deallocation?
  843. KNOWN TESTS:
  844. (AdaFair84)lowlev.ada
  845.  
  846. 17.  Will the  compiler  generate  code  to  automatically  trace  the
  847. execution of a statement, group of statements, or module?
  848.  
  849. 18.   Will the compiler generate code to track changes in value of any
  850. variable and print changes?
  851.  
  852. 19.  Will the compiler generate code  to  provide  statistics  on  the
  853. execution time/frequency of usage of any segment of code?
  854.  
  855. 20.   Will  the compiler generate code which will trace the occurrence
  856. of exceptions and the levels at which they are handled?
  857.  
  858. 21.  If representation specifications are implemented, are  there  any
  859. restrictions?  If so, what are they?
  860. KNOWN TESTS:
  861. (AdaFair84)derived.ada
  862.  
  863. 22.  What is the accuracy of the error message positioning?
  864.  
  865. 23.  What is the time consumption for error detection and recovery?
  866.  
  867. 24.  What is the clarity of error messages in terms of the language?
  868. KNOWN TESTS:
  869. (AdaFair84)friend.ada
  870.  
  871. 25.   Will  the  compiler produce an executable object program even if
  872. errors are present?  If so, under what  conditions  and  what  is  the
  873. effect of executing a source statement that contains an error?
  874.  
  875. 26.  Are steps taken to avoid "cascading" of compilation errors?
  876.  
  877. 27.   What  warning  messages  does  the compiler print?  For example,
  878. warning for  ignored  pragmas,  warning  for  an  unusually  expensive
  879. construct,  etc.?   Is  the  user  able  to switch off certain warning
  880. messages?
  881.  
  882. 28.  Can the user control the level of  error  which  will  abort  the
  883. compilation?
  884.  
  885. 29.   Can  the user halt the compilation after some stage, examine the
  886. current state of the compiler output and restart the compiler?
  887.  
  888. 30.  Is the compiler re-entrant?
  889.  
  890. 31.  Does using the debugger, if one  exists,  require  compiling  the
  891. software with a special DEBUG option?
  892.  
  893. 32.   Can  two  or  more  compilations  access  and/or update the same
  894. library simultaneously?  If so, how is consistency maintained?
  895.  
  896. 33.   Can  any  instances  of  erroneous  execution  be  automatically
  897.  
  898.  
  899.                                  - 15 -
  900. detected?  How are such instances handled?
  901.  
  902.  
  903.  
  904.  
  905.  
  906.  
  907.  
  908.  
  909.  
  910.  
  911.  
  912.  
  913.  
  914.  
  915.  
  916.  
  917.  
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927.  
  928.  
  929.  
  930.  
  931.  
  932.  
  933.  
  934.  
  935.  
  936.  
  937.  
  938.  
  939.  
  940.  
  941.  
  942.  
  943.  
  944.  
  945.  
  946.  
  947.  
  948.  
  949.  
  950.  
  951.  
  952.  
  953.  
  954.  
  955.  
  956.  
  957.  
  958.                                  - 16 -
  959.                                REFERENCES
  960.  
  961. 1.  Generic APSE Evaluation Questions, General Dynamics
  962.  
  963. 2.  Ada Integrated Environment (AIE) Test Procedures for the  Compiler
  964. Front-End, Intermetrics, Inc.  (Available through RADC upon completion
  965. of the AIE contract)
  966.  
  967. 3.  AIE Test Procedures for the  Compiler  Middle-Part,  Intermetrics,
  968. Inc.  (Available through RADC upon completion of the AIE contract)
  969.  
  970. 4.   AIE Test Procedures for the Compiler Back-End, Intermetrics, Inc.
  971. (Available through RADC upon completion of the AIE contract)
  972.  
  973. 5.  AIE Test Procedures for the Compiler Subsystem, Intermetrics, Inc.
  974. (Available through RADC upon completion of the AIE contract)
  975.  
  976. 6.  SRI Tests (Available on USC-ECLB<EV-INFORMATION>)
  977.  
  978. 7.  AdaFair 84 Tests (Available on USC-ECLB<EV-INFORMATION>)
  979.  
  980. 8.  World of Ada Tests (Available through AJPO)
  981.  
  982. 9.  Ada-Europe Guidelines for Ada Compiler specification and selection
  983. by J C D Nissen and B A Wichmann  (et  al)  (ACM  Ada  Letters,  July,
  984. August 1983)
  985.  
  986. 10.  Mike Burlakoff, University of Missouri
  987.  
  988. 11.   Requirements  for  Evaluation  and Validation of Ada Programming
  989. Support Environments, Version 1.0, XX XXX XX.
  990.  
  991.  
  992.  
  993. **It is the intent of the E&V Team to eventually make as many tests as
  994. possible available through EV-INFORMATION.
  995.  
  996.  
  997.  
  998.  
  999.  
  1000.  
  1001.  
  1002.  
  1003.  
  1004.  
  1005.  
  1006.  
  1007.  
  1008.  
  1009.  
  1010.  
  1011.  
  1012.  
  1013.  
  1014.  
  1015.  
  1016.  
  1017.                                  - 17 -
  1018.                                APPENDIX A
  1019.  
  1020.  
  1021.                        ADA FAIR '84 TESTS
  1022.  
  1023. ackerman.ada   recursion, procedure calling overhead
  1024. boolvec.ada    time for "AND" operation on boolean vector
  1025. bsearch.ada    generic binary search
  1026. cauchf1.ada    floating point accuracy
  1027. cauchfy.ada    fixed point accuracy
  1028. univ_ar.ada    universal real and integer arithmetic
  1029. cauchun.ada    test universal arithmetic package
  1030. char_dir.ada   time for file operations using DIRECT_IO with characters
  1031. char_pnum.ada  time for file operations using TEXT_IO and
  1032.                ENUMERATION_IO with characters
  1033. char_text.ada  time for file operations using TEXT-IO with characters
  1034. int_dir.ada    time for file operations using DIRECT_IO with integers
  1035. int_text.ada   time for file operations using TEXT_IO with integers
  1036. conprod.ada    tasking performance using buffering task
  1037. derived.ada    inter_conversion of derived types with different
  1038.                representations
  1039. floatvec.ada   time for adding elements of a large floating point
  1040.                vector
  1041. intvec.ada     time to add elements to a large integer vector
  1042. friend.ada     friendliness of compiler - warnings,exceptions
  1043. lowlev.ada     test length of clauses and unchecked conversion
  1044. proccal.ada    time for simple procedure calls with scalar parameters
  1045. qsortpar.ada   compare parallel and sequential sort algorithms
  1046. qsortseq.ada   compare parallel and sequential sort algorithms
  1047. random.ada     random number generation, generate linear congruential
  1048.                sequences
  1049. rendez.ada     time for simple rendezvous
  1050. set.ada        implementation of sets
  1051. shared.ada     tasking to provide shred access to global variables
  1052.  
  1053.  
  1054.  
  1055.  
  1056.  
  1057.  
  1058.  
  1059.  
  1060.  
  1061.  
  1062.  
  1063.  
  1064.  
  1065.  
  1066.  
  1067.  
  1068.  
  1069.  
  1070.  
  1071.  
  1072.  
  1073.  
  1074.  
  1075.  
  1076.                                  - 18 -
  1077.  
  1078.                              AVO TESTS
  1079.  
  1080. ACKER             ackerman function
  1081. AHL               test arithmetic and random number
  1082. AUSSIE            machine arithmetic
  1083. BASEMATH          simulation of base number arithmetic for comparing
  1084. COMP              check assumptions about behavior of computer
  1085.   COMPA           declarations - separate statements and lines
  1086.   COMPB           declarations - one statement and many lines
  1087.   COMPC           assignments - several per line
  1088.   COMPD           assignments - one per line
  1089.   COMPE           alternating comments and assignments - one per line
  1090.   COMPF           comments followed by assignments - one per line
  1091.   COMPG           tests linearity, alternating comments and assignments
  1092.   COMPN           null procedure
  1093.   COMPT           with and use
  1094.   COMPZ           test program - 1 assignment 1 declaration
  1095. MARK              set of benchmarks
  1096.   ADD             simple addition
  1097.   MULT            simple multiplication
  1098.   PUZZLE          move pieces
  1099.   SEARCH          find character string
  1100.   SIEVE           byte prime number benchmark
  1101.   SYNTHETIC       synthetic benchmark
  1102. MATHLIB           elementary math functions
  1103. MATHTEST          test elementary math functions
  1104. KPTOOLS           insulate "software tools" from system dependencies
  1105. FORMATTER         pretty printer system - put code in military standard
  1106. STUBBER           creates package bodies from text
  1107. WORLDOF           set of thirty-nine benchmarks
  1108.   ackerman.r      enumeration types, non-primitive recursion,
  1109.                   speed requirements, space requirements
  1110.   ambiguity.r     overloading, disambiguation, package linkage,
  1111.                   separate compilation
  1112.   dir_body.r      locate, insert, delete, create - item/dictionary
  1113.   dir_spec.r      directory functions - create, delete, change, add,
  1114.                   display, scan
  1115.   dir_util.r      create and manipulate directory using directory
  1116.                   functions
  1117.   eratos.r        iterative statements, basic arrays, speed of
  1118.                   execution
  1119.   float_test.r    floating points with transcendental functions
  1120.   generator.r     separate procedure specifications and body
  1121.                   specifications
  1122.   io_test.r       I/O capabilities
  1123.   item_body.r     get, display item
  1124.   item_spec.r     get, display, compare items
  1125.   1f_disk_80.tex  disk functions
  1126.   1f_pgmap.text   page functions
  1127.   list_body.r     generics, private types, pragmas, exceptions
  1128.   list_test.r     generics, overloading, private types, pragmas,
  1129.                   exceptions
  1130.   manager.r       generics, overloading, private types, pragmas,
  1131.                   exceptions
  1132.   overload.r      ambiguous overloading of "+"
  1133.   resolution.r    overloading
  1134.  
  1135.  
  1136.                                  - 19 -
  1137.   roman.r         overloading, disambiguation, with Roman_Numerals
  1138.                   package
  1139.   roman_body.r    overloading, disambiguation, with Roman_Numerals
  1140.                   package
  1141.   sieve_body.r    body of sieve task
  1142.   sieve_task.r    solve sieve of Erotothenes problems using tasking
  1143.   stinger.r       basic string operations
  1144.   timing.r        timing functions
  1145.   tower.r         records, discriminants, non-primitive recursion,
  1146.                   execution speed
  1147.   tran_body.r     body of transcendental functions using iteration
  1148.   tran_spec.r     number crunching abilities
  1149. juggling1.r       tasking, entry calls, exceptions, subunits,
  1150.                   single compilation of multiple units
  1151.   e_ball_1.r      tasking, subunits
  1152.   1_hand_1.r      tasking, subunits
  1153.   o_ball_1.r      tasking, subunits
  1154.   r_hand_1.r      tasking, subunits
  1155. juggling2.r       tasking, selective waits, families of entries,
  1156.                   exceptions, subunits, separate compilations
  1157.   counter.r       same as juggling2.r
  1158.   even_ball.r     same as juggling2.r
  1159.   get_jug.r       same as juggling2.r
  1160.   left_hand.r     same as juggling2.r
  1161.   monitor.r       same as juggling2.r
  1162.   odd_ball_1.r    same as juggling2.r
  1163.   print_pos.r     same as juggling2.r
  1164.   right_hand.r    same as juggling2.r
  1165.  
  1166.  
  1167.  
  1168.  
  1169.  
  1170.  
  1171.  
  1172.  
  1173.  
  1174.  
  1175.  
  1176.  
  1177.  
  1178.  
  1179.  
  1180.  
  1181.  
  1182.  
  1183.  
  1184.  
  1185.  
  1186.  
  1187.  
  1188.  
  1189.  
  1190.  
  1191.  
  1192.  
  1193.  
  1194.  
  1195.                                  - 20 -
  1196.  
  1197.                           SRI TESTS
  1198.  
  1199. ALL TESTS ARE ADA TASKING TESTERS
  1200.  
  1201. DETERMINE OVERHEAD IN CONTEXTS SWITCHES BETWEEN TASKS
  1202.   chain2   with chain length of two
  1203.   chain5   with chain length of five
  1204.   chain10  with chain length of ten
  1205.   chain20  with chain length of twenty
  1206. DETERMINE IF GUARDS ON ENTRY STATEMENTS IMPACT PERFORMANCE
  1207.   guard2     with one guard set to true and one set to false
  1208.   guard20    with one guard set to true and nineteen set to false
  1209.   guard20e   with one guard set to true and nineteen set to false
  1210.   guard20et  with all guards set to true
  1211.   guards20t  with all guards set to true
  1212.   guards2e   with one guard set to true and one set to false
  1213. DETERMINE WHETHER IDLE TASKS IMPACT PERFORMANCE
  1214.   idle1    with one idle task
  1215.   idle5    with five idle tasks
  1216.   idle10   with 10 idle tasks
  1217.   idle20   with twenty idle tasks
  1218. DETERMINE IF IT IS BETTER TO HAVE LOTS OF LITTLE TASKS WITH SINGLE
  1219. ENTRY CHOICES OR A FEW BIG TASKS WITH MANY SELECT CHOICES
  1220.   moretasks   master task calls twenty slave tasks with single entries
  1221.   moretasks1  each task has a single entry embedded in a select
  1222.               statement
  1223.   moreselct   master task calls each entry in a single slave task
  1224.   moreselctr  entries are listed in opposite order from calling order
  1225. DETERMINE IF ORDERING OF ENTRY CLAUSES IN A SELECT MATTERS
  1226.   order31   with thirty-one choices
  1227.   order31r  entries are called in reverse order of select statement
  1228.   order32   with thirty-two choices
  1229.   order100  with one hundred choices
  1230. DETERMINE IF SIZE OF PASSED PARAMETER MAKES A DIFFERENCE
  1231.   passarrys  with small "in" array of integers
  1232.   passarryb  with larger "in" array of integers
  1233.   passinout  with large "in out" array of integers
  1234. DETERMINE IF THE NUMBER OF SELECT CHOICES MAKES A DIFFERENCE
  1235.   select2    with two choices, desired entry is first
  1236.   select2e   with two choices, desired entry is last
  1237.   select20   with twenty choices, desired choice is first
  1238.   select20e  with twenty choices, desired choice is last
  1239. DETERMINE IF ADA SCHEDULER MAY STARVE A TASK
  1240.   schedtest  with two entry select statements used independently by
  1241.              three other tasks
  1242.  
  1243.  
  1244.  
  1245.  
  1246.  
  1247.  
  1248.  
  1249.  
  1250.  
  1251.  
  1252.  
  1253.  
  1254.                                  - 21 -
  1255.  
  1256.                       AIE FRONT END TESTS
  1257.  
  1258.   SYNTAX ERRORS
  1259.     (AIE)fen0301a checks frequent comment syntax mistakes
  1260.     (AIE)fen0302a checks miscellaneous common spelling mistakes
  1261.     (AIE)fen0303a checks common Ada/Pascal errors
  1262.     (AIE)fen0304a checks common errors in subprogram specifications
  1263.     (AIE)fen0305a checks common errors in subprogram declarations
  1264.   COMPILER OPTIONS
  1265.     (AIE)fen0501a verifies that default options are as specified
  1266.     (AIE)fen0502a verifies that specified options take on the given
  1267.                   values
  1268.     (AIE)fen0503a checks the NOSEM option
  1269.     (AIE)fen0503b checks the NOSEM option
  1270.     (AIE)fen0503c checks the NOSEM option
  1271.     (AIE)fen0503d checks the NOSEM option
  1272.     (AIE)fen0503e checks the NOSEM option
  1273.     (AIE)fen0503f checks the NOSEM option
  1274.     (AIE)fen0504a checks the NOCODE option
  1275.     (AIE)fen0504b checks the NOCODE option
  1276.     (AIE)fen0504c checks the NOCODE option
  1277.     (AIE)fen0504d checks the NOCODE option
  1278.     (AIE)fen0504e checks the NOCODE option
  1279.     (AIE)fen0504f checks the NOCODE option
  1280.     (AIE)fen0505a checks the COMMENT option
  1281.     (AIE)fen0505b checks the COMMENT option
  1282.     (AIE)fen0506a checks the LOOKAHEAD option
  1283.     (AIE)fen0506b checks the LOOKAHEAD option
  1284.     (AIE)fen0506c checks the LOOKAHEAD option
  1285.     (AIE)fen0506d checks the LOOKAHEAD option
  1286.   CHECK CORRECT MEANING OF DOT "." AND TIC "'"
  1287.     (AIE)fen0701a verify dot as a delimiter in numeric range
  1288.     (AIE)fen0701b verify dot as part of a numeric literal
  1289.     (AIE)fen0701c verify tic in attribute selection
  1290.     (AIE)fen0701d verify tic in type qualification
  1291.     (AIE)fen0701e verify tic in character literal
  1292.   CHECK HIDING
  1293.     (AIE)fen0702a by nested blocks
  1294.     (AIE)fen0702b by loop parameters
  1295.     (AIE)fen0702c by nested packages
  1296.     (AIE)fen0702d using the extended scope of a pkg spec through its
  1297.                   corresponding body
  1298.     (AIE)fen0702e with nested (non-overloaded subprograms
  1299.     (AIE)fen0702f within a record type declaration
  1300.     (AIE)fen0702g by an object renaming declaration
  1301.     (AIE)fen0702h by nesting a subprogram declaration
  1302.     (AIE)fen0702i by a formal parameter of nested subprogram
  1303.                   declaration
  1304.     (AIE)fen0702j by nesting a task definition
  1305.     (AIE)fen0702k of an object by a subprogram declaration with the
  1306.                   same identifier
  1307.     (AIE)fen0702l checks hiding of a predefined type from STANDARD
  1308.   CHECKS OVERLOADING ENTITIES
  1309.     (AIE)fen0703a using a procedure and a function
  1310.     (AIE)fen0703b using procedures with different numbers of parameters
  1311.     (AIE)fen0703c using functions with different numbers of parameters
  1312.  
  1313.  
  1314.                                  - 22 -
  1315.     (AIE)fen0703d using procedures with different base types of
  1316.                   parameters
  1317.     (AIE)fen0703e using functions with different base types of
  1318.                   parameters
  1319.     (AIE)fen0703f using functions with different return base types
  1320.     (AIE)fen0703g using procedures with differently ordered parameters
  1321.     (AIE)fen0703h overloading an operator
  1322.   CHECKS USE CLAUSES
  1323.     (AIE)fen0704a using two nested packages, one which is USEd
  1324.     (AIE)fen0704b using nested package which has an identifier that
  1325.                   should not hide a directly visible identifier
  1326.     (AIE)fen0704c using nested packages with dot selection
  1327.     (AIE)fen0704d using separately compiled pkgs using WITH and USE
  1328.   CHECKS VERY LARGE SOURCE LINES
  1329.     (AIE)fen0801a verifies line length of 255 allowed
  1330.     (AIE)fen0801b verifies line length of >255 flagged
  1331.   CHECKS LARGE NUMBERS OF VMM SUBDOMAINS
  1332.     (AIE)fen0803a opens 198 subdomains using a WITH chain 197 units
  1333.     (AIE)fen0803b opens 199 subdomains using a WITH chain 198 units
  1334.     (AIE)fen0803c opens 200 subdomains using a WITH chain 199 units
  1335.     (AIE)fen0803d opens 199 subdomains using a WITH chain 196 units
  1336.                   with 2 nested units
  1337.     (AIE)fen0803e opens 200 subdomains using a WITH chain 197 units
  1338.                   with an indirect WITH and a subunit
  1339.   CHECK OVERFLOW OF PARSE STACK OR STATE STACK OF THE PARSER
  1340.     (AIE)fen0804a using nested block statements level 5
  1341.     (AIE)fen0804b using nested block statements level 10
  1342.     (AIE)fen0804c using nested block statements level 15
  1343.     (AIE)fen0805a using nested loop statements level 5
  1344.     (AIE)fen0805b using nested loop statements level 10
  1345.     (AIE)fen0805c using nested loop statements level 15
  1346.     (AIE)fen0806a using nested if statements level 5
  1347.     (AIE)fen0806b using nested if statements level 10
  1348.     (AIE)fen0806c using nested if statements level 15
  1349.     (AIE)fen0807a using nested package statements level 5
  1350.     (AIE)fen0807b using nested package statements level 10
  1351.     (AIE)fen0807c using nested package statements level 15
  1352.     (AIE)fen0808a using nested subprogram statements level 5
  1353.     (AIE)fen0808b using nested subprogram statements level 10
  1354.     (AIE)fen0808c using nested subprogram statements level 15
  1355.     (AIE)fen0809a using WITH, USE, variable decls, arithmetic and
  1356.                   logical expressions which are not quickly resolvable
  1357.  
  1358.  
  1359.  
  1360.  
  1361.  
  1362.  
  1363.  
  1364.  
  1365.  
  1366.  
  1367.  
  1368.  
  1369.  
  1370.  
  1371.  
  1372.  
  1373.                                  - 23 -
  1374.  
  1375.                        AIE MIDDLE PART TESTS
  1376.  
  1377.   CHECKS GENERIC INSTANTIATIONS
  1378.     (AIE)mid0301a verify Diana is not modified if no generic
  1379.                   instantiation
  1380.     (AIE)mid0302a verify instance body created for instantiation is
  1381.                   correct Diana
  1382.   CHECK GENERICS COMPILED AT DIFFERENT TIMES IN VARIOUS ORDERS
  1383.     (AIE)mid0303a generic procedure declaration, body and
  1384.                   instantiation (single compilation)
  1385.     (AIE)mid0303b generic procedure declaration, instantiation, and
  1386.                   body (single compilation)
  1387.     (AIE)mid0303c generic procedure declaration, body and
  1388.                   instantiation (separate compilation)
  1389.     (AIE)mid0303d generic procedure declaration, instantiation and
  1390.                   body (separate compilation)
  1391.     (AIE)mid0303e generic procedure declaration, its package body
  1392.                   containing the body and an instantiation - main
  1393.                   proc using the instantiation (separate compilation)
  1394.     (AIE)mid0303f generic procedure declaration, its package body
  1395.                   containing the generic body stub and an
  1396.                   instantiation, the generic body subunit (main proc
  1397.                   using the instantiation)(separate compilation)
  1398.     (AIE)mid0304a generic package declaration, body and instantiation
  1399.                   (single compilation)
  1400.     (AIE)mid0304b generic package declaration, instantiation, and body
  1401.                   (single compilation)
  1402.     (AIE)mid0304c generic package declaration, body and instantiation
  1403.                   (separate compilation)
  1404.     (AIE)mid0304d generic package declaration, instantiation and body
  1405.                   (separate compilation)
  1406.     (AIE)mid0304e generic package declaration, its package body
  1407.                   containing the body and an instantiation - main proc
  1408.                   using the instantiation (separate compilation)
  1409.     (AIE)mid0304f generic procedure declaration, its package body
  1410.                   containing the generic body stub and an
  1411.                   instantiation, the generic body subunit (main proc
  1412.                   using the instantiation)(separate compilation)
  1413.     (AIE)mid0305a generic procedure declaration, instantiation, and
  1414.                   main procedure (single compilation)
  1415.     (AIE)mid0305b generic package declaration, instantiation and main
  1416.                   procedure (separate compilation)
  1417.     (AIE)mid0306a generic package declaration, instantiation, and main
  1418.                   procedure (single compilation)
  1419.     (AIE)mid0306b generic package declaration, instantiation and main
  1420.                   procedure (separate compilation)
  1421.   CHECK SHARING OF GENERIC BODY INSTANTIATION REPRESENTATIONS
  1422.     (AIE)mid0307a check that 'in' actual parameters match
  1423.     (AIE)mid0308a check that 'in out' actual parameters match
  1424.     (AIE)mid0309a check that integer type actual parameters match
  1425.     (AIE)mid0310a check that floating point type actual parameters
  1426.                   match (verifies when they have the same amount of
  1427.                   storage)
  1428.     (AIE)mid0310b check that floating point type actual parameters
  1429.                   match (verifies if they have identical rep specs)
  1430.     (AIE)mid0311a check that fixed point type actual parameters match
  1431.  
  1432.  
  1433.                                  - 24 -
  1434.                   (verifies when they have the same amount of storage)
  1435.     (AIE)mid0311b check that fixed point type actual parameters match
  1436.                   (verifies if they have identical rep specs)
  1437.     (AIE)mid0312a check that discrete type actual parameters match
  1438.                   (verifies when they have the same amount of storage)
  1439.     (AIE)mid0312b check that discrete type actual parameters match
  1440.                   (verifies if they have identical rep specs)
  1441.     (AIE)mid0313a check that access type actual parameters match
  1442.   CHECK CROSS REFERENCE INFORMATION TO si_refs ATTRIBUTE OF DEF_IDs
  1443.     (AIE)mid0401a which are subtypes, types, and variables
  1444.     (AIE)mid0401b verify no information is added when LIST => NOXREF
  1445.     (AIE)mid0401c which are procedures, functions, operators,                    subprogram parameters
  1446.     (AIE)mid0401d which are labels and packages
  1447.     (AIE)mid0401e verifies references are not included from uses in
  1448.                   other units
  1449.     (AIE)mid0401f when LIST => XREF
  1450.   CHECK CROSS REFERENCE INFORMATION TO si_calls ATTRIBUTE OF DEF_IDs
  1451.     (AIE)mid0402a when subprograms invoked from within subprograms
  1452.     (AIE)mid0402b check no information is added when LIST => NOXREF
  1453.     (AIE)mid0402c when subprograms and operations invoked within
  1454.                   subprograms, operations and packages
  1455.     (AIE)mid0402d when invocations from a package specification and
  1456.                   body
  1457.   CHECK ACROSS REFERENCE INFORMATION TO si_external_refs ATTRIBUTE OF
  1458.     A COMPILATION UNIT NODE
  1459.     (AIE)mid0403a using a procedure compilation unit
  1460.     (AIE)mid0403b verify not si_external refs added if LIST => NOXREF
  1461.     (AIE)mid0403c using package compilation units
  1462.     (AIE)mid0403d using subunit compilation unit
  1463.     (AIE)mid0403e using a function body compilation unit
  1464.     (AIE)mid0403f using a procedure specification compilation unit
  1465.   CHECK CROSS REFERENCE INFORMATION TO si_global_refs ATTRIBUTE OF A
  1466.     BLOCK OR BODY NODE
  1467.     (AIE)mid0404a using a procedure body
  1468.     (AIE)mid0404b verify no information idded if LIST => NOXREF
  1469.     (AIE)mid0404c using a function body
  1470.     (AIE)mid0404d using a block statement
  1471.     (AIE)mid0404e using a package specification and body
  1472.   VERIFY VALUE GIVEN TO THE si_labeled ATTRIBUTE OF STATEMENTS
  1473.     (AIE)mid0405a using assignment, goto and null statements
  1474.     (AIE)mid0405b using if, loop and exit statements
  1475.     (AIE)mid0405c using block and case statements
  1476.     (AIE)mid0405d using procedure calls and return statements
  1477.   VERIFY VALUE GIVEN TO THE si_context ATTRIBUTE OF NAME_EXP NODES
  1478.     (AIE)mid0406a those that should receive ADDRESS_CONTEXT value
  1479.     (AIE)mid0406b those that should receive FLOW_CONTEXT value
  1480.     (AIE)mid0406c those that should receive PARAMETER_CONTEXT value
  1481.     (AIE)mid0406d those that should receive VALUE_CONTEXT value
  1482.   VERIFY VALUE GIVEN TO THE si_opt_level ATTRIBUTE OF A BODY OR BLOCK
  1483.     (AIE)mid0501a using procedure body without a pragma
  1484.                   (OPTIMIZE=>NONE)
  1485.     (AIE)mid0501b using procedure body without a pragma
  1486.                   (OPTIMIZE=>TIME)
  1487.     (AIE)mid0501c using procedure body without a pragma
  1488.                   (OPTIMIZE=>SPACE)
  1489.     (AIE)mid0502a using procedure body with pragma OPTIMIZE(SPACE)
  1490.                   (OPTIMIZE=>TIME)
  1491.  
  1492.  
  1493.                                  - 25 -
  1494.     (AIE)mid0502b using block statement with nested pragmas
  1495.                   OPTIMIZE(SPACE) and OPTIMIZE(TIME)
  1496.                   (OPTIMIZE => NONE)
  1497.     (AIE)mid0502c using package spec and body with pragma
  1498.                   OPTIMIZE(TIME) (OPTIMIZE=>SPACE)
  1499.     (AIE)mid0502d using nested block statements with pragma
  1500.                   OPTIMIZE(SPACE) (OPTIMIZE=>NONE)
  1501.   CHECK IMPROPER USES OF PRAGMA OPTIMIZE
  1502.     (AIE)mid0503a using second pragma OPTIMIZE in a declarative part
  1503.                   (OPTIMIZE=>NONE)
  1504.     (AIE)mid0503b pragma OPTIMIZE cannot be placed in package
  1505.                   specification
  1506.   VERIFY THE AIE DEFINED PRAGMA STATIC
  1507.     (AIE)mid0504a verify call frame for each of subprogram arguments
  1508.                   is allocated static storage
  1509.     (AIE)mid0504b verify error when there is dynamically sized local
  1510.   VERIFY PRAGMA INLINE
  1511.     (AIE)mid0505a verifies subprogram bodies are expanded inline
  1512.   VERIFY DECISIONS MADE WHEN CHOOSING A LAYOUT REPRESENTATION FOR
  1513.     STORAGE
  1514.     (AIE)mid0601a predefined type INTEGER given a layout of one word
  1515.     (AIE)mid0601b predefined type SMALL_INTEGER given a layout of
  1516.                   1/2 word
  1517.     (AIE)mid0601c verify user defined integer types given smallest
  1518.                   layout
  1519.     (AIE)mid0602a predefined type FLOAT is represented as single word
  1520.     (AIE)mid0602b predefined type LONG_FLOAT is represented as single
  1521.                   word
  1522.     (AIE)mid0602c user defined floating point types are given smallest
  1523.                   layout
  1524.     (AIE)mid0602d error issued when accuracy requested is too precise
  1525.                   for implementation
  1526.     (AIE)mid0603a fixed point types represented as single word
  1527.     (AIE)mid0603b or issued when accuracy requested is too precise for
  1528.                       implementation
  1529.     (AIE)mid0604a object represented with 3 bits is given 3 bits in
  1530.                   packed record
  1531.     (AIE)mid0604b object represented with 3 bits is given a byte in an
  1532.                   unpacked array
  1533.     (AIE)mid0604c object represented with 3 bits is given 1/2 word as
  1534.                   a local ojbect to a subprogram
  1535.     (AIE)mid0605a statically sized components are stored in the
  1536.                   beginning of record and dynamically sized components
  1537.                   at end with pointer from beginning
  1538.     (AIE)mid0606a representations are as small as possible in packed
  1539.                   array
  1540.     (AIE)mid0606b representations are expanded to byte to ease
  1541.                   addressing in unpacked array
  1542.     (AIE)mid0607a storage for variant parts of records is overlaid
  1543.     (AIE)mid0607b storage for disjoint blocks within subpgm bodies is
  1544.                   overlayed
  1545.     (AIE)mid0608a verify allocation on secondary stack for dynamic
  1546.                   sized arrays not in records
  1547.     (AIE)mid0609a checks length clauses for numeric type (rep specs)
  1548.     (AIE)mid0609b checks length clauses for access type  (rep specs)
  1549.     (AIE)mid0609c checks length cluases for task type (rep specs)
  1550.     (AIE)mid0610a checks record rep clause that specifies the packing
  1551.  
  1552.  
  1553.                                  - 26 -
  1554.                   in 2 words
  1555.   VERIFY STATICALLY SIZED OBJECTS SIZED <= 64 BITS ARE USED AS FORMAL
  1556.     PARAMS - ACTUALS PASSED BY VALUE
  1557.     (AIE)mid0701a checks parameters of procedures
  1558.     (AIE)mid0701b checks parameters and return values of functions
  1559.   VERIFY STATICALLY SIZED OBJECTS SIZED >= 64 BITS ARE USED AS FORMAL
  1560.     PARAMS - ACTUALS PASSED BY VALUE
  1561.     (AIE)mid0702a checks parameters of procedures
  1562.     (AIE)mid0702b checks parameters and return values of functions
  1563.   VERIFY CORRECT PARAMETER PASSING METHODS ARE SELECTED
  1564.     (AIE)mid0703a checks parameters of procedures
  1565.     (AIE)mid0703b checks parameters and return values of functions
  1566.   VERIFY DYNAMICALLY SIZED OBJECTS USED AS FORMAL PARAMS PASSED BY
  1567.     REFERENCE
  1568.     (AIE)mid0704a checks parameters of procedures
  1569.     (AIE)mid0704b checks parameters and return values of functions
  1570.  
  1571.  
  1572.  
  1573.  
  1574.  
  1575.  
  1576.  
  1577.  
  1578.  
  1579.  
  1580.  
  1581.  
  1582.  
  1583.  
  1584.  
  1585.  
  1586.  
  1587.  
  1588.  
  1589.  
  1590.  
  1591.  
  1592.  
  1593.  
  1594.  
  1595.  
  1596.  
  1597.  
  1598.  
  1599.  
  1600.  
  1601.  
  1602.  
  1603.  
  1604.  
  1605.  
  1606.  
  1607.  
  1608.  
  1609.  
  1610.  
  1611.  
  1612.                                  - 27 -
  1613.  
  1614.                       AIE BACK-END TESTS
  1615.  
  1616. CHECK COMPILER OPTIONS
  1617.   ben0101a  verify memory size with OPTIMIZE => SPACE
  1618.   ben0102a  verify cpu time with OPTIMIZE => TIME
  1619.   ben0201a  check FLOW with OPTIMIZE => NONE
  1620.   ben0202a  check strength reduction and code motion when OPTIMIZE =>
  1621.             SPACE
  1622.  
  1623. CHECK FLOW AND WALKS OF BILL TREE
  1624.   ben0203a  with LOOP and no subprogram calls
  1625.   beno2o3b  with GOTO and no loops or subprogram calls
  1626.   beno203c  strength reduction unit processing
  1627.   ben0203d  with subprogram call and INLINE pragma
  1628.   ben0203e  with subprogram call, subprogram defined in program
  1629.   ben0203f  with subprogram call, subprogram declared in package
  1630.   ben0203g  with subprogram call, subprogram in library unit
  1631.   ben0203h  with subprogram call, recursive subprogram in program
  1632.   ben0203i  with subprogram call, recursive subprogram in package
  1633.   ben0203j  with subprogram call, recursive subprogram in library
  1634.   ben0203k  with GOTO, no loops or subprograms, detection of common
  1635.             subexpressions
  1636.   ben0204a  with units eligible for strength reduction when
  1637.             OPTIMIZE => TIME
  1638.   ben0205a  with straightline program
  1639.  
  1640. CHECK CONSTANT PRAPAGATION WITH EXPRESSION SIMPLIFICATION
  1641.   ben0301a  when constant is a named number
  1642.   ben0301b  when constant is a true constant
  1643.  
  1644. CHECK FOLDING IMPLEMENTATION BY FLOW
  1645.   ben0302a  where expression has binary operation and integer operands
  1646.   ben0302b  where expression has unary operation and integer operands
  1647.   ben0302c  where expression has deeply nested unary operations
  1648.   ben0302d  where boolean expression has unary or binary operations
  1649.             and boolean operands
  1650.   ben0302e  where constants are adjacent and where they are dispersed
  1651.  
  1652. CHECK TREATMENT OF EXPRESSIONS AS COMMON SUBEXPRESSIONS
  1653.   ben0303a  with binary expressions and no change of any variable
  1654.   ben0303b  with binary expressions and a change of some variable
  1655.   ben0303c  with components of an array
  1656.   ben0303d  with binary expressions, variable changed in IF and CASE
  1657.   ben0303e  with subexpresions permuted or muddled by parentheses
  1658.   ben0303f  with array offset
  1659.   ben0303g  with array offset and value assigned object
  1660.   ben0303h  with arguments to subtype conversion functions
  1661.   ben0303i  with arguements to type conversion functions
  1662.   ben0303j  with labelled statement to GOTO
  1663.   ben0303k  with labelled statement with no GOTO
  1664.   ben0303l  with nested levels of declaration of subexpressions
  1665.   ben0303m  with record components
  1666.  
  1667. CHECK EXPRESSION SIMPLIFICATION
  1668.   ben0304a  with integer , no side effect as a sub_operand
  1669.   ben0304b  with integer, with side effect as an operand
  1670.  
  1671.  
  1672.                                  - 28 -
  1673.   ben0304c  with floating point, with side effect as an sub_operand
  1674.   ben0304d  with floating point,  no side effect as a sub_operand
  1675.   ben0304e  with boolean, no side effect as a sub_operand
  1676.   ben0304f  with boolean, with side effect as a sub_operand
  1677.   ben0304g  with cancelling of subexpressions
  1678.  
  1679. CHECK STRENGTH REDUCTION
  1680.   ben0401a  with FOR loop
  1681.   ben0401b  with FOR loop, elements not in usual arrangement
  1682.   ben0402a  with invariant code movement
  1683.  
  1684. CHECK RANGE INFORMATION AND UNNECESSARY CONSTRAINT CHECKS
  1685.   ben0501a  at END IF statement
  1686.   ben0501b  at END CASE statement
  1687.   ben0501c  with BACK END check range information
  1688.   ben0501d  with BACK END check access checks
  1689.  
  1690. CHECK REMOVAL OF UNREACHABLE CODE
  1691.   ben0502a  by FINAL with 'if-else-then' with constant propagation
  1692.   ben0502b  by FINAL with 'if-else-then' with range information
  1693.   ben0502c  by FLOW with LOOPS, condition always false or range null
  1694.   ben0502d  by FINAL with CASE, with constant propagation
  1695.   ben0502e  with GOTO
  1696.   ben0502f  between RAISE, with unhandled exception
  1697.   ben0502g  between RAISE, with handled exception
  1698.   ben0502h  by FLOW in CASE, where alternative chosen by null range
  1699.   ben0502i  by FLOW in CASE, don't need OTHERS choice
  1700.   ben0503a  nested GOTOs changed to one GOTO
  1701.  
  1702. CHECK "CROSS-JUMPING" WITH COMPILER OPTION, OPTIMIZE => SPACE
  1703.   ben0504a  at end of THEN, ELSE
  1704.   ben0504b  at end of THEN, ELSIF, ELSE
  1705.   ben0504c  at end of CASE
  1706.   ben0504d  at end of CASE where several sets of duplicate code
  1707.   ben0504e  at end of THEN, ELSE where code semantically the same
  1708.  
  1709. CHECK PRAGMA INLINE SUBPROGRAM
  1710.   ben0505a  instead of compilation unit
  1711.   ben0505b  in declaration of space optimized subprograms
  1712.  
  1713. CHECK BACK END USE OF LOCAL SPILL
  1714.   ben0601a  with integer expression that requires 16-plus registers
  1715.   ben0601b  with floating . expression that requires 4-plus registers
  1716.   ben0601c  with complex expression that requires 16-plus registers
  1717.   ben0602a  with simple expression
  1718.  
  1719. CHECK COMPILER BACK END LIMITATIONS
  1720.   ben0701a  verify speed of compilation
  1721.   ben0702a  verify size of compiler
  1722.   ben0703a  verify maximum size of BILL node
  1723.  
  1724.  
  1725.  
  1726.  
  1727.  
  1728.  
  1729.  
  1730.  
  1731.                                  - 29 -
  1732.  
  1733.