AD-A273 785 ATION PAGE FormA~wve

RA PO IK ftU WI MU" hma u tbna the wme 1w awwm. wwwaww *awa"G"

mll215J.llews- D-ws -ig-"1204".--n..ManegeflqwE m ,• uqd W-h~ntulon. DC 20M.

$ 1AGNC US (eae 2. REPORT 3.REPORT TYPE AND DATES

4. TITLE AND 5. FUNDINGVADS Sun4 =) PARAGOIfVAda-110-40782, Version 6.2, Host: SunSPARCstation 2 , Target: Intel PARAGON Supercomputer, OSF/1Release 1.0.3 Server 1.1 PT10.7.6(T1O.4), 930901W1.11325

6.

Authors:

Wright-Patterson AFB7. PERFORMING ORGANIZATION NAME(S) AND 8. PERFORMING

Ada Validating Facility, Language Control Facility ASD/SCEL ORGANIZATIONBldg. 676, Room 135Wright Patterson AFB, Dayton OH 45433

9. SPONSORING/MONITORING AGENCY NAME(S) AND 10. SPONSORING'MIONITORING

Ada Joint Program Office AGENCY

The Pentagon, Fim 3E118Washington, DC 20301-3080

11. SUPPLEMENTARY

12a. DISTRIBUTION/AVAILABILITY 12b. DISTRIBUTIONApproved for public release; distribution unlimited

13. (Maximum 200

VADS Sun 4 =) PARAGON/VAda-110-40782, Version 6.2 , Host: Sun SPARCstation 2Target: Intel PARAGON Sumpercomputer, OSF/1 Release 1.0.3, Server 1.1 PT1O.7.6(TIO.4)ACVC 1.11

SDEC 14 19g

14. SUBJECT 15. NUMBER OF

Ada programming language, Ada Compiler Val. Summary Report, Ada Comp 16. PRICE

I/MIL-S2 !•AtYAjI. Testing, Ada Val. Office, Ada Val. Facili y17. SECURITY 18. SECURITY I 19. SECURITY 20, LIMITATION OFCLASSIFICATIONEU S C.AESIFICATIONUNCLASSIFIED I UNCLASSIFIED UNCLASSIFIED UNCLASSIFIED•NN Slandard Form 208, (Rev. 2

Presilbed by ANSI St:.

AVF Control Nuwber: AW-VSR-572.0893Date VSR Completed: September 28, 1993

93-07-23-VRX

Ada COMPILERVALIDATION SDMMARY REPORT:

Certificate Number: 930901W1.11325Verdix Corporation

VADS Sun4 -> PAMGCN/VAda-110-40782, Version 6.2Sun SPARCstation 2 under SunOS 4.1.3 ->

Intel PARAGON Supercomputer, OSF/1 Release 1.0.3

(Final)

Prepared By:Ada Validation Facility

645 C CSG/SCSLWright-Patterson AFB OH 45433-6503

93-30267

"93 12 13 085

Certificate Information

The following Ada implementation was tested and determined to pass ACVC1.11. Tmsting was completed on September 1, 1993.

Compiler Name and Version: VADS Sun4 -> pARAGCN/VAda-110-40782, Version 6.2

Host Computer System: Sun SPARCstation 2under SunOS 4.1.3

Target Computer System: Intel PARA(KM4 Supercomputer, OSF/1 Release 1.0.3Server 1.1 PT10.7.6(Tl0.4)

Customwr Agreement Number: 93-07-23-VRX

See section 3.1 for any additional information about the testingenvironment.

As a result of this validation effort, Validation Certificate930901W1.11325 is awarded to Verdix Corporation. This certificate expirestwo years after MIL-STD-1815B is approved by ANSI.

This report has been reviewed and is approved.

Ada Validation FacilityDale E. LangeTechnical Director645 CCSG/SCSLWright-Patterson AFh OH 45433-6503

Ad Wal)Uap Oganization " QA1 J1oEOM3

4 Direcor, C ter adSfware Engineering Division CQA YI 'ED'J Innstiuteg /D1efense Analyses

Alexandria VA 22311t oce~sion For!

Ada Joint Program 0 ce Unenrrou. -ed I]M. Dirk Rogers, Major, USAF Ju.; _.cationActing DirectorDepartment of Defense By-Washington DC 20301 Distribution/

Av7il.bilit7 Codes

Avai'. and/or

Dist !:PIVa1

ATTACHMENT I

DECLARATION OF CONFORMANCE

Customer. Verdix Corporation

Ada Validation Facility: ASD/SCEL, WPAFB OH 45433-6503

ACVC Version: 1.11

Ada Implementation:

Compiler N&ne and Version: VADS Sun4 => PARAGON, Version 6.2,VAda- 110-40782

Host Computer System: Sun SPARCstation 2, SunOS 4.1.3

Target Computer System: Intel PARAGON Supercomputer,OSF/1 Release 1.0.3 Server 1.1 PT1O.7.6(TIO.4)

Customer's Declaration:

[I/we], the undersigned. declare that [I/we] have noknowledge of deliberate deviations from the Ada LanguageStandard ANSI/MIL-STD-1815A in the implementationlisted above.

Customer Signature I Date

TABLE OF CONTENTS

CIAPTER 1 niH'I0cTioN

1.1 USE OF THIS VALIATICN SUMMARY REPORT . . . . . . . 1-11.2 REFERENCES. .. .................. 1-21. 3 ACVC TEST CLASSES . ................ 1-21.4 DEFINITION OF TERS ............... . . 1-3

CHAPTER 2 IMP? LVINTTIN DEPEDENCIES

2.1 WITHMI4 TESTS . . ................ 2-12.2 INAPPLICABLE TESTS . ............... 2-12.3 TEST IfDIFICATIONS ........ ................. .. 2-4

CHAPTER 3 PnocEsSIN INFODBMUN

3.1 TESTING ENVI IENT . .............. 3-13.2 SLUMARY OF TEST RESULTS ................ . 3-13.3 TEST EXECUTION. ........... ................... 3-2

APPENDIX A MACRO PARAMETERS

APPEDDIX B COMPILATION SYSTEM OPTIONS

APPENDIX C APPED4IX F OF THE Ada STANDARD

OIAPTnR 1

XIN1AWCTICZ4

The Ada implementation described above was tested according to the AdaValidation Procedures [Pro90] against the Ada Standard ([da83] using thecurrent Ada Compiler Validation Capability (ACVC). This Validation StuaryReport (VSR) gives an account of the testing of this Aa implementation.For any technical terms used in this report, the reader is referred to(Pro90]. A detailed description of the ACVC may be found in the currentACVC User's Guide [UG89].

1.1 USE OF THIS VALIDATICM M REPORT

Consistent with the national laws of the originating country, the AdaCertification Body may make full and free public disclosure of this report.In the United States, this is provided in accordance with the "Freedom ofInformation Act" (5 U.S.C. #552). The results of this validation applyonly to the computers, operating systems, and compiler versions identifiedin this report.

The organizations represented on the signature page of this report do notrepresent or warrant that all statements set forth in this report areaccurate and complete, or that the subject implementation has nononconformities to the Ada Standard other than those presented. Copies ofthis report are available to the public from the AVF which performed thisvalidation or from:

National Technical Information Service5285 Port Royal RoadSpringfield VA 22161

Questions regarding this report or the validation test results should bedirected to the AVF which performed this validation or to:

Ada Validation OrganizationComputer and Software Engineering DivisionInstitute for Defense Analyses1801 North Beauregard StreetAlexandria VA 22311-1772

1-1

1.2 REFERENE

WIhaB3] Reference Manual for the Ada Programming Language,ANSI/AL,-STD-1815A, February 1983 and ISO 8652-1987.

Pro Ada Compiler validation Procedures, Version 2.1, Ada JointProgram Otrice, Augjust 1990.

tUG891 Ada Compiler Validation Capability User's Guide, 21 June 1989.

1.3 ACVC TES CLASSES

Compliance of Ada implementations is tested by means of the ACVC. The ACvccontains a collection of test programs structured into six test classes: A,B, C, D, E, and L. The first letter of a test name identifies the class towhich it belongs. Class A, C, D, and E tests are executable. Class B andclass L tests are expected to produce errors at compile time and link time,respectively.

The executable tests are written in a self-checking manner and produce aPASSED, FAILED, or NOT APPLICABLE message indicating the result when theyare executed. Three Ada library units, the packages REPORT and SPPRT13,and the procedure CHECK FILE are used for this purpose. The package REPORTalso provides a set of Tdentity functions used to defeat some compileroptimizations allowed by the Aaa Standard that would circmvent a testobjective. The package SPPRT13 is used by many tests for Chapter 13 of theAda Standard. The procedure CHECK FILE is used to check the contents oftext files written by some of the Class C tests for Chapter 14 of the AdaStandard. The operation of REPORT and CHECK FILE is checked by a set ofexecutable tests. If these units are not operating correctly, validationtesting is discontinued.

Class B tests check that a compiler detects illegal language usage. ClassB tests are not executable. Each test in this class is compiled and theresulting compilation listing is examined to verify that all violations ofthe Ada Standard are detected. Some of the class B tests contain legal Adacode which imist not be flagged illegal by the compiler. This behavior isalso verified.

Class L tests check that an Ada implementation correctly detects violationof the Ada Standard involving multiple, separately compiled units. Errorsare expected at link time, and execution is attempted.

In some tests of the ACVC, certain macro strings have to be replaced byimplementation-specific values - for example, the largest integer. A listof the values used for this implementation is provided in Appendix A. Inaddition to these anticipated test modifications, additional changes may berequired to remove unforeseen conflicts between the tests andimplementation-dependent characteristics. The modifications required forthis implementation are described in section 2.3.

1-2

For each Ada implementation, a customized test suite is produced by theAVF. This customization consists of making the modifications described inthe preceding paragraph, removing withdrawn tests (see section 2.1), andpossibly removing some inapplicable tests (see section 2.2 and (UG89]).

In order to pass an ACVC an Ada implementation mast process each test ofthe customized test suite according to the Ada Standard.

1.4 DEFINITION OF TERS

Ada Compiler The software and any needed hardware that have to be addedto a given host and target computer system to allowtransformation of Ada programs into executable form andexecution thereof.

Ada Compiler The means for testing compliance of Ada implementations,Validation consisting of the test suite, the support programs, the ACVCCapability user's guide and the template for the validation summary(ACVC) report.

Ada An Ada compiler with its host computer system and itsImplementation target computer system.

Ada Joint The part of the certification body which provides policy andProgram guidance for the Ada certification system.Office (AJPO)

Ada The part of the certification body which carries out theValidation procedures required to establish the compliance of an AdaFacility (AVF) implementation.

Ada The part of the certification body that provides technicalValidation guidance for operations of the Ada certification system.Organization(AVO)

Compliance of The ability of the implementation to pass an ACVC version.an AdaImplementation

Computer A functional unit, consisting of one or more computers andSystem associated software, that uses common storage for all or

part of a program and also for all or part of the datanecessary for the execution of the program; executesuser-written or user-designated programs; performsuser-designated data manipulation, including arithmeticoperations and logic operations; and that can executeprograms that modify themselves during execution. Acomputer system may be a stand-alone unit or may consist ofseveral inter-connected units.

1-3

INTR~c•IaON

Conformity Fulfillment by a product, process, or service of allrequirements specified.

Customer An individual or corporate entity who enters into anagreement with an AVF which specifies the terms andconditions for AVF services (of any kind) to be performed.

Declaration of A formal statement from a customer assuring that conformityConformance is realized or attainable on the Ada implementation for

which validation status is realized.

Host Computer A computer system where Ada source programs are transformedSystem into executable form.Inapplicable A test that contains one or more test objectives found to betest irrelevant for the given Ada implementation.

ISO International Organization for Standardization.

LRM The Ada standard, or Language Reference Manual, published asANSI/MIL-STD-1815A-1983 and ISO 8652-1987. Citations fromthe LRM take the form "<section>.<subsection>:<paragraph>."

Operating Software that controls the execution of programs and thatSystem provides services such as resource allocation, scheduling,

input/output control, and data management. Usually,operating systems are predominantly software, but partial orcomplete hardware implementations are possible.

Target A computer system where the executable form of Ada programsComputer are executed.System

Validated Ada The compiler of a validated Ada implementation.Compiler

Validated Ada An Ada implementation that has been validated successfullyImplementation either by AVF testing or by registration [Pro90].

Validation The process of checking the conformity of an Ada compiler tothe Ada programming language and of issuing a certificatefor this implementation.

Withdrawn A test found to be incorrect and not used in conformitytest testing. A test may be incorrect because it has an invalid

test objective, fails to meet its test objective, orcontains erroneous or illegal use of the Ada programminglanguage.

1-4

CHAPTER 2

IMPLEMTTICON DEPENDENCIES

2.1 WITHDRAM TESTS

The following tests have been withdrawn by the AVO. The rationale forwithdrawing each test is available from either the AVO or the AVF. Thepublication date for this list of withdrawn tests is 2 August 1991.

E28005C B28006C C32203A C34006D C35508I C355083C355081 C35508N C35702A C35702B B41308B C43004AC45114A C45346A C45612A C45612B C45612C C45651AC46022A 849008A B49008B A74006A C74308A B83022BB83022H B83025B B83025D C83026A B83026B C83041AB85001L C86001F C94021A C97116A C98003B BA2011ACB7001A CB70018 CB7004A CC1223A BC1226A CC1226BSC3009B BD1028 BD1B06A ADIBOBA BD2AO2A CD2A21ECD2A23E CD2A32A CD2A41A CD2A41E CD2A87A CD2B1SCBD3006A BD4008A CD4022A CD4022D CD4024B CD4024CCD4024D CD4031A CD4051D CD5111A CD7004C ED7005DCD7005E AD7006A CD7006E AD7201A AD7201E CD7204BAD7206A BD8002A BD8004C CD9005A CD9005B CDA201ECE21071 CE2117A CE2117B CE2119B CE2205B CE2405ACE3111C CE3116A CE3118A CE3411B CE3412B CE3607BCE3607C CE3607D CE3812A CE3814A CE3902B

2.2 INAPPLICABLE TESTS

A test is inapplicable if it contains test objectives which are irrelevantfor a given Ada implementation. Reasons for a test's inapplicability maybe supported by documents issued by the ISO and the AJPO known as AdaCommentaries and commonly referenced in the format AI-ddddd. For thisimplementation, the following tests were determined to be inapplicable forthe reasons indicated; references to Ada Comntaries are included asappropriate.

2-1

Ir•iJIGNATIGI DEPEDENCIES

The following 201 tests have floating-point type declarationsrequiring more digits than SYSTEK.MAX_DIGITS:

C24113L..Y (14 tests) C35705L..Y (14 tests)C35706L..Y (14 tests) C35707L..Y (14 tests)C35708L..Y (14 tests) C35802L..Z (15 tests)C45241L..Y (14 tests) C45321L..Y (14 tests)C45421L..Y (14 tests) C45521L..Z (15 tests)C45524L..Z (15 tests) C45621L..Z (15 tests)C45641L..Y (14 tests) C46012L..Z (15 tests)

The following 20 tests check for the predefined type LWNG INTEGER; forthis implementation, there is no such type:

C35404C C45231C C45304C C45411C C45412CC45502C C45503C C45504C C45504F C45611CC45613C C45614C C45631C C45632C 852004DC55BO7A B55B09C B86001W C86006C CD7101F

C35713C, B86001U, and C86006G check for the predefined typeLONG FLOAT; for this implementation, there is no such type.

C35713D and B86001Z check for a predefined floating-point type with aname other than FLOAT, LONG FLOAT, or SHORT FLOAT; for thisimplementation, there is no such type.

A35801E checks that FLOAT' FIRST.. FLOT' LAST may be used as a rangeconstraint in a floating-point type declaration; for thisimplementation, that range exceeds the range of safe nubers of thelargest predefined floating-point type and must be rejected. (Seesection 2.3.)

C45531M..P and C45532M..P (8 tests) check fixed-point operations fortypes that require a SYSTE.MNAX MANTISSA of 47 or greater; for thisimplementation, MAXMANTISSA is leis than 47.

C45624A..B (2 tests) check that the proper exception is raised ifMACHINE OVERFLOWS is FALSE for floating point types and the results ofvarious- floating-point operations lie outside the range of the basetype; for this implementation, MACHINE OVERFLOWS is TRUE.

B86001Y uses the name of a predefined fixed-point type other than typeDURATICN; for this implementation, there is no such type.

C96005B uses values of type DURATICN's base type that are outside therange of type DiRATICK; for this implementation, the ranges are thesame.

CD1009C checks whether a length clause can specify a non-default sizefor a floating-point type; this implementation does not support suchsizes.

2-2

IInPLDNTAION DEPEDWICIES

CD2A84A, CD2A84E, CD2A84I..J (2 tests), and CD2A840 use length clausesto specify non-default sizes for access types; this implementationdoes not support such sizes.

The tests listed in the following table check that USE ERROR is raisedif the given file operations are not supported -for the givencombination of mode and access method; this implementation supportsthese operations.

Test File Operation Mode File Access Method

CE2102D CREATE IN FILE SEM TAL_0ICE2102E CREATE OUT FILE SEQUENTIAL 10CE2102F CREATE IN(XJ FILE DIRECT 10CE21021 CREATE IN FILE DIRECT-IOCE2102J CREATE OUT FILE DIRECT-IOCE2102N OPEI IN 'FILE SEMMMIAL I0CE21020 RESET IN-FILE SEQUENTIAL 10CE2102P OPEN OUT FILE SEQUENTIAL-IOCE2102Q RESET OffTFILE SEQUENTIAL 10CE2102R OPDE INOUT FILE DIRECT 10CE2102S RESET INOUT-FILE DIRECT-IOCE2102T OPEN IN FILE DIRECT-IOCE210O2U RESET IN-FILE DIRECT-IOCE2102V OPEN OU FILE DIRECT-10CE2102W RESET OUT-FILE DIRECT-IOCE3102E CREATE IN FILE TEXT IdCE3102F RESET Any Mode TwTI0CE3102G DELETE TEXT-I0CE3102I CREATE OUT FILE TEXT-I0CE31023 OPEN IN FILE TEXT-I0CE3102K OPE OtfT FILE TET--IO.

CE2203A checks that WRITE raises USE ERROR if the capacity of anexternal sequential file is exceeded;- this implementation cannotrestrict file capacity.

CE2403A checks that WRITE raises USE ELR0R if the capacity of anexternal direct file is exceeded; this iqplementation cannot restrictfile capacity.

CE3304A checks that SET LINE LENGTH and SET PAGE LETH raiseUSE ERROR if they specify an Tnappropriate value fo? the externalfile; there are no inappropriate values for this implementation.

CE3413B checks that PAGE raises LAYOUT ERROR when the value of thepage number exceeds C0UNT'LAST; for this Tmplementation, the value ofCOU'NTLAST is greater than 150000, making the checking of thisobjective impractical.

2-3

ILUJTIAI TIMN DEPENDNCIES

2.3 TEST m3IFICATIoNS

Modifications (see section 1.3) were required for 21 tests.

The following tests were split into two or more tests because thisimplementation did not report the violations of the Ada Standard in the wayexpected by the original tests.

B24009A B33301B B38003A B38003B B38009A B38009BB85008G B85008H BC1303F BC3005B BD2BO3A BD2D03ABD4003A

A35801E was graded inapplicable by Evaluation Modification as directed bythe AVO. The compiler rejects the use of the range FLOAT' FIRST.. FLOAT'LASTas the range constraint of a floating-point type declaration because thebounds lie outside of the range of safe numbers (cf. LRN 3.5.7:12).

CD1009A, CD1009I, CD1C03A, and CD2A31A..C (3 Tests) were graded passed byEvaluation Modification as directed by the AVO. These tests useinstantiations of the support procedure LENGTH CHECK, which usesUnchecked Conversion according to the interpretatioin given in AI-00590.The AWO ?uled that this interpretation is not binding under ACVC 1.11; thetests are ruled to be passed if they produce Failed messages only from thein-tances of LENTHCHECK-i.e, the allowed Report.Failed messages have theg9 .ecal form:

" * CHECK CN REPRESEATICN FOR <TYPE ID> FAILED."

AD9001B was graded passed by Test Modification as directed by the AVO.This test checks that no bodies are required for interfaced subprograms;among the procedures that it uses is one with a parameter of mode OUT (line36). This implemenation does not support pragma INTERFACE for procedureswith parameters of mode OUT. The test was modified by commenting out line36 and 40; the modified test was passed.

2-4

CHAPTER 3

PROCESSING INFORMATION

3.1 TESTING E•VIRC'••NIT

The Ada implementation tested in this validation effort is described

adequately by the information given in the initial pages of this report.

For technical and sales information about this Ada implementation, contact:

Corey AshfordVerdix Corporation1600 N.W. Compton DriveAloha, OR 97006-6905

Testing of this Ada implementation was conducted at the customer's site bya validation team from the AVF.

3.2 SUMMMY OF TEST RESULTS

An Ada Implementation passes a given ACVC version if it processes each testof the customized test suite in accordance with the Ada ProgramingLanguage Standard, whether the test is applicable or inapplicable;otherwise, the Ada Implementation fails the ACVC [Pro901.

For all processed tests (inapplicable and applicable), a result wasobtained that conforms to the Ada Programming Language Standard.

The list of items below gives the number of ACVC tests in variouscategories. All tests were processed, except those that were withdrawnbecause of test errors (item b; see section 2.1), those that require afloating-point precision that exceeds the implementation's maximumprecision (item e; see section 2.2), and those tht depend on the supportof a file system - if none is supported (item d). All tests passed,except those that are listed in sections 2.1 and 2.2 (counted in items band f, below).

3-1

PROCESSING IN wOUTIM

a) Total Number of Applicable Tests 3805b) Total Number of Withdrawn Tests 95c) Processed Inapplicable Tests 69d) Non-Processed I/0 Tests 0e) Non-Processed Floating-Point

Precision Tests 201

f) Total Number of Inapplicable Tests 270 (c+d+e)

g) Total Number of Tests for ACVC 1.11 4170 (a+b+f)

3.3 TEST EXECUTION

A magnetic tape containing the customized test suite (see section 1.3) wastaken on-site by the validation team for processing. The contents of themagnetic tape were loaded onto a Sun Workstation and copied over Ethernetto the host computer.

After the test files were loaded onto the host computer, the full set oftests was processed by the Ada implementation.

Testing was performed using command scripts provided by the customer andreviewed by the validation team. See Appendix B for a complete listing ofthe processing options for this implementation. It also indicates thedefault options. The options invoked explicitly for validation testingduring this test were:

Option/Switch Effect

-w Suppress warning diagnostics.

Test output, compiler and linker listings, and job logs were captured onmagnetic tape and archived at the AVF. The listings examined on-site bythe validation team were also archived.

3-2

APPD4IX A

MAR PARAMETERS

This appendix contains the macro parameters used for customizing the ACVC.The meaning and purpose of these parameters are explained in JUG89]. Theparameter values are presented in two tables. The first table lists thevalues that are defined in terms of the maximum input-line length, which isthe value for $MAX IN _LE-also listed here. These values are expressedhere as Ada string aggregates, where "V" represents the maxim= input-linelength.

Macro Parameter Macro Value

SMAX_IN_LEq 499 - Value of V

$BIGIDI (1..V-1 -> 'A', V -> '1')

$SBIGID2 (l..V-1-> 'A', V-> '2')

$BIGID3 (l..V/2-> 'A'W) & '3' &(l..V-l-V/2 -> 'A')

$BIGID4 (1..V/2 -> 'A') & '4' &(l..V-I-V/2-> 'A')

$SBIGINTLIT (l..V-3 -> '0') & "298"

$BIGREALLIT (l..V-5 -> '0') & "690.0"

SBIGSTEING '"' & (l..V/2 -> 'A') & '"'

$BIGSTRING2 '"' & (1..V-1-V/2 -> 'A') & '1' & l"'

$BLANKS (l..V-20 => '

$J4AXLENINTBASEDLITERAL"2:" & (1..V-5-> '0') £ "11:"

SMAXLENREALBASEDLITERAL"16:" & (1..V-7 => '0') & "F.E:"

A-1

MN= PARAM1VnW

$NAXSTRINGLIAL '"' & (1..V-2 -> 'A') &

The following table lists all of the other macro parameters and theirrespective values.

Macro Parameter Macro Value

$ACCSIZE 32

$ALIGNMEN 4

$CUNT LAST 2147_483_647

$DEFAULT_ MMSIZE 16 777_216

$DEFAULT_S UNIT 8

$DEFAULTSYSNAME sysv86O-self cube

$DELTA DOC 0.0000000004656612873077392578125

$1ENTRY ADDRESS S ."+"(16#40#)

$ENTRY ADDRESS1 SYSTEI."+"(16#80#)

$ENTRY_ADDRESS2 SYSTEI."+"(16#100#)

$FIELDLAST 2147_483_647

$FILETM'-••I R '

$FIXEDNAME NO SUCHTYPE

$FLOAT NANE NOSUCHTYPE

$FORKSTRIN "G

$FORM 1STRING "CANNOTRESTRICT FILECAPACITY"

$GREATER THAN DURATION4100 000.0

$GREATERTHAN DURATION BASE LAST- to oo'0 ooo.o

$GREATER_79ANFLOAT BASE LASTl- 1.E+308

$GREATERTHANFL40AT SAFE LAMtE- 5.XE307

A-2

PDAC PARNUEIUS

IMIR TAN IMIFLWAT SAFE LAM~9.0137 -

SHIGHPRIORITYt 99

$IT-JM EUMALFILE XNAMl-/illegal/ftile._na /2)%2102c.dat"

$ITIM- E MKIFILE NANE2- 'r/lllegal/fUL e nam/CE2102C*.datm

$INAPPROPRIATE LINELENGTH-1

sInaPPROPRIATEPAGELEWTH-1

$INCLUDEPRPAC;l PRAGA INCLUDE ("A28006D1.TST")

s$nCDE PRAGIA2 PRAGMA INCLUDE ("B28006D1 .TST")

$INTEGERFIRST -2_147_483_648

s$NTEGERAST 2147_483_647

$INTEGER LAST P,• S-1 2_147483_648

$INTERFACELANIGZG C

$LESS THAN DURA.TION -100_000.0

SLESSTHAN_ DMTIOtI BASE FIRST- -1"_000 000.0

$LINE_TENIaO ASCII.LF & ASCII .F

$LOWPRIORITY' 0

$MA~CHINE CODE STA.TDIKflCODE 0'(OP -> NOP);

W$MA..II. CODE TYPE CODE_0

$MANTISSADOCC 31

SMAX_DIGITS 15

$MAXINT 2_147_483_647

$NAX_INT PLUS_1 2_147_483_648

$SIN INT -2.147.483z 48

-3TINY f

A-3

SNAKE LIST inysv86Ose1f-cub.

SNAKE SPEC! FICATIOWI /usr/test-suites/ihip _cvcl . 1/Cý/eAC'212OD

SNANE SPECIF!CRTICtf3 Amsr/test-suitea/iip._cvcl.11/c"/eý/X3119A

$NEG SAMINT 16#FOOOOOOE#

$NEW MMI SIZE 16_777_216

$NEWS UNIT 8

$NEWSYiSNAME sysv86O-self cube

$PAW ETERmInaTO ASCII * 7

SRECOMDDEFINITION RECORD SEWP: OPERAND; END RECORD;

$RECORDNAME CODE_0

$TASK SIZE 32

$TASK STORAG SIZE 2048

$TICK 0.01

$VARIABLEADDRESS VAR_1 'ADDRESS

$VARIABLEADDRESS1 VAR_2 'ADDRESS

$VARIABLEADDRESS2 VAR_31ADDRESS

$YOUJRPRAGMA PRAQI& PASSIVE

A-4

APPENDIX B

~ILATION SYSTDI OPTICIIS

The compiler options of this Ada implemntation, as described in thisApendix, are provided by the customer. Unless specifically notedotherwise, references in this appendix are to compiler documentation andnot to this report.

Syntax

ada (options] [source file]... (object file.o]...

Argumnts

object file.o nan-A object file name. These files will be passedon to the linker and will be linked with the specifiedAda object files.

options options to the compiler. These are:

-A (disassemble) Disassemule the units in the source file aftercompiling them. -A can be followed by arguments that furtherdefine the disassembly display (e.g., -Aa, -Ab, -Ad, -Af,-Al, -As).

a Add hexadecimal display of instruction bytes todisassembly listing.

b Disassemble the unit body (default].d Print the data section (if present) as well.f Use the alternative format for output.1 Put the disassembly output in file "file name.das"s Disassemble the unit spec.

-a file name(arEhive) Treat file name as an object archive file createdby ar. Since some arhive files end with .a, -a is used todistinguish archive files from Ada source files.

-astatic/dynamic (SPARCompiler Ada only)(static) If static is indicated, the Ada program is compiledand linked statically. The default is dynamic.

B-1

COMXLUATIQ SYS7 OrTIAN

-c suppress the control messages generated when pragma PAWand/or prages LIST are encountered.

-D identifier type value(define) Define an identifier of a specified type and value.

-DA..0-DlR.1-OA2.0

(architecture) Specify the architecture version the compilershould generate code for. These options override the AROIITZCIUtEI= directive [Default: -Wl.l1 (HP PA-RISC only)

-d (dependencies) Analyze for dependencies only. Do not dosemantic analysis or code generation. Update the library,narking any defined units as uncompiled. The -d option isused by a.make to establish dependencies among new files.This option will attempt to do imports for any unitsreferenced froa outer libraries. This should reducerelocation and reduce user disk space usage.

-E-E directory

(error output) Without a directory argument, ada processeserror messages using a.error and directs a brief message tostandard output; the raw error messages are left insource file.err. If a directory name is given, the raw erroroutput-is placed in directory/source file.err. The file ofraw error messages can be used as input to a.error. Onlyone -e or -E option should be used.

-e (error) Process compilation error messages using a.error andsend it to standard output. Only the source lines containingerrors are listed. Only one -e or -E option should be used.

-Eferror file source file(err&r) Process iource file and place any error messagesin the file indicated Fy error file. Note that there isno space between the -Ef and eiror file.

-El-El directory

(error listing) Same as the -E option, except that a sourcelisting with errors is produced.

-el (error listing) Intersperse error messages among sourcelines and direct to standard output.

-Elferror file source file(erroE listing) Same as the -Ef option, except that a sourcelisting with errors is produced.

-ev (error vi(l)) Process syntax error messages using a.error,

9-2

COWlAT•IG SYSTDI OO•'OIS

overrides the SSWBE BODY IM directive and the SHAM CODEor SHM BODY pragnas.

-0(0-91(optimize) Invoke the code optimizer. An optional digit(there is no space before the digit) provides the level ofoptimization. The default is -04.

-0 full optimization-W0 no optimization (use for debugging)-01 copy propagation, constant folding, removing

dead variables, subsuming moves between scalarvariables

-02 add cont1rn subexpression elimination withinbasic blocks

-03 add global comon subexpression elimination-04 add hoisting invariants from loops and address

optimizations-05 add range optimizations, instruction scheduling

and one pass of reducing induction expressions-06 no change-07 add one more pass of induction expression reduction-0W add one more pass of induction expression reduction-09 add one more pass of induction expression

reduction and add hoisting expressions cnown tothe then and the else parts of if statements

Hoisting from branches (and cases alternatives) can be slowand does not always provide significant performance gains soit can be suppressed.

-o executable file(output) !his option is to be used in conjunction withthe -M option. executable file is the name of the executablerather than the default, a.out (self) or a.vox (cross).

-P Invoke the Ada Preprocessor.

-R VADS library(reowpile instantiation) Force analysis of all genericinstantiations, causing reinstantiation of any that are outof date. VADS library is the library in which therecompilation Ts to occur. If it is not specified, therecompilation occurs in the current working directory.

-r (recreate) Recreate the library's GWAS TME file. This optionreinitializes the file and exits. Thii allows recovery from"GVAS exhausted" without recompiling all the files in the library.

-S (suppress) Apply pragma SUPPRESS to the entire compilationfor all suppressible checks.

-sh (show) Display the name of the tool executable but do notexecute it.

B-4

COUPIIATIN SYSTD OI'ICNS

-T (timing) Print timing information for the compilation.

-v (verbose) Print compiler version number, date and time ofcompilation, nam of file compiled, command input line,total compilation tim and error summry line. Storage usageinformation about the object file is provided.

-w (warnings) Suppress warning diagnostics.

source-file name of the source file to be compiled.

Description

The ada command executes the Mda compiler and compiles the named Adasource file. The file must reside in a VADS library directory. Theada.lib file in this directory is modified after each Ada unit iscompiled.

By default, ada produces only object and net files. If the -M optionis used, the compiler automatically invokes a.ld and builds a completeprogram with the named library unit as the main program.

For cross systems, the compiler generates object files compatible withthe host linker in VOX format. The VOK format is discussed inAppendix A of the Progranmer's Guide.

Non-Ada object files (.o files produced by a compiler for anotherlanguage) may be given as arguments to ada. These files will be passedon to the linker and will be linked with the specified Ada object files.

Commnd line options may be specified in any order but the order ofcompilation and the order of the files to be passed to the linker canbe significant.

Several VADS compilers may be simultaneously available on a singlesystem. Because the ada command in any VADS location/bin on a systemwill execute the correct compiler componenti based upon visiblelibrary directives, the option -sh is provided to print the name ofthe components actually executed.

Program listings with a disassembly of machine code instructionsare generated by a.db or a.das.

NOrE: If two files of the same name from different directories arecompiled in the same ada library using the -L option (even if thecontents and unit names are different), the second compilation willoverwrite the first. For example, the compilation of/usr/directory2/foo.a -L /usr/vads/test will overwrite thecompilation of /usr/directoryl/foo.a -L /usr/vads/test in theVADS library /usr/vads/test.

Diagnostics

B-5

COMFI&•TI SYSTDI OPTICHS

The diagnostics produced by the VADS compiler are intended to beself-explanatory. Most refer to the RN. Each RNM reference includes asection number and optionally, a paragraph number enclosed inparentheses.

LINKER OPTICNS

The linker options of this Ada implementation, as described in thisAppendix, are provided by the customer. Unless specifically notedotherwise, references in this appendix are to linker documentation and notto this report.

Syntax

a.ld [options] unit name [linkeroptions]

Arguments

linker options* All arguments after unit name are passed to the linker.

library abbreviations or-object files.

options options to the a.ld command. These are:

-D1. .0-DAl.1-DA2.0

(architecture) Specify the architecture version the compilershould generate code for. These options override the ARCHITECTUREINFO directive [Default: -Ml.l1 (HP PA-RISC only)

-DO (objects) Use partially linked objects instead of archivesas an intermediate file if the entire list of objects cannotbe passed to the linker in one invocation. This option isuseful because of limitations in the archiver on some hosts(including ULTRIX, HP-UX and System V). (VADSself only)

-DT (time) Displays how long each phase of the prelinking processtakes. (VADSself only)

-Du unit list(uniTs) Traces the addition of indirect dependencies to the namedunits. (VADSself only)

-Dx (dependencies) Displays the elaboration dependencies used eachtime a unit is arbitrarily chosen for elaboration. (VADSself only)

-DX (debug) Debug memory overflow (use in cases where linkinga large number of units causes the error message "localsymbol overflow" to occur). (VADSself only)

B-6

COMPILATION SYSTMM OPTIONS

-E unit name(eliborate) Elaborate unit name as early in the elaborationorder as possible.

-F (files) Print a list of dependent files in order and suppresslinking.

-K (keep) Do not delete the termorary file containing the list ofobject files to link. This file is only present when many objectfiles are being linked. (SGI only)

-L library name(library) Collect information for linking in library name insteadof the current directory. However, place the executible in thecurrent directory.

-o executable file(output) Use the specified fielname as the name of the outputrather than the default a.out (self) or a.vox (cross).

-sh (show) Display the name of the tool executable but do notexecute it.

-T (table) List the symbols in the elaboration table to standardoutput.

-U (units) Print a list of dependent units in order andsuppress linking.

-v (verbose) Print the linker command before executing it.

-V (verify) Print the linker command but suppress execution.

-w (warnings) Suppress warning messages.

unit namename of an Ada unit. It must name a non-generic subprogram.If unit name is a function, it must return a value of thetype SINO.INTmER. This integer result will be passed backto the shell as the status code of the execution.

Description

a.ld collects the object files needed to make unit name a mainprogram and calls the ld(l) linker to link togethe? all Ada andother language objects required to produce an executable image ina.out (self) or a.vox (cross). The utility uses the net files producedby the Ada compiler to check dependency information, a.ld producesan exception mapping table and a unit elaboration table and passesthis information to the linker. The elaboration list generated bya.ld will not include library level packages that do not needelaboration. Similarly, packages that contain no code that can raisean exception will no longer have exception tables.

B-7

CPUILATION SYSTDI OPTIONS

a.ld reads instructions for generating executables from the ada.libfile in the VADS libraries on the search list. Besides informationgenerated by the compiler, these directives also include WITHndirectives that allow the automatic linking of object modulescompiled from other languages or Ada object modules not namedin context clauses in the Ada source. Any number of WITHndirectives may be placed into a library but they ust benumbered contiguously beginning at WITH1. The directives arerecorded in the library's ada.lib file and have the following form.

WITH1:LINK:object file:WITH2 :LINK:archivie file:

WITHn directives may be placed in the local Ada libraries or inany VADS library on the search list.

A WITHn directive in a local VADS library or earlier on thelibrary search list will hide the same numbered WITHn directivein a library later in the library search list.

Use the tool a.info to change or report library directives inthe current library.

For VADSself on Silicon Graphics Computer Systems, theUSE LAST LINK INFO directive speeds relinking by retaining a listof units, theTr types, seals and dependencies.

VADS location/bin/a.ld is a wrapper program that executes thecorre-ct executable based upon directives visible in the ada.libfile. This permits multiple VADS compilers to exist on the samehost. The -sh option prints the name of the actual executable file.

Files

a.out (self), a.vox (cross) default output file.nets Ada DIANA net files directory.objects/* Ada object filesVADS_location/standard/* startup and standard library routines

Diagnostics

Self-explanatory diagnostics are produced for missing files,etc. Additional messages are produced by the ld linker.

B-8

APPEDIX C

APPENDIX F OF THE Ada STANDARD

The only allowed implementation dependencies correspond toimplementation-dependent pragmas, to certain machine-dependent conventionsas mentioned in Chapter 13 of the Ada Standard, and to certain allowedrestrictions on representation clauses. The implementation-dependentcharacteristics of this Ada implementation, as described in this Appendix,are provided by the customer. Unless specifically noted otherwise,references in this Appendix are to compiler documentation and not to thisreport. Implementation-specific portions of the package STANARD, whichare not a part of Appendix F, are:

package STNARD is

type I is range -2147483648 .. 2147483647;type SHORT INTEGER is range -32768 .. 32767;type TINY NTEGER is range -128 .. 127;

type FLOAT is digits 15 range -1.79769313486232E+3081.79769313486232E+308;

type SHORT FLOAT is digits 6 range -3.40282E+38 .. 3.40282E+38;

type DURATION is delta 0.0001 range -214748.3648 .. 214748.3647;

end TUNARD;

C-1

APPEDIX F OF ThE Ada STANDARD

APPDDIX F. Implementation-Dependent Characteristics

1. Implementation-Dependent Pragmas

1.1. INLINEONLY Pragma

The INLINE ONLY pragma, when used in the same way as pragmaINLINE, indicates to the compiler that the subprogram mustalways be inlined. This pragma also suppresses the genera-tion of a callable version of the routine which saves codespace. If a user erroneously makes an INLINE ONLY subpro-gram recursive a warning message will be emitted and anPROGRAM ERROR will be raised at run time.

1.2. INITIALIZE Pragma

Takes one of the identifiers STATIC or DYNAMIC as the singleargument. This pragma is only allowed within a library-level package spec or body. It specifies that all objectsin the package be initialized as requested by the pragma(i.e. statically or dynamically). Only library-levelobjects are subject to static initialization; all objectswithin procedures are always (by definition) dynamic. Ifpragma INITIALIZE(STATIC) is used, and an object cannot beinitialized statically, code will be generated to initializethe object and a warning message will be generated.

1.3. BUILTIN Pragma

The BUILT IN pragma is used in the implementation of somepredefine' Ada packages, but provides no user access. It isused only to implement code bodies for which no actual Adabody can be provided, for example the MACHINE CODE package.

1.4. SHARECODE Pragma

The SHARE CODE pragma takes the name of a generic instantia-tion or a generic unit as the first argument and one of theidentifiers TRUE or FALSE as the second argument. Thispragma is only allowed immediately at the place of adeclarative item in a declarative part or package specifica-tion, or after a library unit in a compilation, but beforeany subsequent compilation unit.

When the first argument is a generic unit the pragma appliesto all instantiations of that generic. When the first argu-ment is the name of a generic instantiation the pragmaapplies only to the specified instantiation, or overloadedinstantiations.

If the second argument is TRUE the compiler will try to

C-2

APPENDIX F Of THE Ada STANDARD

share code generated for a generic instantiation with codegenerated for other instantiations of the same generic.When the second argument is FALSE each instantiation willget a unique copy of the generated code. The extent towhich code is shared between instantiations depends on thispragma and the kind of generic formal parameters declaredfor the generic unit.

The name pragma SHARE BODY is also recognized by the imple-mentation and has The same effect as SHARE CODE. It isincluded for compatability with earlier versioni of VADS.

1.5. NO_IMAGE Pragma

The pragma suppresses the generation of the image array usedfor the IMAGE attribute of enumeration types. This elim-inates the overhead required to store the array in the exe-cutable image. An attempt to use the IMAGE attribute on atype whose image array has been suppressed will result in acompilation warning and PRGRAM_ELRR raised at run time.

1.6. EXTERNAL NAM Pragma

The EXTERNAL NAME pragma takes the name of a subprogram orvariable deiined in Ada and allows the user to specify adifferent external name that may be used to reference theentity from other languages. The pragma is allowed at theplace of a declarative item in a package specification andmist apply to an object declared earlier in the same packagespecification.

1.7. INTERFACE NAME Pragma

The INTERFACE NAME pragma takes the name of a a variable orsubprogram defined in another language and allows it to bereferenced directly in Ada. The pragma will replace alloccurrences of the variable or subprogram name with anexternal reference to the second, link argument. The pragmais allowed at the place of a declarative item in a packagespecification and must apply to an object or subprogramdeclared earlier in the same package specification. Theobject must be declared as a scalar or an access type. Theobject cannot be any of the following:

a loop variable,a constant,an initialized variable,an array, ora record.

1.8. IMPLICIT CODE Pragma

Takes one of the identifiers CN or OFF as the single argu-ment. This pragua is only allowed within a machine code

C-3

APPENDIX F OF T•E Ada STAND

procedure. It specifies that implicit code generated by thecompiler be allowed or disallowed. A warning is issued ifOFF is used and any implicit code needs to be generated.The default is ON.

1.9. OPTIMIZE_CODE Pragia

Takes one of the identifiers ON or OFF as the single argu-ment. This pragma is only allowed within a machine codeprocedure. It specifies whether the code should be optim-ized by the compiler. The default is (N. Own OFF isspecified, the compiler will generate the code as specified.

2. Implementation of Predefined Pragmas

2.1. CONTROLLJMD

This pragma is recognized by the implementation but has noeffect.

2.2. ELNSOEATE

This pragma is implemented as described in Appendix B of theAda RN.

2.3. INLINE

This pragma is implemented as described in Appendix B of theAda Rm.

2.4. INTERFACE

This pragmea supports calls to 'C' and FORTRAN functions. TheAda subprograms can be either functions or procedures. Thetypes of parameters and the result type for functions mustbe scalar, access or the predefined type ADDRESS in SYSTEM.All parameters mist have mode IN. Record and array objectscan be passed by reference using the ADDRESS attribute.

2.5. LIST

This pragma is implemented as described in Appendix B of theAda RM.

2.6. NDfRY SIZE

This pragma is recognized by the implementation. The imple-mentation does not allow SYSTEI to be modified by means ofpragmas, the SYSTEM package must be recompiled.

2.7. NCN _RENTRANT

This pragma takes one argument which can be the name of

C-4

APPVMIX F OF TIM Ada STANDARD

either a library subprogram or a subprogram declared iinmdi-ately within a library package spec or body. It indicatesto the compiler that the subprogram will not be calledrecursively allowing the compiler to perform specific optim-izations. The pragea can be applied to a subprogram or aset of overloaded subprogram within a package spec or pack-age body.

2.8. NOTELA5ORA1'D

This pragma can only appear in a library package specifica-tion. It indicates that the package will not be elaboratedbecause it is either part of the RTS, a configuration pack-age or an Mda package that is referenced from a languageother than Mda. The presence of this pragma suppresses thegeneration of elaboration code and issues warnings if ela-boration code is required.

2.9. OPTIMIZE

This pragma is recognized by the implementation but has noeffect.

2.10. PACK

This pragma will cause the compiler to choose a non-alignedrepresentation for composite types. It will not causesobjects to be packed at the bit level.

2.11. PAGE

This pragma is implemented as described in Appendix B of theAda Rm.

2.12. PASSIVE

The pragma has three forms :

PMWA PASSIVE;PRAQIA PASSIVE(SMAPIIORE);PRAGMA PASSIVE(INTL4uJPT, <number>);

This pragma Pragma passive can be applied to a task or tasktype declared immediately within a library package spec orbody. 7 pragma directs the compiler to optimize certaintaskino operations. It is possible that the statements in atask body will prevent the intended optimization, in thesecases a warning will be generated at compile time and willraise TASKING ERROR at runtime.

2.13. PRIORITY

This pragma is implemented as described in Appendix B of the

C-5

APPEDIX F OF THE Ada STRNDD

Ada R1.

2.14. SHARED

This pragma is recognized by the implementation but has noeffect.

2.15. STORAGE UNIT

This pragma is recognized by the implementation. The imple-mmntation does not allow SYSTE to be modified by means ofpragmas, the SYSTEM package nust be recompiled.

2.16. SUPPRESS

This pragma is implemented as described, except thatDIVISION CHECK and in som cases OVERFLOW CHECK cannot besupresseU.

2.17. SYSTEM NAME

This pragma is recognized by the implemntation. The imple-mntation does not allow SYSTEM to be modified by means ofpragmas, the SYSTEI package mnust be recoupiled.

3. Implementation-Dependent Attributes

3.1. P'REF

For a prefix that denotes an object, a program unit, alabel, or an entry:

This attribute denotes the effective address of the first ofthe storage units allocated to P. For a subprogram, pack-age, task unit, or label, it refers to the address of themachine code associated with the corresponding body orstatement. For an entry for which an address clause hasbeen given, it refers to the corresponding hardware inter-rupt. The attribute is of the type OPERAND defined in thepackage MACHINE CODE. The attribute is only allowed withina machine code pFocedure.

See section F.4.8 for more information on the use of thisattribute.

(For a package, task unit, or entry, the 'REF attribute isnot supported.)

3.2. T'TASKID

For a task object or a value T, T'TASK ID yields the uniquetask id associated with a task. The vilue of this attributeis of the type ADDRESS in the package SYSTEM.

C-6

APP• IX F or THE Ada STAAW

4. Specification Of Package SYSTEM

with UNSIGN TYPES;package STES is

pragma suppress(ALL CHECKS);pragma suppress( ICONTITAN ES);pragma notelaborated;

type NMAE is ( Sysv860 self cube )

SYSTEM NAME : constant M :-sysv860_self_cube;

STORAGE UNIT : constant :-8;MU ERYTIZE : constant :-16_777_216;

- System-Dependent Named Numbers

MIN INT : constant :- -2 147 483 648;-I~NT : constant :- 2 147 _83_ 47;

M)X-DIGITS : constant :-1; -1 -MAX-ANTISSA : constant :-31;F? DELTh : constant t- 2.0**(-31);TICKC : constant *- 0. 01;

- Other System-dependent Declarations

subtype PRIORITY is INT•EG range 0 .. 99;

MAX REC SIZE : integer :- 1024;

type ADDRESS is private;

function ">" (A: ADDRESS; B: ADDRESS) return BOOLEAN;function "<" (A: ADDRESS; B: ADDRESS) return BOOLEAN;function ">-"(A: ADDRESS; B: ADDRESS) return BDOLEAN;function "<-"(A: ADDRESS; B: ADDRESS) return BOOLEAN;function "-" (A: ADDRESS; B: ADDRESS) return INTER;function "+" (A: ADDRESS; I: INTEGER) return ADDRESS;function "-" (A: ADDRESS; I: INTEGER) return ADDRESS;

function "+" (I: UNSIGNE)_TYPES.UNSIGNED INTEGER) return ADDRESS;

function MEIRY ADDRESS(I: UNSIGN5_TYPES.UNSIGNE INTEGER) return ADDRESS renames "+";

NO ADDR : constant ADDRESS;

type TASK ID is private;NOTASKID : constant TASK ID;

C-7

9

"* APPDIX F OF TOE Ada SRAiD

type PASSIVE TASK ID is private;No PASSIVEtSK_Ix : constant PASSIVETASK_ID;

subtype SIG STAU T is INTER;SIG STT UIZE: c~mstant :- 4;

type PROGRA ID is private;NOPROGRA14_15: constant PROGRAMID;

type BYTE ORDER T is (LfTTLE INIAN,BIG EN1IAN

BYTE _ORDER: constant BYTEORDT :- SIG_ EIMA;

type LONG ADDRESS is private;

NOUMADDR : constant L _ ADDRESS;

function "+" (A: LGM ADDRESS; I: INTEGER) return LQG ADDRESS;function "-" (A: UM ADDRESS; I: INTEGER) return L46--ADDRESS;

function MAKE LCG_ADDRESS (A: ADDRESS) return LtG ADDRESS;

function LOCLMIZE(A: LONG ADDRESS ; BYTE SIZE : IN'IEER) return ADeESS;

function SMMTICH_OF(A: LCNG ADDESS) return INTEER;

- Internal RTS representation for day. If the calendar package is used,- then, this is the julian day.subtype DAY T is INTEGER;

- Constants describing the configuration of the CIFO add-on product.SUPPORTS INVOCATION BY ADDRESS : constant BOOLERN :- TRUE;SUPPORTS PREELAOR•IAC• : constant OOLERN :- TRUE;mA KEACCSSSUP10WIE : constant BOOLERN :- T ;

- Arguments to the CIFO pragma INTERFUPT TRSK.type INTERRUPTASKKIND is (SIMPL, SIQIALLING;)

privatetype ADDRESS is new UNSIG TYPES.L1SIGEINTEGER;

NO ADM : constant ADDRESS :- 0;

pragma BUILT IN(">");pragma BU1ILT-IN("<");pragma BUILT-IN( -"W);pragma BUILT-IN( "<-");pragma UILT-IN("-");

C-8

APPENDIX F OF THE Ada STANARD

pram BUILT IN("+");

type TASK ID is new UNSIGED) TYPmS.UZISIGND INTEGER;NO TASK I : constant TASK_ I :- 0;

type PASSIVE TASK ID is new UNSIGNED TYPES.UNSIGNEDINTEGER;NO PASSIVE ASK I : constant PASsIV _TASK ID :- 0;-

type PROGAM ID is new UNSIGNED TYPES.UNSIGNED INT R;NO PGAM 5 : constant PRAN ID : - 0;

type 14 _ ADDRESS is now UNSIGNETYPs.SI_ INTEGER;

NO LONG ADMR : constant LONG ADDESS :- 0;

pragma BUILT IN(MRKE LONG ADDRESS);pragma UILT--IN(WLCALIZE)Tpragma BUILT_-IN( STATICM_OF);

end SYSTEM;

5. Restrictions On Representation Clauses

5.1. Pragma PACK

In the absence of pragma PACK record components are paddedso as to provide for efficient access by the targethardware, pragma PACK applied to a record eliminate the pad-ding where possible. Pragma PACK has no other effect on thestorage allocated for record components a record representa-tion is required.

5.2. Size Clauses

For scalar types a representation clause will pack to thenwber of bits required to represent the range of the sub-type. A size clause applied to a record type will not causepacking of components; an explicit record representationclause m=at be given to specify the packing of the com-ponents. A size clause applied to a record type will causepacking of components only when the component type is adiscrete type. An error will be issued if there is insuffi-cient space allocated. The SIZE attribute is not supportedfor task, access, or floating point types.

5.3. Address Clauses

Address clauses are only supported for variables. Sincedefault initialization of a variable requires evaluation of

C-9

APPEDIX F OF THE Ada STANDD

the variable address elaboration ordering requirementsprohibit inititalization of a variables which have addressclauses. The specified address indicates the physicaladdress associated with the variable.

5.4. Interrupts

Interrupt entries are supported with the following interpre-tation and restrictions:

An interrupt entry may not have any parameters.

A passive task that contains one or more interrupt entriesmist always be trying to accept each interrupt entry, unlessit is handling the interrupt. The task must be executingeither an accept for the entry (if there is only one) or aselect statement where the interrupt entry accept alterna-tive is open as defined by Ada RH 9.7.1(4). This is not arestriction on normal tasks (i.e., signal ISRs).

An interrupt acts as a conditional entry call in that inter-rupts are not queued (see the last sentence of Ada RM13.5.1(2) and 13.5.1(6)).

No additional requirements are imposed for a select state-ment containing both a terminate alternative and an acceptalternative for an interrupt entry (see Ada RM 13.5.1(3)).

Direct calls to an interrupt entry from another task areallowed and are treated as a normal task rendezvous.

Interrupts are not queued.

The address clause for an interrupt entry does not specifythe priority of the interrupt. It simply specifies theinterrupt vector number. For passive ISss, the nnn of thepassive(interrupt,nnn) pragma specifies the interrupt prior-ity of the task.

5.5. Representation Attributes

The ADDRESS attribute is not supported for the followingentities:

PackagesTasksLabelsEntries

5.6. Machine Code Insertions

Machine code insertions are supported.

C-10

APPENDIX F OF THE Ada STAIDAR

The general definition of the package MACHINE CODE providesan assmbly language interface for the target machine. Itprovides the necessary record type(s) needed in the codestatement, an enumeration type of all the opcode unmoznics,a set of register definitions, and a set of addressing modefunctions.

The general syntax of a machine code statement is as fol-lows:

CODE n' ( opcode, operand {, operand) ;

where n indicates the number of operands in the aggregate.

A special case arises for a variable number of operands.The operands are listed within a subaggregate. The formatis as follows:

CODE N'( opcode, (operand (, operand)) );

For those opcodes that require no operands, named notationmust be used (cf. RN 4.3(4)).

CODE_0'( op -> ý)pcode )

The opcode mist be an enumeration literal (i.e. it cannot bean object, attribute, or a rename).

An operand can only be an entity defined in MACMINE CODE orthe 'REF attribute.

The arguments to any of the functions defined inMACHINE CODE must be static expressions, string literals, orthe functions defined in MACHINE CODE. The 'REP attributemay not be used as an argument i7 any of these functions.

Inline expansion of machine code procedures is supported.

6. Conventions for Implementation-generated Names

There are no implementation-generated names.

7. Interpretation of Expressions in Address Clauses

Address expressions in an address clause are interpreted asphysical addresses.

8. Restrictions on Unchecked Conversions

None.

9. Restrictions on Unchecked Deallocations

C-11

q

APPEDIX F OF THE Ada STANDARD

None.

10. Implementation Characteristics of I/v Packages

Instantiations of DIRECT 10 use the value MAX REC SIZE asthe record size (expressed in STORAGE UNITS) when-the sizeof ELEMENT TYPE exceeds that value. For-example for uncon-strained irrays such as string where ELEMENT TYPE'SIZE isvery large, MAX REC SIZE is used instead. MAN RECD SIZEis defined in IYSTI3 and can be changed by a program biforeinstantiating DIRECT 10 to provide an upper limit on therecord size. In an-case the maxium size supported is 1024x 1024 x S70RAGE UNIT bits. DIRECT 10 will raise USE- .

if MAX REC SIZE ixceeds this absolute limit.

Instantiations of SEQUENTIALO1 use the value MAX REC SIZEas the record size (expressed in STORAGE UNITS) when thesize of ELEMEN TYPE exceeds that value. For example forunconstrained irrays such as string where ELEMENT TYPE'SIZEis very large, MAX REC SIZE is used - instead.MAX RECORD SIZE is define3 in -SYSTD and can be changed by aprogram belore instantiating INTEGER 10 to provide an upperlimit on the record size. SEU=TA 10 imposes no limit onMAX REC SIZE.

11. Implementation Limits

The following limits are actually enforced by the implemen-tation. It is not intended to imply that resources up to oreven near these limits are available to every program.

11.1. Line Length

The implementation supports a maximum line length of 500characters including the end of line character.

11.2. Record and Array Sizes

The maxim•u size of a statically sized array type is4,000,000 x STORAGE UNITS. The maximum size of a staticallysized record type ii 4,000,000 x STORAGE UNITS. A recordtype or array type declaration that exceeds these limitswill generate a warning message.

11.3. Default Stack Size for Tasks

In the absence of an explicit STORAGE SIZE length specifica-tion every task except the main program is allocated a fixedsize stack of 10,240 STORAGE UNITS. This is the valuereturned by T'STORAGE SIZE for i task type T.

11.4. Default Collection Size

C-12

U

APPENDIX F OF THE Ada STANDARD

In the absence of an explicit STORAGE SIZE length attributethe default collection size for an aicess type is 100 timesthe size of the designated type. This is the value returnedby T'STORAGESIZE for an access type T.

11.5. Limit on Declared Objects

There is an absolute limit of 6,000,000 x STORAGE UNITS forobjects declared statically within a compilation unit. Ifthis value is exceeded the compiler will terminate the com-pilation of the unit with a FATAL error message.

C-13