New editions of this guide incorporate all material added or changed since the previous edition.

Update packages may be used between editions. The manual printing date changes when a
new edition is printed. The contents and format of this manual are subject to change without
notice.

Generated: 7/14/2024, 8:01 PM

Rev: 447e070

Part Number: VectorCAST/Ada RSP User's Guide for VectorCAST 2024

VectorCAST is a trademark of Vector Informatik, GmbH

© Copyright 2024, Vector Informatik, GmbH All rights reserved. No part of the material
protected by this copyright notice may be reproduced or utilized in any form or by any means,
electronic or mechanical, including photocopying, recording, or by any informational storage
and retrieval system, without written permission from the copyright owner.

U.S. Government Restricted Rights

This computer software and related documentation are provided with Restricted Rights. Use,
duplication or disclosure by the Government is subject to restrictions as set forth in the
governing Rights in Technical Data and Computer Software clause of

DFARS 252.227-7015 (June 1995) and DFARS 227.7202-3(b).

Manufacturer is Vector North America, Inc. East Greenwich RI 02818, USA.

Vector Informatik reserves the right to make changes in specifications and other information
contained in this document without prior notice. Contact Vector Informatik to determine
whether such changes have been made.

Third-Party copyright notices are contained in the file: 3rdPartyLicenses.txt, located in the
VectorCAST installation directory.

2
TABLE OF CONTENTS

Introduction 6

Introduction 7
Overview 7
VectorCAST RSP Concepts 7
Harness Architecture 7
RSP Communication Overview 8
RSP Communication Details 9

Using VectorCAST RSP 10

Introduction 11
Common Compile Commands 11
Range Database Creation 11
Combining Host- and Target-Based Testing 12
CLICAST - Command Line VectorCAST 12
QuickStart 12
Command Format 14
Common Target Options 15
Target-Specific Options 16
Deprecated Options 21

Target Reference 22

DDC-I 23
Configuration 23
Target Execution 23
Stopping a Target Execution 23
GNAT HIE and Abatron Emulator 24
Configuration 24
Target Execution 26
Stopping a Target Execution 28
Running with Debugger 28
GNAT vxWorks 29
Configuration 29
Target Execution 30
Stopping a Target Execution 31
Running with the gdb Debugger (vxWorks) 31
GNAT vxWorks AE653 33
Overview 33

3
 Target Execution 33
GNAT ERC32 with TSIM Simulator 37
Configuration 37
Target Execution 37
Stopping a Target Execution 37
Green Hills GMART or GSTART 39
Configuration 39
Target Execution 40
Stopping a Target Execution 41
Running with the AdaMULTI Debugger (GMART) 42
Green Hills INTEGRITY 43
Configuration 43
Configuration Differences for Live Board 44
Target Execution 47
Stopping a Test Execution 52
Running with the Green Hills Debugger 53
Target Execution with Green Hills Multi Debugger 53
Green Hills vxWorks 57
Configuration 57
Target Execution 58
Stopping a Target Execution 58
Running with the AdaMULTI Debugger (vxWorks) 59
ObjectAda Raven for PPC 60
Configuration 60
Target Execution 61
Stopping a Target Execution 61
Running with a Debugger 61
ObjectAda Raven for Intel 63
Configuration 63
Target Execution 64
Stopping a Target Execution 64
Running with a Debugger 65
ObjectAda vxWorks 66
Configuration 66
Target Execution 67
Stopping a Test Execution 68
Running with a Debugger 68
Rational Apex vxWorks 69
Configuration 69
Target Execution 70
Stopping a Target Execution 71
Running with the Apex Debugger for vxWorks 71
Rational Apex Exec 72
Configuration 72
Target Execution 72

4
 Stopping a Target Execution 73
Running with the Apex Debugger for vxWorks 73
TLD Ada MIL-STD-1750 Simulator 75
Configuration 75
Target Execution 75
Stopping a Target Execution 76
Running with the TLD Debugger 76
XGC Ada M1750A Simulator 77
Configuration 77
Target Execution 77
Stopping a Target Execution 77
Running with the XGC Debugger 78

Index 79

5
Introduction
 INTRODUCTION 7

Introduction
Welcome to VectorCAST RSP.

Congratulations! You have just taken the first step towards increasing your productivity testing your
Ada language programs on embedded targets.

The VectorCAST RSP User’s Guide is intended to be a companion to the VectorCAST/Ada User’s
Guide. This user guide assumes a familiarity with the VectorCAST product and its features.

This user guide has three sections. The first section, which you are currently reading, introduces the
product and RSP concepts. The second section describes creating target environments. The third
section contains a target reference, with specific information on configuring and executing tests on
each target.

Overview
VectorCAST RSP is an extension of the VectorCAST product. It provides an interface layer that allows
you to use VectorCAST testing techniques and methods on an embedded target processor. The
VectorCAST RSP product will always run on your host platform. Only the VectorCAST-generated test
harness will be downloaded to, and executed on, the embedded target.

The VectorCAST RSP product is always customized to a particular Target CPU, Cross Compiler, and
Run-Time environment (or kernel). As such, the information presented here contains sections for
several different compiler and kernel combinations.

VectorCAST RSP Concepts

VectorCAST RSP complements the basic VectorCAST functionality. This section provides a
conceptual overview of the VectorCAST RSP functionality and architecture.

VectorCAST allows for the automation of software testing in a self-host environment. That is, testing of
the software by running the VectorCAST Test Harnesses on the software development platform –
generally a commercial workstation.

The VectorCAST RSP package allows you to extend your testing one step further and execute your
VectorCAST test cases in an embedded Target Environment. This allows you to easily verify that the
test results generated in each environment are the same. It also allows you to test software that cannot
be executed in the host environment due to target dependencies.

Harness Architecture
The VectorCAST architecture is centered on the executable test harness that is constructed using the
VectorCAST environment constructor. The source code for this harness is custom built each time a
new version of your application is built. The test harness code is compiled and linked into an executable
program using the same cross-compiler and linker that you are using for your application code. The
result is a complete executable program that can be downloaded to any target architecture your cross-
compilation tools support. There is complete compatibility with whatever processor and board the
application is intended to run on. The components of the test harness are illustrated in the following
graphic:

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 RSP COMMUNICATION OVERVIEW 8

RSP Communication Overview

The VectorCAST harness is data driven, which means that no changes are required to the harness
source code in order to change how the harness stimulates the code under test. VectorCAST uses
ASCII text based test data sets to stimulate the test harness. All data produced by the harness during a
test run is likewise ASCII text. All I/O that the harness performs is funneled through the VectorCAST
I/O facility. The following graphic illustrates this architecture:

The VectorCAST architecture allows the VectorCAST application to run on a Host platform while the
test harness executable runs on the same host platform, or on a remote target platform. The

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 RSP COMMUNICATION DETAILS 9

architecture of the target is not important; all that matters to VectorCAST is that there is some
mechanism to by which to send ASCII data into the harness and to retrieve ASCII test result data back
from the harness. With VectorCAST RSP this mechanism is the I/O link that is used for downloading to
the target processor from the host platform, or some other dedicated communications link.

VectorCAST supports a variety of different I/O mechanisms. The mechanism that you will use is
dependent on the compiler and the real-time operating system (RTOS), if any, that you are using.

The version of VectorCAST that you are using has been customized for the RTOS (or kernel) that is
running on your target, and for the I/O link that exists between your host and target.

RSP Communication Details

Once VectorCAST is started, you should select the Tools => Options dialog and configure VectorCAST
to work with your specific target environment. Each target variant has a slightly different dialog box,
based on the options that are relevant to the target.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

Using VectorCAST RSP
 INTRODUCTION 11

Introduction
The VectorCAST RSP product allows you to use all of the VectorCAST functionality on an embedded
target, emulator or simulator. The steps involved in creating a VectorCAST environment for target
testing are exactly the same as for host testing. When creating a target environment make sure that the
parent library that you provide to VectorCAST is a "Target" library.

Common Compile Commands

To compile with Green Hills Ada

PowerPC: acppc -G -cpu=ppc603

68K: ac68e -G

MIPS:acmipe -G

To compile with ObjectAda:

adacomp -ga

To compile with GNAT for vxWorks, vxWorks AE, or GNAT HIE

for the Abatron Emulator:
powerpc-wrs-vxworks-gcc -c

powerpc-wrs-vxworksae-gcc -c

To compile with Apex:

Create an Apex subsystem and View in which to compile. Make sure that the view is built with
the correct switches and model for your target board. Copy files into the Apex View.

From an Apex Shell window, run the command "apex migrate" on each source file. This will
rename the files to conform to the Apex file naming conventions.

To compile with DDC-I:

Make sure that all DDCI compiler initialization scripts have been run. Assume that your compiler
command verb is pm386:

Create an Ada library:

pm386_plu -library $pm386_sys_lib –command “create adalib"

Compile using the following command sequence:

pm386 -library=adalib <file>

Range Database Creation

After the environment is created, VectorCAST must interact with the target (or simulator) in order to

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 COMBINING HOST - AND TARGET -BASED TESTING 12

populate a VectorCAST database with target specific information such as type ranges on the target,
sizes of storage units, and other target-specific information. For each compiler and RTOS this is slightly
different. You may see a dialog box prompting you to boot the target processor.

Note: VectorCAST will invoke the target two separate times to retrieve target-specific data.

In some cases, the execution of this "range database creation" program may take a long time. This is
especially true if the code under test has access to large amounts of global data, or if the parameter or
object types have a large number of scalar components. If the "range database creation" program takes
too long to run, you may stop the execution as follows:

> Kill the "transfer" process that is running the target if you are using a PPC target, or the
"runemb" process if you are using an Intel target.
> Kill the "windsh” process that is running the target.
> Kill the "pm386_xdebug" process that is running the target
> Kill the "windsh” process that is running the target.
> Kill the "rtserv" (INTEGRITY) or "tornserv" (Green Hills vxWorks) process that is running the
target.

If you interrupt the execution of the "range database creation" program, you will still be able to test with
this environment. The only restriction is that the data entry dialog boxes will not include range data for
scalar items when building test cases.

The speed at which a test case runs on the target is based the amount of processing done by the code
under test and on the amount of data that you ask VectorCAST to capture to the test results. A way to
decrease the amount of data captured is to turn off the Expand Report Parameters and Expand Report
Objects options in the Tools => Options dialog box, “Execute” tab.

Combining Host- and Target-Based Testing

If you are doing Host- and Target-based testing, you should use different directories to store your
VectorCAST Host and VectorCAST RSP directories. All instances of VectorCAST that are started
from the same directory will share the same configuration file (ADACAST_.CFG). If you run the target
product and the host product from the same directory, options saved for the target environments will
overwrite the options saved from the host environment, which may not be desirable.

CLICAST - Command Line VectorCAST

QuickStart
The following is a list of useful commands to get online CLICAST help. Each command is preceded by
$VECTORCAST_DIR/ (Unix) or %VECTORCAST_DIR%\ (Windows).

To see a list of all commands, type:

clicast -lada help all

To see a list of categories, type:

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 CLICAST - COMMAND LINE VECTORCAST 13

clicast -lada help

To see a list of commands in a single category, type:

clicast -lada help <category>

where <category> is one of the following:

> ENvironment (or just “EN”)

> EXecute
> Report
> TEst
> TOol
> Option
> Get_option
> Language
> Cover

To see a list of all targets, type:

clicast –x tgt

To see a list of all options, type:

clicast -lada help options all

To see a list of option categories, type:

clicast -lada help options

To see a list of options in a single category, type:

clicast -lada help options <category>

where <category> is one of the following:

> Language
> Builder
> Execute
> Report
> Target
> Coverage

To find out the value of an option, type:

clicast get_option <option>

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 CLICAST - COMMAND LINE VECTORCAST 14

In this manual, the VectorCAST RSP User’s Guide, only the Target Options are listed. See the
VectorCAST/Ada User’s Guide for a complete description of commands and other options.

Command Format
CLICAST is invoked using the following syntax:

Unix systems:

$VECTORCAST_DIR/clicast –eenv -xtgt –uunit –ssub –ttestcase command arguments

Windows systems:

%VECTORCAST_DIR%\clicast /e:env /x:tgt /u:unit /s:sub /t:testcase command

arguments

where env is the name of the environment, unit is the name of a unit under test, tgt is the name of
the target, sub is the name of a subprogram, and testcase is the name of a testcase. If the
environment has only one UUT, then -u unit is optional.

Throughout this User Guide, the corresponding CLICAST command is presented after each feature or
option available in the VectorCAST application. The CLICAST command uses the following format:

clicast -lada -e <env> command | option arguments

Description of the command, option, and arguments.

The following conventions are used:

> The vertical bar | stands for “or”, indicating that one of several choices is to be included in the
command.
> Square brackets around a parameter indicate that a parameter is optional. For example,

-e <env> [-u <unit>]

indicates that the environment name must be specified, but the unit name can optionally be
specified on the command line.
> Angle brackets indicate that a source file name or script file name must be substituted. For
example,

<output file>

indicates that an output file name must be provided.

> Square brackets and angle brackets can be combined to indicate that a substitution is optional.
For example,

[<output file>]

indicates that if the optional output filename is not present, standard output is used.
> Capital letters in a command name indicate the minimum that needs to be typed to uniquely

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 CLICAST - COMMAND LINE VECTORCAST 15

identify the command. For example,

clicast ENvironment Build <scriptfile>

indicates that the abbreviated command clicast EN B <scriptfile> can be used.

To specify <<COMPOUND>> or <<INIT>> as the subprogram or when used in a testcase name,

enclose the name in quotes, as in:

clicast -e DM6B -s "<<COMPOUND>>" -t “<<COMPOUND>>.001” exec run

Common Target Options

These options can be enabled or disabled in the Tools => Options dialog, on the Target tab.

clicast option VCAST_USE_COMPOUND_FOR_BATCH True | False

This option allows you to run all of your test cases during a single test
driver execution. This is useful if there are many steps involved in running
on your target platform. When this option is set, and you choose to Batch
Execute All, VectorCAST will generate a temporary compound test case to
execute all of the simple tests. The default value is False.

clicast option VCAST_ADA_ACCESSOR_FUNCTIONS True | False

If this option is set, VectorCAST will access Ada options from accessor
functions. If this is set to false, VectorCAST will access Ada options from
global objects. The default value is TRUE.

clicast option VCAST_MAX_STRING_LENGTH <integer number>

This option specifies the size of temporary character arrays that VectorCAST
creates in the test harness. Longer strings are needed specifically when test
cases use long lists of values as stimulus data. For example, a stimulus
value for the sine function of: 10,20,30,40,50,60 ... If you are running in a
target environment with limited heap and stack resources, making this value
smaller will reduce the VectorCAST test harness use of heap and stack.
Changes to this value will take effect after the environment is recompiled.
The default value is 1000 characters.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 CLICAST - COMMAND LINE VECTORCAST 16

clicast option VCAST_PRE_EXECUTE_CMD <path to script | OS command >

This option enables users to run a script file or command before each test
case execution. Located on the Tools => Options dialog, Target tab, it is
called "Pre-Test case Execution Command."

When set, this command causes VectorCAST to execute the OS command, script
file, or batch file before the test harness is called for each test case
execution. This option is useful for cycling power to your target, for
example.

When specifying the path to a script file or batch file, a full or relative
(to the environment directory) can be used.

Target-Specific Options
These options can be enabled or disabled in the Tools => Options dialog, on the Target tab, after
specifying a particular target variant.

clicast option TARGET_VARIANT <target code>

This option describes the compiler and target combination used to build an
environment.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 CLICAST - COMMAND LINE VECTORCAST 17

The valid choices for <target code> are:

<target code> Name

HOST Host

M68K_AW_CS M68K AdaWorld C-SMART

MIPS_RA_CS MIPS RISCAda C-SMART

PPC_GH_VEL PPC Green Hills Integrity

PPC_GH_VX PPC Green Hills vxWorks

PPC_GH_SIM PPC Green Hills Simulator

X86_DDCI_BARE x86 DDCI Bare

PPC_AONIX_RAVEN PPC Aonix Raven

M68K_GH_SIM 68000 Green Hills Simulator

PPC_GNAT_VX PPC GNAT vxWorks

PPC_APEX_VX PPC Apex vxWorks

PPC_SCORE_BARE PPC Score Bare

PPC_APEX_EXEC PPC Apex Exec

X86_AONIX_RAVEN x86 Aonix Raven

PPC_GH_BARE PPC Green Hills Bare

PPC_GH_GMART PPC Green Hills GMART

M1750_XGC_SIM M1750 XGC Simulator

PPC_AONIX_VX PPC Aonix vxWorks

MIPS_GH_SIM MIPS Green Hills Simulator

ERC32_AW_CS ERC32 AdaWorld C-SMART

PPC_GH_GSTART PPC Green Hills GSTART

PPC_GNAT_HIE PPC GNAT HIE

PPC_GNAT_AE653 PPC GNAT vxWorks AE653

AAMP_GNAAMP_BARE AAMP GNAAMP BARE

TLD_1750 TLD 1750

ERC32_GNAT GNAT ERC32

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 CLICAST - COMMAND LINE VECTORCAST 18

clicast option FPP True | False

Target uses floating point processor capability.

clicast option TARGET_AE653_MAKE_FILE <directory containing makefile>

This option provides the path to the directory containing the vxWorks AE653
make file. VectorCAST will use this path to create the executable image for
the target, via the command "make -C".

clicast option TARGET_APEX_LIBRARY full | mark

For Apex Exec. This option tells VectorCAST which Ada library to use. If this
option is set to Full, the full Ada run-time library will be used. If this
option is set to MARK, the reduced run-time will be used and the test harness
will be built with the appropriate restrictions. The default value is full.

clicast option TARGET_BOARD_NAME <target_name>

Name of target board. For vxWorks, target_name is the name of the target
server. For other targets, target_name is the hostname or the IP address of
the target.

clicast option TARGET_BOOT_HOSTNAME <hostname>

For vxWorks. This is the name that the target knows the boot host as. If
hostname is not set, VectorCAST assumes that the hostname of the machine it
is running is the boot host.

clicast option TARGET_BUILD_FILE <filename>

For Green Hills compilers only. <filename> is the name of the default build
file. The .bld extension should not be used (e.g. ppc, sim800). Builder flags
can also be provided in this option (e.g. :language=ada).

clicast option TARGET_COMMAND_OPTIONS <target command options>

Options used when loading the target.

clicast option TARGET_COMMAND_VERB <download command>

Command prefix, used to invoke the compiler.

clicast option TARGET_CPU ppc603

Used for SingleStep debugger. The name of the “CPU” to be passed to the
“debug” command.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 CLICAST - COMMAND LINE VECTORCAST 19

clicast option TARGET_INTEGRITY_ADDRESS_SPACE_MODE KERNEL | VIRTUAL

For Green Hills Integrity. If this option is KERNEL, then VectorCAST links
the test harness with the OS as a kernel space application. If this option is
VIRTUAL, then VectorCAST links the test harness with the OS as a virtual
address space application. The default value is KERNEL.

clicast option TARGET_INTEGRITY_LIBRARY Full | Gmart | Gstart

For Green Hills Integrity. This option tells VectorCAST which Ada library to
use. If this option is set to Full, the full Ada run-time library will be
used. If this option is set to GMART or GSTART, the reduced run-time library
will be used and the test harness will be built with the appropriate
restrictions. The default value is FULL.

clicast option TARGET_IO_DIRECTORY <directory>

Directory where Input / Output files for target test execution will be
stored. This option should be used when the target does not have read/write
permission for the test environment directory.

clicast option TARGET_SIM_CMD <simulator command>

Command used to execute on the target or simulator.

clicast option TARGET_TFTP_DIR <directory>

This is the directory that the executable files will be copied to so that the
target can be booted via tftp.

clicast option TARGET_USE_RTSERV_COMM True | False

If this option is set, and you are building a Kernel application, VectorCAST
will copy the executable files to the tftp directory, and then prompt you to
manually boot the target board. This option is assumed set if you are
building a Virtual Address Space application.

clicast option TARGET_USE_TORNSERV True | False

Tornado command is tornserv instead of the default torn2serv.

clicast option TARGET_XFER_METHOD serial | ethernet

Method of target data transfer. This option controls the value passes to the
Aonix transfer command when a test is run.

clicast –lc option VCAST_ENVIRONMENT_FILES <path> [, <path> ... ]

<path> is the full path to a file that needs to be copied into the

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 CLICAST - COMMAND LINE VECTORCAST 20

environment directory during environment build. Multiple paths are separated

by a comma. Its default value is set by the compiler template.

For customers using the AAMP/GNAAMP Bare target, the option "Environment Files" specifies
customizable .sod files, which are copied to the environment directory when the environment is built or
rebuilt. As a result, you can modify the original files in the distribution to fit your purposes. The
vcast.sod scripts write directly to VCAST_STDOUT.DAT.

By default, the Environment files are:

$VECTORCAST_DIR/DATA/aamp/facade.cfg
$VECTORCAST_DIR/DATA/aamp/aamp5_sim/vcast.sod
$VECTORCAST_DIR/DATA/aamp/aamp5_sim/vcast_debug.sod

To switch to the board, go to Tools => Options dialog, Target tab and change the text for the scripts to
$VECTORCAST_DIR/DATA/aamp/aamp7_board:

$VECTORCAST_DIR/DATA/aamp/facade.cfg
$VECTORCAST_DIR/DATA/aamp/aamp7_board/vcast.sod
$VECTORCAST_DIR/DATA/aamp/aamp7_board/vcast_debug.sod

clicast option VCAST_FILE_INDEX True | False

If this option is TRUE, VectorCAST uses a file indexing mode that

significantly reduces the file I/O required for running coverage or unit
tests.

clicast option VCAST_GH_INT_CMD <intex command>

When set, VectorCAST will invoke the Green Hills intex utility with this
command immediately after linking the test harness. Refer to the VCAST_GH_
INT_FILE option for information on how to specify a custom integrate file.
Example:

intex -kernel=C:\GHS\int408\sim800\kernel
-bspdir=C:\GHS\int408\sim800
-target=C:\GHS\int408\sim800\default.bsp vcast.int

clicast option VCAST_GH_INT_FILE <intex filename>

This is the custom integrate file passed to the Green Hills 'intex' command.
This file should follow the general format of the default file found in the
VectorCAST installation directory, which means it should contain a 'Filename'
line with the text VCAST_FILE (to be replaced with the VectorCAST executable
name) and a 'StartIt' line with the value 'true'.

clicast option VCAST_GMART_FILE_IO True | False

If this option is TRUE, VectorCAST uses file I/O to communicate with the
target. If FALSE, then VectorCAST uses asynchronous monitor communication.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 CLICAST - COMMAND LINE VECTORCAST 21

clicast option VCAST_PSC_MAKE_FILE_BASE_DIRECTORY <directory path>

This option provides the path to the AE653 build directory containing the
existing partition build. This directory should contain a directory (with the
same name as the Target Board option) containing the files necessary to
complete an executable build.

clicast option VCAST_RAVEN_FILE_IO True | False

Run Raven target using file I/O instead of standard output.

clicast option VCAST_VXWORKS_RTP_MODE True | False

Set this option to run VxWorks executables as a Real-Time process (via the
'rtpSp' command) rather than as a standard process (via the 'ld' and 'sp'
commands).

Deprecated Options

clicast option TARGET_AE653_DATA_DIR <directory_path>

This option provides the path to the "data" component directory in the
Tornado project. After VectorCAST builds the test driver, it will copy the
data program to this directory. This option should be set to a path similar
to: .../data_if_adacast_comp/extbin/PPC604gnu.debug.

This option was deprecated in VectorCAST/Ada version 5.1e.

clicast option TARGET_AE653_UUT_DIR <directory_path>

This option provides the path to the "UUT" component directory in the Tornado
project. After VectorCAST builds the test driver, it will copy the UUT
program to this directory. This option should be set to a path similar to:
.../uut_interface_adacast_comp/extbin/PPC604gnu.debug.

This option was deprecated in VectorCAST/Ada version 5.1e.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

Target Reference
 DDC-I 23

DDC-I
Configuration
The following dialog shows the DDC-I x86 Bare options:

Command Prefix: This is the command string that VectorCAST will use as a prefix for all compiler
commands. By default, this option is set to “pm386”.

Target Execution
The command used to run a target program is pm386_xdebug.

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the "pm386_xdebug" command,
VectorCAST will hang waiting for the termination of the target program. If for some reason you want to
cancel the test execution you should kill the "pm386_xdebug" process that VectorCAST spawns.

To kill this process, use the Unix "ps" command in the window that you initially started VectorCAST
from. Note the process number of the "pm386_xdebug" process, and use the Unix "kill -9" command to
kill that process. VectorCAST will come off its hang and you will be able to continue testing.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT HIE AND ABATRON EMULATOR 24

GNAT HIE and Abatron Emulator

Configuration
The following dialog shows the GNAT HIE Abatron options:

Board Name: This is the name, or the IP address, of the target board. The value entered here will be
used in the vcast_gdb.in script to connect to the target. The value shown in the screen shot will result in
the following line in the vcast_gdb.ini file:

“target remote 192.1.160.30:2001”

Command Prefix: Different versions of the GNAT compiler have different command prefixes for the
basic GNAT commands (gcc, gnatchop etc.). By default, VectorCAST uses the prefix: “powerpc-wrs-
vxworks” for GNAT HIE. If the command prefix for your compiler is different, you must use this option
to set the value.

Execute Command: This is the command string that VectorCAST will use to invoke the gdb debugger
when it is time to run a test case on the target. The script file (vcast_gdb.ini) is generated automatically
by VectorCAST.

Linker Options: In addition to the Target tab options, there are some Linker Options that must be set
manually prior to using VectorCAST with the GNAT HIE compiler.

Certain function implementations that are not part of the GNAT HIE No Runtime environment are
required for VectorCAST testing. These functions are: memcpy, memset, malloc, secondary stack,
and last_chance_handler.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT HIE AND ABATRON EMULATOR 25

You must create versions of these functions, and compile them, outside of VectorCAST. Details about
these functions are provided in the GNAT HIE User’s Guide (sections 3.3, 3.4 and 3.5). Once these
functions are compiled, use the VectorCAST “Linker Options” in the Ada tab of the Tool => Options
dialog, to pass the object files names to the gnat linker.

For example, if you compile the run-time components into a file called: rts_lib.o, you would add the
absolute path to this object file as a link option in VectorCAST. For example:

“C:\HIE_TESTING\extra_stuff\rts_lib.o”

If you need to use a linker command file for your target, this can also be provided via the Linker Options,
using the LD option –T. Simply add the “–T” option to the end of the VectorCAST Linker Options. For
example:

“-T C:\HIE_TESTING\extra_stuff\link.dat”

When running with the GNAT HIE compiler and the Abatron emulator, test case execution is
accomplished using gdb debug scripts. VectorCAST will automatically generate a debug script that will
connect to your target, load the test driver, and execute the test.

When setting up your environment, remember to put the GNAT HIE tools on your path.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT HIE AND ABATRON EMULATOR 26

Target Execution
When executing tests built with GNAT HIE for the Abatron Emulator, test execution is completely
automatic. VectorCAST will generate a gdb script file to control the execution of the test case.

The actual command that is used to execute the target is set by the user in the Target tab of the Tool =>
Options dialog. By default this option is set to:

powerpc-wrs-vxworks-gdb -batch -x vcast_gdb.ini.

The script filename is: vcast_gdb.ini. VectorCAST will automatically generate this file when it needs to
run a test case. For your reference, a sample of this file has been appended to this section.

It is possible for you to modify the default file that VectorCAST generates. To make it simple to modify
the file, VectorCAST creates a “template” of this file called vcast_gdb.tmp. Each time you execute a
test case, VectorCAST will check if the template file exists. If it does, VectorCAST will copy the
template file into the gdb script file (vcast_gdb.ini), and then execute the test. If the template file does
not exist, VectorCAST will generate the template file, copy it into the gdb script file, and then execute
the test. The purpose of this mechanism is to enable the user to edit the template file if necessary. After
editing, the changed file will be used for test case execution.

If you edit the template file and then want to go back to the default, just delete the template file and then
run a test case.

The beginning of the script file is dynamically created for one specific test environment. It has the
commands to connect to the target, and to load the executable. This part of the file is delimited by the
comments: “Start Dynamic part of .ini file” and “End Dynamic part of .ini file”.

The rest of the script file is static. It is the same for every test environment. The static portion is
delivered as a text file in the VectorCAST installation area. This file is located in the VectorCAST install
directory\DATA\vcast.ini.

If you make changes to the vcast.ini file form the install directory, the changes will affect all new
environments that are built subsequent to the change.

Sample vcast_gdb.ini file

# This file is a gdb initialization file that is used
# to control VectorCAST test execution via the gdb debugger.
#
# This file is delivered as source code in the
# VECTORCAST_DIR/DATA subdirectory of the VectorCAST
# installation directory.
#
# This file is currently used for the HIE version
# of the GNAT Ada compiler.
#
# The way that this file is used is controlled via
# the "Execute Command" option in the Target
# tab of the Tool -> Options dialog.
#
# By default, this ini file is passed to the gdb debugger

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT HIE AND ABATRON EMULATOR 27

# using syntax similar to the following:

# gdb -batch -x vcast.ini name_of_executable_file
#
# This file is copied into the test environment directory
# when the test environment is first built.
# You can edit this local version of the file to
# affect one test environment, or edit the version
# in the VectorCAST install directory to affect all users.
#

# This is a breakpoint on the last function that is called

# by the VectorCAST driver. This breakpoint is needed so
# that the output buffer can be dumped.
#
break data_pkg_adacast.write_end_file

# Start the Ada program running

#
continue

#
# Here is where the breakpoint will occur.
#
finish

# This command sets a limit to the maximum characters to be printed

# The value used should be the size of the VCAST_OUTPUT_BUFFER
# string that is defined in the ADACAST_IO package
# VECTORCAST_DIR/IO/ADACAST_.HIS.
#
# After the breakpoint, we set the print elements value
# to be the size of the actual buffer created during
# the test run. This ensures that no "extra" characters
# are dumped.
#
set print elements adacast_io.vcast_output_buffer_ptr

# This command ensures that gdb does not use the <repeat x times>
# syntax when dumping the output_buffer
#
set print repeats adacast_io.vcast_output_buffer'last

# This command forces the output to be one character/line

#
set print array on

# Echo a string at the start of the output buffer so that

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT HIE AND ABATRON EMULATOR 28

# VectorCAST can easily parse this data after the test run
#
echo \n
echo VCAST Buffer Start\n

# output the test buffer in unsigned decimal integer format

#
output/u adacast_io.vcast_output_buffer(1..adacast_io.VCAST_OUTPUT_BUFFER_PTR)

# Echo a string at the end of the output buffer so that

# VectorCAST can easily parse this data after the test run
#
echo \n
echo VCAST Buffer End\n

# Quit (and confirm) from the debug session

#
quit
yes

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the debug script, VectorCAST
will hang waiting for the termination of the debugger program. If for some reason you want to cancel the
test execution you should kill the "gdb" process that VectorCAST spawns. This actual gdb application
name will be the one that you configured in the VectorCAST Target options.

By default the gdb command is:

powerpc-wrs-vxworks-gdb

Unix:
Use the "ps" command in the window that you initially started VectorCAST from. Note the process
number of the "gdb" process, and use the Unix "kill -9" command to kill that process. VectorCAST will
come off its hang and you will be able to continue testing.

Windows:
Use the Windows Task Manager to locate and terminate the "gdb" process.

Running with Debugger

To debug test harness execution, you must edit the vcast_gdb.tmp file to add additional debug
instructions. For example, you could add a breakpoint to the continue command.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT VXW ORKS 29

GNAT vxWorks
Configuration
The following dialog shows the GNAT vxWorks options:

Board Name: This is the name of the Tornado target server for the target board.

I/O Directory: This is an optional string to tell VectorCAST to use a directory other than the
environment directory for file I/O with the target. The target and host must be able to share files. By
default VectorCAST tells the target to use the test environment directory for I/O. The target must have
read and write permission to the I/O directory. By using this options, you can use a common world-
writable directory for doing target I/O rather than changing the permissions on your environment
directory.

Command Prefix: Different versions of the GNAT compiler have different command prefixes for the
basic GNAT commands (gcc, gnatchop etc.) By default, VectorCAST uses the prefix: “powerpc-wrs-
vxworks”. If the command prefix for your compiler is different, you must use this option to set the value.
As an example, the command prefix for GNAT for vxWorks AE is: “powerpc-wrs-vxworksae”.

Boot Hostname: This is the name that the Boot Host that is set on the target. If this name is the same
as the name of the workstation running VectorCAST, this option is not needed.

Use Target Server File System (TSFS): The Target Server File System is a VxWorks file system, but
the files operated on by VxWorks are located on the host. To use this option, TSFS must be included in
your VxWorks image and the target server must be configured for TSFS. You must rebuild this
VectorCAST environment after checking or unchecking this option.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT VXW ORKS 30

When running with the vxWorks run-time, test case execution involves minimal manual steps. You
must boot the target processor and start a target server. After doing this you can run multiple tests
without any additional interaction with the target hardware. See "Target Execution " on page 67for an
overview of starting up and running vxWorks with VectorCAST.

When setting up your environment, remember to put both the GNAT tools and the Tornado tools on your
path, since VectorCAST will need to interface with both.

Target Execution
For executing tests built with GNAT or ObjectAda, VectorCAST uses the Tornado tool windsh to
control the download to the target and the test execution. The target board must be "booted” with
vxWorks. Once this has been done, multiple executables can be downloaded and run on the target
without additional reboots. When VectorCAST is ready to run on the target for the first time, it will
present a dialog box similar to the following:

If the target has already been booted and is ready to accept downloads, simply click OK. Otherwise
boot the target and start a target server process. When you select OK VectorCAST will use the Tornado
"windsh" command to download and start the execution of the target program.

The following is an overview of starting up and running vxWorks:

1. Boot the target.

2. Start tornado using the "launch” command on Unix or the Start Menu on Windows.
3. Within tornado create a target server and start it running.
4. Select this target from the list and start windsh.
5. Verify that the windsh initializes successfully.
6. Start VectorCAST.
7. Within VectorCAST, set the target board name to the name of the target server created in tornado.
8. Perform testing.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT VXW ORKS 31

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the "windsh" command,
VectorCAST will hang waiting for the termination of the target program. If for some reason you want to
cancel the test execution you should kill the "windsh" process that VectorCAST spawns.

Unix:
Use the "ps" command in the window that you initially started VectorCAST from. Note the process
number of the "windsh" process, and use the Unix "kill -9" command to kill that process. VectorCAST
will come off its hang and you will be able to continue testing.

Windows:
Use the Windows Task Manager to locate and terminate the "windsh" process.

Running with the gdb Debugger (vxWorks)

VectorCAST RSP supports the execution of tests using the gdb debugger. Running under control of the
debugger is accomplished by booting the target as you would without the debugger, and then right-
clicking on the test case name and selecting "Execute with Debug".

VectorCAST will put up a dialog that looks similar to this:

VectorCAST does not currently start the debugger automatically. You must manually start the debugger
in the environment directory using the instructions in the dialog. When you are done debugging, select
the OK button in the VectorCAST dialog and all the normal test execution reports will be built.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT VXW ORKS 32

Refer to the GNAT documentation for complete information on running an executable under control of
the debugger.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT VXW ORKS AE653 33

GNAT vxWorks AE653

Overview
The following sections describe how to configure VectorCAST and run test cases for the vxWorks
AE653 environment. The VectorCAST-vxWorks RSP works the same for both simulator and hardware,
regardless of the underlying CPU being targeted. Although the examples used in this section are
specific to a PPC target, they can easily be adapted to other target CPUs.

Before using VectorCAST with vxWorks, you must have a vxWorks target or a vxSim simulator
booted, and a target server running. Additionally, you must be able to attach to the target using the
“windsh” shell application. Both the WindRiver toolset and the GNAT toolset (including the GPRbuild
application) should be accessible from the command line.

All of the variations involved in booting and configuring a vxWorks target are beyond the scope of this
guide. For the sake of simplicity, we will configure VectorCAST to use an actual target server
connection.

Target Execution
For application partition testing, the application has to be built, together with the kernel, into a monolithic
image that the target boots. To support this, VectorCAST delivers a vxWorks 653 project with the
VectorCAST distribution that you can use to create your test environments.

To run with vxWorks 653, use the .zip file provided in the VectorCAST installation directory
(%VECTORCAST_DIR%\DATA\WindRiver). The VectorCAST_SinglePartition_Ada.zip file enables
you to build an application partition and execute on the live board. In our example, we are using a WRS
SBC83XX PowerQUICC II Pro development board.

Note: You may notice a .bat file associated with the .zip file in the directory. VectorCAST uses
this file internally when running the make command.

The following section takes you through the steps required to use the single partition project to build and
execute a VectorCAST test environment for the target.

In preparation, create a new directory (such as c:\vcast_target_testing), copy the file VectorCAST_
SinglePartition_Ada.zip to this directory, and then unzip it.

1. Start a new vxWorks 653 Development shell (Start => WindRiver => vxWorks 653 2.2 for PPC
=> vxWorks Development Shell).
2. In the shell window, execute the following commands (click “Yes” to allow overwriting if you see
any errors regarding that):

cd c:\vcast_target_testing\singlepartition
make BSP=wrSbc834x CPU=PPC603 create
make BSP=wrSbc834x CPU=PPC603 create mosbuild posbuild
set VCAST_PSC_USE_ADDRESS_SPACE=true
mkdir c:\vcast_target_testing\io_directory
cd \vcast_target_testing

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT VXW ORKS AE653 34

3. Start VectorCAST and choose File => Set Product Mode => Ada Target Environment => PPC
GNAT vxWorks AE653
4. In the Tools => Options dialog, Target tab, set the “Board Name” to tgt_wrsbc@<hostname>
where <hostname> is the hostname of the machine you are working on.

Note: The name of your target server will be different. You will only know the exact target
server name after Step 12. We use the name tgt_wrsbc@<hostname> as a placeholder.

5. Set the I/O Directory to C:\vcast_target_testing\IO_DIRECTORY

6. Set the command prefix to powerpc-wrs-vxworksae (this is the default value)
7. Set the vxWorks AE653 Build directory to C:\vcast_target_testing\SinglePartition
8. The vxWorks AE653 make file command should be set by default. Replace the placeholders
<board>, <cpu>, and <partaddr> with the appropriate values. (You can also change the binding
and runtime options away from their defaults of “apex” and “cert”). In our example, the option looks
like: $(VECTORCAST_DIR)\data\windriver\make_ada_653_partition.bat wrSbc834x PPC603
0x40000000 apex cert
9. Build a simple test environment using the manager tutorial files from the VectorCAST Tutorial
directory. Insert a test case and execute it. (The source code must have been previously compiled
external to VectorCAST).
10. When VectorCAST is ready to execute on the target, you see this message:

Once you have completed the following steps to create the target connection, come back to this
dialog and click OK.
11. Open the WindRiver WorkBench IDE, and create a new target connection for a vxWorks 653
Target Server.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT VXW ORKS AE653 35

12. For the boot filename, browse to:

C:\vcast_target_testing\SinglePartition\wrSbc834x_
SinglePartition\integration\boot.txt

and then click Next.

13. For the Target Server Options, you need to browse to: C:\vcast_target_
testing\SinglePartition\wrSbc834x_SinglePartition\integration\boot.txt

You also need to change the -R option to match the VectorCAST option for IO_Directory. It should
be:

-R C:\vcast_target_testing\IO_Directory

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT VXW ORKS AE653 36

14. Click Next four times to accept the default options for everything else, and then click Finish to
create the target.
15. Right-click on the new target, and select “Connect.”

Note: If the target server name is not tgt_wrsbc@<hostname> you will need to go back to
the VectorCAST Tools => Options dialog, Target tab, and change the board name to the
correct value.

16. In VectorCAST, click OK in the previously displayed dialog.

At this point the test executes. To run the next test case, you do not have to recreate the vxWorks
target, you simply can type reboot into the target shell window when prompted by VectorCAST to
reboot the target.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT ERC32 WITH TSIM SIMULATOR 37

GNAT ERC32 with TSIM Simulator

Configuration
The following dialog shows the Simulator options:

Command Prefix: Different versions of the GNAT compiler have different command prefixes for the
basic GNAT commands (gcc, gnatchop etc.). By default, VectorCAST uses the prefix: “erc32-elf” for
GNAT ERC32. If the command prefix for your compiler is different, you must use this option to set the
value.

Execute Command: This is the command string that VectorCAST will issue to start the simulator. It
DOES NOT include the name of the executable program. VectorCAST will add this automatically.
VectorCAST will preset this to the minimum required command string. You may use this option to add
command options, as required. You must replace the <ip-address> placeholder with the IP address of
the computer where the TSIM simulator resides, and the <destination-dir> placeholder with the full path
to the directory on that computer from where the simulator will run.

The “run_erc32_tsim.sh” file is a shell script that copies the harness executable and a debug script to
the simulator host machine, and then runs the simulator in the specified machine. The “tsim_cmds.lst”
is a simulator script that will load the harness executable, run the test case, and then exit. Both of these
files can be edited by the user if necessary.

Target Execution
The execution of VectorCAST test cases using the TSIM simulator with GNAT ERC32 is completely
automatic. Running an instruction set simulator is functionally equivalent to running VectorCAST/Host.
The only difference is that test cases will run slower than in native mode since the simulator adds
another layer of abstraction to the executing program.

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the execute command,

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GNAT ERC32 WITH TSIM SIMULATOR 38

VectorCAST will hang waiting for the termination of the target program. If for some reason you want to
cancel the test execution you should kill the process that VectorCAST spawns. This is most easily
accomplished by logging on to the machine hosting the simulator and use the "ps" command. Note the
process number of the simulator process and use the Unix "kill -9" command to kill that process.
VectorCAST will come off its hang and you will be able to continue testing.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS GMART OR GSTART 39

Green Hills GMART or GSTART

Configuration
The following dialog shows the GMART and GSTART options:

Build File: This option will be used by VectorCAST as the “-driver” argument to the Green Hills builder.

Execute Command: This is the command string that is used to execute a test. There are three
different default commands that VectorCAST will use for this option:

Use file I/O for target communication: This tells VectorCAST to use file I/O for communication with
the target. This is the fastest way to execute a test in the GMART/GSTART environment. The default
for this option is ON. If you turn off this option, VectorCAST uses asynchronous I/O across the debug
interface.

Before building a VectorCAST environment for the GMART Ada Run Time, you should ensure that your
code under test is compiled into an Ada library that references the GMART version of the Green Hills
pre-defined library. You can check this by looking at the ADA.LIB file and ensuring that it contains and
entry similar to this:

“ELABPATH: /opt/GHS_35/adalib_gmart”

Also prior to building, you must configure VectorCAST with the name of the AdaMulti “build” file that is
appropriate to your environment, and the linker option to include the GMART utility library into the

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS GMART OR GSTART 40

executable. Both of these option are set automatically by VectorCAST when you select the GMART
target. They can be modified using the VectorCAST Tools => Options menu choice to display the
Options dialog.

The build file is entered into the Target tab. Note that you DO NOT enter the “.bld” extension for this
option ("ppc_gmart" has been entered in this example).

The linker option is entered in the Ada tab, in the Linker Options area. The value should be –
ladagmartutil –lind -larch. This tells Multi to link in the file utility libraries that are needed for test
execution with VectorCAST.

For test case execution you must set up the command string that will allow VectorCAST to execute on
the target or the simulator. This value is set by default to use the Green Hills PPC simulator.

Target Execution
For test case execution with GMART you must set up the command string that will allow VectorCAST
to execute on the target or the simulator. This command string is set in the Target tab of the
VectorCAST Options dialog.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS GMART OR GSTART 41

In the above example, the Execute Command is set to the default value: grun simppc -ppc603 -dec --.
“grun” is a Green Hills utility that allows target connections to be made outside of the Multi GUI. The
“grun” and the double dashes “--“ delimit the target attachment command, in this case: “simppc –ppc603
–dec”. If you were to run on a live target using the OCD probe and your board was an mbx860, you
might change the command to be: “grun ocdserv rlpt1 ppc860 -s /home/GHS/mbx800/mbx800.ocd –“

For a full description of the options associated with the grun, simppc, ocdserv, hpserv or other Green
Hills commands please consult the Green Hills product documentation.

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the "grun" command,
VectorCAST will hang waiting for the termination of the target program. If for some reason you want to
cancel the test execution you should kill the "grun" process that VectorCAST spawns.

Unix:
Use the "ps" command in the window that you initially started VectorCAST from. Note the process
number of the "grun" process, and use the Unix "kill -9" command to kill that process. VectorCAST will
come off its hang and you will be able to continue testing.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS GMART OR GSTART 42

Windows:
Use the Windows Task Manager to locate and terminate the "grun" process.

Running with the AdaMULTI Debugger (GMART)

VectorCAST RSP by default, uses an I/O monitor to communicate with the test harness. When
operating in this mode, VectorCAST does not support the execution of tests using the AdaMULTI
debugger. The reason for this, is that the AdaMULTI debugger does not have the capability to map the
standard input and output to pipes or files. As a result, the test input and result data cannot be captured.

If you wish to use the AdaMULTI debugger, you must set the VectorCAST environment variable:
VCAST_GMART_FILE_IO to true prior to building a test environment. Once you have set this variable,
and built a new environment, you will be able to run test cases with the AdaMULTI debugger. When this
variable is set, VectorCAST builds the test environment with low-level file I/O features built in. This
enables test execution with debug to occur.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 43

Green Hills INTEGRITY

Configuration
The following dialog shows the INTEGRITY options:

Build File: This option will be used by VectorCAST as the “-driver” argument to the Green Hills builder.
It is also used by VectorCAST when “integrating” a Virtual Address Space application.

TFTP Boot Directory: This option tells VectorCAST what the default TFTP boot directory is on your
platform. If the “Use Green Hills rtserv for target communication” option is on, VectorCAST will copy
the executable files into the tftp Boot Directory. This is the host based directory from which the target
board will be booted (normally this will be /tftpboot).

Execute Command: This is the command string that is used to execute a test. There are three
different default commands that VectorCAST will use for this option, based on the Address space type:

Kernel: grun isimppc -X83 -dec --

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 44

Monolith: $(VECTORCAST_DIR)\IO\pty
$(VECTORCAST_DIR)\IO\monitor_stdout isimppc -X83 -ada --
Virtual: rtserv -X8 -X14 -run "vcast.Initial" -load vcast.mod -port
udp@localhost

Use INTEGRITY drivers to build: If this option is set, VectorCAST will use acintppc to compile, and
cxintppc to link the test harness. This option is required for GHS compilers version 4.0.5 or newer.

INTEGRITY driver options: Located directly below the “Use INTEGRITY drivers to build,” this option
is used to set the –os_dir and –bsp options for the acintppc and cxintppc commands.

Green Hills intex utility command: This option specifies the complete command used to integrate a
monolithic download build. The “ada_monolith.int” file specified is copied from the VectorCAST
installation directory.

Green Hills integrate file: This option specifies the custom integrate file passed to the Green Hills
‘intex’ command. This file should follow the general format of the default file found in the VectorCAST
installation directory, which means it should contain a ‘Filename’ line with the text VCAST_FILE (to be
replaced with the VectorCAST executable name) and a ‘StartIt’ line with the value ‘true’.

Unload mod file after each test: This option forces VectorCAST to explicitly “unload” the test driver
module after executing a test. This option should be set if back-to-back test executions with rtserv are
not working.

Use rtserv for target communication: If Virtual Address Space linking is enabled, this option is
assumed to be on.

This option applies to Kernel space linking only. For Kernel space applications, if this option is turned
on, VectorCAST will assume that the user will manually boot the target using tftp. When a test is to be
run on the target, VectorCAST will copy the executable file to the tftp boot directory, and put up a dialog
prompting the user to boot the target.

Call syscall (exit) at end of test: When this option is set, VectorCAST will build a system call into the
harness to exit the kernel when the harness has finished (only useful in “Kernel” mode).

Address space: This option tells VectorCAST how to build the executable test harness, and also (in
combination with the Execute Command and rtserv option, how to run it). Also, when this option is
changed, the execute command will be set to the default as listed above.

If this option is set the Kernel (which is the default), the Green Hills builder will be invoked with the
option: “:integrity_option=kernel”.

If this option is set to Virtual, the builder will be invoked with the option: “:staticlink=true”.

When the option is set to “Monolith”, a monolithic download (which requires integrating a kernel with the
harness application) will be built.

Ada Runtime: This option tells VectorCAST what Ada runtime to link with the test harness. If you
choose GMART or GSTART, it also tells VectorCAST to construct a test harness that conforms to the
GMART/GSTART runtime restrictions.

Configuration Differences for Live Board

To use this RSP with a live board, follow the configuration instructions above, and then modify the
options listed below for use with your specific live board. The following example is for a Freescale

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 45

MPC5554EVB target.

The changed options are on the Target tab and the Ada tab of the Options dialog.

Target tab options

Build File: This option will be used by VectorCAST as the “-driver” argument to the Green Hills builder.
It is also used by VectorCAST when “integrating” a Virtual Address Space application.

Execute Command: This is the command string that is used to execute a test. VectorCAST supplies a
“.bat” file that can start AdaMulti in automatic mode. The batch file takes any number of commands,
which must specify the target connection string (using the “-remote” option) and the debug playback file
(using the “-p” option). For the board being used in this example, the option is:

$(VECTORCAST_DIR)\DATA\green_hills\multi_execution_generic.bat adamulti -nosplash -remote

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 46

\"setup=c:\ghs\int509\mpc5554\mpc5554.mbs mpserv ghprobe\" –p

$(VECTORCAST_DIR)\DATA\green_hills\multi_playback_file_ada.p

INTEGRITY driver options: Located directly below the “Use INTEGRITY drivers to build,” this option
is used to set the –os_dir and –bsp options for the acintppc and cxintppc commands. For the board
being used in this example, option is:

-os_dir c:/ghs/int509 -bsp mpc5554

Ada tab options

Linker options: This option is used to specify the full path to the Linker Definition (.ld) file that has
been modified to match your configuration. (VectorCAST provides an example .ld (mpc5554evb_ada.ld)
file for the Freescale MPC5554EVB live board in the DATA/green_hills folder inside the VectorCAST
installation directory.) For the board being used in this example, the option is:

--ada_library_full -kernel $(VECTORCAST_DIR)\data\green_hills\mpc5554evb_ada.ld

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 47

Note: Due to memory size constraints on certain targets, the VectorCAST harness may be too
large to fit into the available memory map. In that case a linker error will occur with a message
indicating section limit exceeded. Some mechanisms to reduce the size of the harness are:
l Add -OSpace to the compiler options to force optimization for space efficiency
l Change the “Maximum string length” parameter (on the Target tab of the Options
dialog) to 100 to reduce the size of default string objects
l Change the “Maximum varied parameters” option (on the Builder tab of the options
dialog) to 5 to reduce the size of the structure used to store range information
l Remove all User Globals from the Environment User Code

Target Execution
When running with the INTEGRITY RTOS, there are a variety of ways to execute a test case. The
method that you use, will be dependent on the configuration of your target board, or simulator. If you are
building the test harness as a kernel space application and using rtserv to connect to the target, there
will be some manual steps required. In this case, VectorCAST will prompt you with a dialog when any
manual intervention is required. The dialog is very specific as to the steps required.

Using the Integrity Simulator and a Monolithic build

When building a Monolithic download application, VectorCAST uses the Green Hills “intex” command
to integrate a kernel and the address space in which the harness will run. VectorCAST supplies a
default integrate file in the installation directory’s DATA folder called “ada_monolith.int”. If the user
needs special integrate options, or a user-specified kernel, they need to edit this file before building the
environment.

Using the Integrity Simulator and a Kernel Address Space

Before running on the target using the Green Hills tools, you must configure VectorCAST for the type of
target communication that you are using. This information is provided via the "Target" tab in the Tools
=> Options dialog. By default, the options are set to enable you to execute with Green Hills Integrity
simulator. We recommend that you start out with the simulator to become familiar with VectorCAST
test execution. In this mode, running a test case is completely automatic.

When you first select the Integrity target, all of the options that are required for you to build a test
environment and run a test case are set automatically by VectorCAST. The options that are set, and the
values they are set to are as follows:

On the Target tab, the Build File is set to: sim800; the Execute Command is set to: grun isimppc -X83 -
dec --, Full Ada Runtime, and Address Space: Kernel.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 48

On the Ada tab, the Compiler options and Linker options are set to: -cpu=ppc860.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 49

If you are using Integrity version 4 or greater, the Integrity distribution is not shipped with the Ada
compiler driver (acppc). As a result, the VectorCAST calls to the compiler acppc will fail, or invoke the
wrong version of the compiler if you happen to have two versions of the Green Hills tools on your
system path. To resolve this issue, you must create the acppc driver in the Green Hills distribution area.
To do this on Windows, just copy the ccppc.exe file into acppc.exe. On Unix, copy the ccppc script file
into acppc, and add the following options to the builder invocation: :language=ada -c. So the full
command line that should exist in the acppc file is as follows:

exec ${ghsdir}build -name_or_board $0 ppc ppc generic standalone :language=ada -c "$@"

Using the Integrity Simulator and a Virtual Address Space (VAS)

If you would like to run the test harness as a VAS application, you need to change some of the default
options. In the Target tab of the Tool => Options, you need to change the Address Space option radio
button to: “Virtual”.

If you change the Address Space from Kernel to Virtual, after you have already built a VectorCAST test
environment, you must use the VectorCAST command Environment => Relink to relink the test
harness before you can run any test cases. A relink is needed because changing the Address Space
option causes different build options to be passed to the Green Hills builder. When you build for VAS,
VectorCAST passes “:staticlink=true” to the builder; for kernel mode, VectorCAST passes “:integrity_
option=kernel”

When you change the Address Space option, VectorCAST will automatically change the Execute

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 50

Command to the default rtserv command that is needed for VAS applications.

The Execute Command will be set to:

rtserv -X8 -X14 -run "vcast.Initial" -load vcast.mod -port udp@localhost

Before you can run a test case in this mode, you will need to start the Integrity simulator. If you are
running the Integrity simulator on the same machine that VectorCAST is running on, the default
Execute Command will be correct. If you are running the Integrity simulator on a remote machine, you
will need to change “localhost” to be the hostname of the remote machine.

In this mode, running a test case is completely automatic. The only message that you will see to
indicate that you are running in VAS mode, is an additional status message in the VectorCAST
message tab when the test runs, indicating an “Integration” command that is run prior to test execution.
The message window, when running a test will look similar to the following:

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 51

Using rtserv with a Kernel Space Application

If you normally use tftp to boot your target, you will need to select the: “Use Green Hills rtserv for target
communication” checkbox, and the Kernel Address Space option as shown in the following dialog:

When you execute a test case with the “Use rtserv” option selected, you will manually boot the target
for each test execution. VectorCAST will copy the executable file into the directory that you set with the
“tftp Boot Directory” option, and then wait for you to boot the target. The following dialog will be
displayed:

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 52

The normal sequence of steps required to boot the target using ppcbug is as follows:

1. Establish a "tip" connection from the host to the target.

2. Use the "niot" command to set the path to the executable file.
3. Use the "nbo" command to boot the target.
4. Select the "OK" button in the VectorCAST dialog.

So that you do not have to constantly change the target boot parameters, VectorCAST always uses the
same names for the target executable file: “vcast.bin” is a hex-formatted version of the executable,
“vcast.elf” is an ELF-formatted version, and “vcast.srec” is an s-record formatted version. Also, you can
control the directory that VectorCAST stores the executable file into by using the Target tab of the Tools
=> Options dialog, to change the “tftp” directory.

After the target is booted, you will select OK in the dialog, and VectorCAST will attach to the target
using the Execute Command option. By default, the Execute Command is set to: rtserv -run "Initial" -
port udp@localhost, you will need to modify the “localhost” to reflect the hostname of your target.

Stopping a Test Execution

Once the target is booted and VectorCAST starts the target running via the "rtserv" command,
VectorCAST will hang waiting for the termination of the target program. If for some reason you want to
cancel the test execution you should kill the "rtserv" process that VectorCAST spawns.

Use the "ps" command in the window that you initially started VectorCAST from. Note the process
number of the "rtserv" process, and use the Unix "kill -9" command to kill that process. VectorCAST
will come off its hang and you will be able to continue testing.

Windows:
Use the Windows Task Manager to locate and terminate the "rtserv" process.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 53

Running with the Green Hills Debugger

VectorCAST RSP supports the execution of tests using the AdaMULTI debugger. Running under
control of the debugger is accomplished by right-clicking on the test case name and selecting "Execute
with Debug".

Refer to the Green Hills AdaMULTI documentation for complete information on running an executable
under control of the debugger.

Target Execution with Green Hills Multi Debugger

When running a test case under control of the Multi debugger, VectorCAST will display a dialog similar
to the following:

This dialog provides all of the information that you need to use Multi to attach to your target, or
simulator, load the test harness executable, and execute a test. After you select OK in this dialog,
VectorCAST will automatically start Multi and load the executable file if possible.

The name of the executable file (in the above screen shot, the name is UUT_INST) will change
depending on the type of test. When VectorCAST is doing a test execution with coverage the name will
be “UUT_INST”, and when you are doing a test execution without coverage the name will be: “UUT_
INTE”. Be aware of this, if you must manually load the file, and choose the correct filename.

The following Green Hills Multi screen shots show a nominal debug test case execution:

1. The Ada Multi IDE will appear automatically, in the Multi IDE, select the “Target” Menu or
“Remote” Menu (depending on the version of Multi), and then “Connect to Target.”

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 54

2. Next, enter your target connection command, or select a previously used command from the list.
For example: enter “isim –X83 -dec” to use the integrity simulator.
3. If the driver file is NOT displayed, select the “File” or “Debug” menu and select “Debug Other",
then Browse for the name of the file that VectorCAST asked for. In this example the filename is
UUT_INST.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 55

4. After clicking on “Debug” the Multi debugger window will show the VectorCAST driver program.
The window may initially come up with some assembly code rather than the start of the
VectorCAST driver procedure. If this happens, and you want to debug your test, simply type:
“e UUT_INTERFACE_ADACAST” in the command pane, which brings up the source code for the
VectorCAST driver.

5. To run the test without breakpoints or stepping simple click on the “GO” button
6. When the test completes there the status line in the Multi Debugger indicating the termination of
execution: /home/TEST/ULTRA/INTEGRITY/TEST/UUT_INST completed normally.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS INTEGRITY 56

7. At this point you should close the Multi debugger window. VectorCAST will sense the termination
of the Multi debugger, and will build its test execution report just as if you had run the test without
debug.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS VXW ORKS 57

Green Hills vxWorks

Configuration
The following dialog shows the vxWorks options:

Board Name: This is the host name of the target board. The name should resolve to the target IP
address. This is the name of the target that will be passed to "tornserv".

I/O Directory: This is an optional string to tell VectorCAST to use a directory other than the
environment directory for file I/O with the target.

Tornserv options: This is an optional string to allow you to pass command line options to the Green
Hills tornserv tool. See the Green Hills documentation for more information.

Use Tornado Server: This option tells VectorCAST to invoke Green Hills tornserv to connect to the
target, rather than torn2serv. This option should be set only if you are using the older Tornado 1.x tools.

Old Green Hills: This option controls the name of the entry point for tornserv. When it is on, the entry
point is forced uppercase. Check this option if you are using the Green Hills vxWorks compiler version
1.8.8 or below.

Use Target Server File System (TSFS): The Target Server File System is a VxWorks file system, but
the files operated on by VxWorks are located on the host. To use this option, TSFS must be included in
your VxWorks image and the target server must be configured for TSFS. You must rebuild this
VectorCAST environment after checking or unchecking this option.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS VXW ORKS 58

Target Execution
The execution of VectorCAST test cases using vxWorks requires that the target board be “booted,” with
vxWorks and downloaded with the Ada run-time kernel (adalib.o). Once this has been done, multiple
executables can be downloaded and run on the target without additional reboots.

When VectorCAST is ready to run on the target, it will present a dialog box similar to the following:

If the target has already been booted and is ready to accept downloads, simply click OK. Otherwise
boot the target and download the Ada run-time (adalib.o). When you select OK, VectorCAST will use
the Green Hills "torn2serv" command to start the execution of the target program.

The following is an overview of starting up and running vxWorks with VectorCAST RSP:

1. Set up a default directory in the target boot script to be the default working-directory for the target
process. The directory should allow world read and write.
2. Boot the target.
3. Start tornado using the "launch" command.
4. Within tornado, create a target server.
5. Select this target from the list and start windsh.
6. Enter: "moduleshow" in the windsh and check if the adalib.o file is already downloaded, if not
download it from the Green Hills distribution are using the "ld <file_location>" command.
7. Start VectorCAST.
8. Within VectorCAST set the Target board name to the target server created in Tornado, and set the
Target I/O directory to the directory created in step 1.
9. Perform testing.

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the "torn2serv" command,

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 GREEN HILLS VXW ORKS 59

VectorCAST will hang waiting for the termination of the target program. If for some reason you want to
cancel the test execution you should kill the "torn2serv" process that VectorCAST spawns.

Unix:
Use the "ps" command in the window that you initially started VectorCAST from. Note the process
number of the "torn2serv" process, and use the Unix "kill -9" command to kill that process. VectorCAST
will come off its hang and you will be able to continue testing.

Running with the AdaMULTI Debugger (vxWorks)

VectorCAST RSP supports the execution of tests using the AdaMULTI debugger. Running under
control of the debugger is accomplished by booting the target as you would without the debugger, and
then right-clicking on the test case name and selecting "Execute with Debug". Refer to the Green Hills
AdaMULTI documentation for complete information on running an executable under control of the
debugger.

The following is the nominal sequence for running the Multi debugger:

1. In the Green Hills builder window enter: "torn2serv <board name>" next to the "REMOTE" button.
2. Click on remote.
3. A task window and a debug window will come up, you must exit the debug window, and you may
exit the task window.
4. In the builder window, Select REMOTE => LOAD MODULE from the menu.
5. Use the browser to select the directory TESTTEST, and then executable "uut_interface_
adacast".
6. The debug window will reappear with the source code for the AdaCAST test driver (uut_interface_
adacast).
7. Use the debug window to set breakpoints.
8. Run your program by typing "runtask UUT_INTERFACE_ADACAST_main" in the command
pane of the debugger window.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 OBJECT ADA RAVEN FOR PPC 60

ObjectAda Raven for PPC

Configuration
The following dialog will be displayed if PPC Aonix Raven is chosen:

VectorCAST allows all parameters associated with the target boot and download to be set via the Tools
=> Options dialog. It is important for you to configure VectorCAST with the correct “board name” and
the appropriate “transfer method” prior to building a test environment or running a test.

Board Name: The board name should be the hostname by which your board is known on your network.
The name provided should resolve to the target IP address from the host’s file.

Transfer Method: This is the communication mechanism used for downloading the board.

Use Raven File I/O: Run Raven target using file I/O rather than standard output.

When running with the Raven run-time on PPC hardware you must manually boot the target board with
the Aonix monitor program. Once the monitor program is loaded, VectorCAST can download its test
harness to execute your test cases using the Aonix “transfer” utility.

If you are using a Motorola VME board, you will generally boot the target monitor program using the
"ppcbug" utility and the "tftp" protocol. Refer to the Aonix product documentation for complete
information.

Once the target is booted with the Aonix monitor program, you can run multiple VectorCAST test cases

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 OBJECT ADA RAVEN FOR PPC 61

without having to reboot. Rebooting is only necessary if the target crashes during test case execution.

Target Execution
The execution of VectorCAST test cases using Raven requires that the target board be "booted" with
the Aonix monitor program (for PPC).

If you are using ethernet to communicate with the target, VectorCAST will check if the target is booted
by attempting to "ping" the target that you selected using the "Board Name" VectorCAST option. If the
target is alive no user action is required. If VectorCAST cannot ping the target the following dialog is
displayed:

If you get this dialog, you should boot the target with the Aonix monitor program so that VectorCAST
can download and run an executable on the target.

The following is a nominal sequence:

1. Establish a "tip" connection from the host to the target, or use the dedicated console hooked to the
target.
2. Use "niot" to set the ftfp boot parameters including the path to the monitor executable file.
3. Use the "nbo" command to boot the target.
4. Select the "OK" button in the VectorCAST dialog.

When you select OK, VectorCAST will use the Aonix ObjectAda transfer command to start the
execution of the target program.

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the "transfer" or "runemb"
command, VectorCAST will hang waiting for the termination of the target program. If for some reason
you want to cancel the test execution you should kill the "transfer" or "runemb" process that
VectorCAST spawns.

To kill this process, use Windows Task Manager to locate and terminate the "transfer" or "runemb"
process. VectorCAST will come off its hang and you will be able to continue testing.

Running with a Debugger

When VectorCAST compiles with the ObjectAda compiler, debugging of the executable is not permitted
because VectorCAST has not created an ObjectAda project – this must be done manually.

1. The first step is to create the VectorCAST environment, then create a VectorCAST compile
script. This gives a list of the VectorCAST files used for the environment. You only need the files

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 OBJECT ADA RAVEN FOR PPC 62

up to where the first build command is executed in the VectorCAST script. The files after that are
duplicated or not needed.
2. Create an ObjectAda Debugger project. It makes the most sense to place this inside the
VectorCAST environment. The files for the debugger are sitting here, and easy to put into the
debugger project.
3. Import all of the files from the build script into the debugger project.
4. Select the "Project -> Settings" menu item in the ObjectAda project.
5. Select the "Search" tab. Put in the path to the VectorCAST environment "TESTTEST" sub-
directory. Also, add the path to the rest of your project source code.
6. Select the "Ada" tab, and check "Suppress Checks All" box.
7. Select the "Build" tab, and check the uut_interface_adacast box.
8. Select the "Execute" tab. Set the execute path to the VectorCAST environment directory. If you
created the project in this directory, you only have to delete the \debug\....... from the path that is
displayed.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 OBJECT ADA RAVEN FOR INTEL 63

ObjectAda Raven for Intel

Configuration
When running with the Raven run-time on Intel hardware you must boot the target using the Pharlap
ETS boot disk. Once this is done there are no additional manual steps involved in test case execution.
VectorCAST uses the Pharlap download utility "runemb" to download its test harness and execute your
test cases.

The Pharlap install directory must be on your default system “PATH” in order for VectorCAST to use the
“runemb” command.

VectorCAST allows all optional parameters associated with the compiler and linker to be set using the
Tools => Options dialog. It is important for you to configure VectorCAST with the correct “linker options”
prior to building a test environment or running a test. The linker options are the options for the Aonix
“adabuild” command. The following string shows an example value for the “link options”:

-x –ramexe –rsb “c:\test\ada\ravenintel\parent\parent.rsb”

The “-rsb” option will be specific to your environment.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 OBJECT ADA RAVEN FOR INTEL 64

Target Execution
The execution of VectorCAST test cases using Raven (Intel) requires the target board to be booted with
the Pharlap ETS monitor.

VectorCAST uses the Pharlap command "runemb" to download and run an executable program on the
target.

Note: The Pharlap tools must be on your default path.

If the target is booted properly, the following Pharlap dialog will be displayed during the target download
process:

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the "transfer" or "runemb"
command, VectorCAST will hang waiting for the termination of the target program. If for some reason
you want to cancel the test execution you should kill the "transfer" or "runemb" process that
VectorCAST spawns.

To kill this process, use Windows Task Manager to locate and terminate the "transfer" or "runemb"
process. VectorCAST will come off its hang and you will be able to continue testing.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 OBJECT ADA RAVEN FOR INTEL 65

Running with a Debugger

When VectorCAST compiles with the ObjectAda compiler, debugging of the executable is not permitted
because VectorCAST has not created an ObjectAda project – this must be done manually.

1. The first step is to create the VectorCAST environment, then create a VectorCAST compile
script. This gives a list of the VectorCAST files used for the environment. You only need the files
up to where the first build command is executed in the VectorCAST script. The files after that are
duplicated or not needed.
2. Create an ObjectAda Debugger project. It makes the most sense to place this inside the
VectorCAST environment. The files for the debugger are sitting here, and easy to put into the
debugger project.
3. Import all of the files from the build script into the debugger project.
4. Select the "Project -> Settings" menu item in the ObjectAda project.
5. Select the "Search" tab. Put in the path to the VectorCAST environment "TESTTEST" sub-
directory. Also, add the path to the rest of your project source code.
6. Select the "Ada" tab, and check "Suppress Checks All" box.
7. Select the "Build" tab, and check the uut_interface_adacast box.
8. Select the "Execute" tab. Set the execute path to the VectorCAST environment directory. If you
created the project in this directory, you only have to delete the \debug\....... from the path that is
displayed.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 OBJECT ADA VXW ORKS 66

ObjectAda vxWorks
Configuration
The following dialog shows the vxWorks options:

Board Name: This is the name of the Tornado target server. This name is case sensitive.

I/O Directory: This is an optional string to tell VectorCAST to use a directory other than the
environment directory for file I/O with the target. The target and host must be able to share files. By
default VectorCAST tells the target to use the test environment directory for I/O. The target must have
read and write permission to the I/O directory. By using this options, you can use a common world-
writable directory for doing target I/O rather than changing the permissions on your environment
directory.

Boot Hostname: This is the name that the Boot Host that is set on the target. If this name is the same
as the name of the workstation running VectorCAST, this option is not needed.

Use Target Server File System (TSFS): The Target Server File System is a VxWorks file system, but
the files operated on by VxWorks are located on the host. To use this option, TSFS must be included in
your VxWorks image and the target server must be configured for TSFS. You must rebuild this
VectorCAST environment after checking or unchecking this option.

When running with the vxWorks run-time, test case execution is completely automatic. You must boot
the target processor with vxWorks and start a target server, after doing this you can run multiple tests
without any additional interaction with the target hardware. When setting up your environment,
remember to put both the Tornado tools and the compiler on your path, since VectorCAST will need to
interface with Tornado.

You must set the VectorCAST Builder option: “New ObjectAda adaopts” in the Builder tab of the Tool

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 OBJECT ADA VXW ORKS 67

=> Options dialog to use the ObjectAda vxWorks compiler with VectorCAST.

The vxWorks image that you use to run tests must have been configured with the vxWorks option:
INCLUDE_POSIX_ALL. For details on building this option into the kernel, please consult the vxWorks
reference manual.

Target Execution
For executing tests built with GNAT or ObjectAda, VectorCAST uses the Tornado tool windsh to
control the download to the target and the test execution. The target board must be "booted” with
vxWorks. Once this has been done, multiple executables can be downloaded and run on the target
without additional reboots. When VectorCAST is ready to run on the target, it will present a dialog box
similar to the following:

If the target has already been booted and is ready to accept downloads, simply click OK. Otherwise
boot the target and start a target server process. When you select OK VectorCAST will use the Tornado
"windsh" command to download and start the execution of the target program.

The following is an overview of starting up and running vxWorks:

1. Boot the target.

2. Start tornado using the "launch” command on Unix or the Start Menu on Windows.
3. Within tornado create a target server and start it running.
4. Select this target from the list and start windsh.
5. Verify that the windsh initializes successfully.
6. Start VectorCAST.
7. Within VectorCAST, set the target board name to the name of the target server created in tornado.
8. Perform testing.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 OBJECT ADA VXW ORKS 68

Stopping a Test Execution

Once the target is booted and VectorCAST starts the target running via the "torn2serv" command,
VectorCAST will hang waiting for the termination of the target program. If for some reason you want to
cancel the test execution you should kill the "torn2serv" process that VectorCAST spawns.

Unix:
Use the "ps" command in the window that you initially started VectorCAST from. Note the process
number of the "torn2serv" process, and use the Unix "kill -9" command to kill that process. VectorCAST
will come off its hang and you will be able to continue testing.

Running with a Debugger

When VectorCAST compiles with the ObjectAda compiler, debugging of the executable is not permitted
because VectorCAST has not created an ObjectAda project – this must be done manually.

1. The first step is to create the VectorCAST environment, then create a VectorCAST compile
script. This gives a list of the VectorCAST files used for the environment. You only need the files
up to where the first build command is executed in the VectorCAST script. The files after that are
duplicated or not needed.
2. Create an ObjectAda Debugger project. It makes the most sense to place this inside the
VectorCAST environment. The files for the debugger are sitting here, and easy to put into the
debugger project.
3. Import all of the files from the build script into the debugger project.
4. Select the "Project -> Settings" menu item in the ObjectAda project.
5. Select the "Search" tab. Put in the path to the VectorCAST environment "TESTTEST" sub-
directory. Also, add the path to the rest of your project source code.
6. Select the "Ada" tab, and check "Suppress Checks All" box.
7. Select the "Build" tab, and check the uut_interface_adacast box.
8. Select the "Execute" tab. Set the execute path to the VectorCAST environment directory. If you
created the project in this directory, you only have to delete the \debug\....... from the path that is
displayed.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 RATIONAL APEX VXW ORKS 69

Rational Apex vxWorks

Configuration
The following dialog shows the Rational Apex vxWorks options:

Board Name: This is the name of the Tornado target server for the target board.

I/O Directory: This is an optional string to tell VectorCAST to use a directory other than the
environment directory for file I/O with the target. The target and host must be able to share files. By
default VectorCAST tells the target to use the test environment directory for I/O. The target must have
read and write permission to the I/O directory. By using this options, you can use a common world-
writable directory for doing target I/O rather than changing the permissions on your environment
directory.

Boot Hostname: This is the name that the Boot Host that is set on the target. If this name is the same
as the name of the workstation running VectorCAST, this option is not needed.

Location of Apex standard libraries: Path to topmost directory of Apex library subsystems.

Use Target Server File System (TSFS): The Target Server File System is a VxWorks file system, but
the files operated on by VxWorks are located on the host. To use this option, TSFS must be included in
your VxWorks image and the target server must be configured for TSFS. You must rebuild this
VectorCAST environment after checking or unchecking this option.

When running with the vxWorks run-time, test case execution involves minimal manual steps. You
must boot the target processor and start a target server. After doing this you can run multiple tests
without any additional interaction with the target hardware. VectorCAST will prompt with an

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 RATIONAL APEX VXW ORKS 70

acknowledgment dialog to remind you to boot the target before running a test case. See the section
"Target Execution with Rational Apex vxWorks" for an overview of starting up and running vxWorks
with VectorCAST.

When setting up your environment, remember to put the Tornado tools on your path, since VectorCAST
will need to interface with Tornado.

Target Execution
The execution of VectorCAST test cases using vxWorks requires that the target board be “booted” with
vxWorks. Once this has been done, multiple executables can be downloaded and run on the target
without additional reboots.

Make sure that the command line interface to the Tornado tools is on your default path.

When VectorCAST is ready to run on the target, it will present a dialog box similar to the following:

If the target has already been booted and is ready to accept downloads, simply click OK. Otherwise
boot the target and start a target server process. When you select OK VectorCAST will use the Tornado
"windsh" command to download and start the execution of the target program.

The following is an overview of starting up and running vxWorks:

1. Boot the target.

2. Start tornado using the "launch" command.
3. Within tornado, create a target server and start it running.
4. Select this target from the list and start windsh.
5. Verify that the windsh initializes successfully.
6. Start VectorCAST.
7. Within VectorCAST, set the target board name to the target server name created in tornado.
8. Perform testing.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 RATIONAL APEX VXW ORKS 71

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the "windsh" command,
VectorCAST will hang waiting for the termination of the target program. If for some reason you want to
cancel the test execution you should kill the "windsh" process that VectorCAST spawns.

Unix: Use the "ps" command in the window that you initially started VectorCAST from. Note the
process number of the "windsh" process, and use the Unix "kill -9" command to kill that process.
VectorCAST will come off its hang and you will be able to continue testing.

Running with the Apex Debugger for vxWorks

VectorCAST RSP supports the execution of tests using the Apex debugger. Running under control of
the debugger is accomplished by booting the target as you would without the debugger, and then right-
clicking on the test case name and selecting "Execute with Debug".

VectorCAST will put up a dialog that looks similar to this:

VectorCAST does not start the debugger automatically because Apex does not have a command line
interface to the graphical debugger. You must manually start the debugger in the environment directory
using the instructions in the dialog. When you are done debugging, select the OK button in the
VectorCAST dialog and all the normal test execution reports will be built.

Refer to the APEX documentation for complete information on running an executable under control of
the debugger.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 RATIONAL APEX EXEC 72

Rational Apex Exec

Configuration
When running with the Apex Exec run-time, test case execution is completely automatic. You must
boot the target processor. After doing this you can run multiple tests without any additional interaction
with the target hardware.

Target Execution
Location of Apex standard libraries: Path to topmost directory of Apex library subsystems.

Ada runtime: If this option is set to Full, the full Ada run-time library will be used. If this option is set to
MARK, the reduced run-time will be used and the test harness will be built with the appropriate
restrictions.

The execution of VectorCAST test cases using Apex Exec requires that the target board be "booted”
and the Apex View must be set up with the correct target parameters to allow target communication to
take place using “apex_execute”. Once this has been done, multiple executables can be downloaded
and run on the target without additional reboots.

VectorCAST controls the target execution via a shell script file that gets generated at the time that you
build the test environment. VectorCAST generates two executable programs during the environment
build and there is one shell script generated for each. The names are DATA_IF_.csh and UUT_
INTE.csh. A sample of the contents is shown here:

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 RATIONAL APEX EXEC 73

/home/LATEST/IO/pty /home/LATEST/IO/apex_monitor \
apex_execute uut_interface_adacast

The shell script uses the Apex command “apex_execute” to control the test execution. “pty” and
“monitor” are two VectorCAST utilities that allow I/O to be exchanged between the host and the target.

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the "apex_execute" command,
VectorCAST will hang waiting for the termination of the target program. If for some reason you want to
cancel the test execution you should kill the "apex_execute" process that VectorCAST spawns.

Unix:
Use the "ps" command in the window that you initially started VectorCAST from. Note the process
number of the "apex_execute" process, and use the Unix "kill -9" command to kill that process.
VectorCAST will come off its hang and you will be able to continue testing.

Running with the Apex Debugger for vxWorks

VectorCAST RSP supports the execution of tests using the Apex debugger. Running under control of
the debugger is accomplished by booting the target as you would without the debugger, and then right-
clicking on the test case name and selecting "Execute with Debug".

VectorCAST will put up a dialog that looks similar to this:

VectorCAST does not start the debugger automatically because Apex does not have a command line

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 RATIONAL APEX EXEC 74

interface to the graphical debugger. You must manually start the debugger in the environment directory
using the instructions in the dialog. When you are done debugging, select the OK button in the
VectorCAST dialog and all the normal test execution reports will be built.

Refer to the APEX documentation for complete information on running an executable under control of
the debugger.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 TLD ADA MIL-STD-1750 SIMULATOR 75

TLD Ada MIL-STD-1750 Simulator

Configuration
When running with the TLD Ada compiler, test case execution is completely automatic. You must set
up your path to have the TLD compiler and simulator on it; this is usually done by changing your
directory to the TLD compiler directory and running the “inittld.csh” script found there.

Additionally, you should set the “Create accessor functions for Ada options” checkbox to prevent
possible linker errors. (This option tells VectorCAST to use function calls for some global data rather
than an actual global object reference, which can cause link issues).

The harness executable is generally run from a script, so the “Execute command” options is set to the
default behavior for running a script on a Solaris platform. VectorCAST will automatically create the
scripts needed to control the execution, and append the appropriate script to the end of the “Execute
command” when running the testcase.

Note: Due to current limitations within the TLD compiler, the environment build option
“Whitebox” will not be honored. Only blackbox processing can be performed.

Target Execution
When running test cases with the TLD Ada MIL-STD-1750 simulator, test execution is completely
automatic. The only requirement is that the “dbg” command be on your path. As with most instruction
set simulators, test execution is expected to be slower than with native or live board execution.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 TLD ADA MIL-STD-1750 SIMULATOR 76

Stopping a Target Execution

When VectorCAST starts the simulator running via the "dbg" command, VectorCAST will hang waiting
for the termination of the simulator program. If for some reason you want to cancel the test execution
you should kill the "dbg" process that VectorCAST spawns.

Use the "ps" command in the window that you initially started VectorCAST from. Note the process
number of the "dbg" process, and use the Unix "kill -9" command to kill that process. VectorCAST will
come off its hang and you will be able to continue testing.

Running with the TLD Debugger

VectorCAST RSP supports the execution of tests using the TLD debugger. When running with the
debugger, the user will be required to issue the setup commands necessary to properly configure the
compiler. A sample list of debug commands would be:

att tldmps
mode nomessage
load UUT_INTERFACE_ADACAST
reset

This will leave the debugger ready to run the VectorCAST harness; breakpoints can be set at this time,
and “go” will execute the harness.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 XGC ADA M1750A SIMULATOR 77

XGC Ada M1750A Simulator

Configuration
When running with the XGC Ada compiler, test case execution is completely automatic. You must set
up your path to have the XGC compiler and simulator on it and also set you LD_LIBRARY_PATH to
have the XGC /lib directory.

Target Execution
When running test cases with the XGC Ada M1750A simulator, test execution is completely automatic.
The only requirement is that the “m1750-coff-run” command be on your path, and that the XGC “lib”
directory be added the LD_LIBRARY_PATH environment variable. As with most instruction set
simulators, test execution is expected to be slower than with native or live board execution.

Stopping a Target Execution

Once the target is booted and VectorCAST starts the target running via the "m1750-coff-run" command,
VectorCAST will hang waiting for the termination of the target program. If for some reason you want to
cancel the test execution you should kill the "m1750-coff-run" process that VectorCAST spawns.

Unix:
Use the "ps" command in the window that you initially started VectorCAST from. Note the process
number of the "m1750-coff-run" process, and use the Unix "kill -9" command to kill that process.
VectorCAST will come off its hang and you will be able to continue testing.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 XGC ADA M1750A SIMULATOR 78

Running with the XGC Debugger

VectorCAST RSP does not support the execution of tests using the XGC. The reason for this, is that
the debugger does not have the capability to map the standard input and output to pipes or files. As a
result, the test input and result data cannot be captured.

Rev: 447e070 VectorCAST/Ada RSP User's Guide for VectorCAST 2024

 Index: Aonix ObjectAda vxWorks – Rational Apex Exec

Index stopping a target execution for 28

target execution with 26
Aonix ObjectAda vxWorks
GNAT vxWorks 30
configuring VectorCAST RSP for 66
compiling 11
stopping a target execution for 68
configuring VectorCAST RSP for 29
target execution with 30, 67
running with the debugger 31
Aonix Raven for Intel
stopping a target execution for 31
compiling 11
target execution with 30, 67
configuring for VectorCAST RSP 63
GNAT vxWorks AE653
stopping a test execution for 64
compiling 11
target execution with 64
Green Hills GMART/GSTART
Aonix Raven for PPC
configuring VectorCAST RSP for 39
compiling 11
running with the AdaMULTI debugger 42
configuring for VectorCAST RSP 60
stopping a target execution for 41
stopping a test execution for 61
target execution with 40
target execution with 61
Green Hills INTEGRITY
CLICAST
compiling 11
accessing in Unix 14
configuring VectorCAST RSP for 43
accessing in Windows 14
stopping a target execution for 52
command format 14
target execution with 47
command format, compound or init 15
Green Hills Simulator 37
target-specific options 16
configuring VectorCAST RSP for 37
target options 15
target execution with 53
communication overview 8
Green Hills vxWorks
concepts 7
configuring VectorCAST RSP for 57
configuring for your compiler and RTOS 9
running with the AdaMULTI debugger 59
DDC-I Bare
stopping a target execution for 37, 58, 76-77
configuring VectorCAST RSP for 23
target execution with 37, 58
stopping a target execution for 23
harness architecture 7
DDC-I SCORE
introduction 7
compiling 11
ObjectAda adaopts” 66
configuring VectorCAST RSP for 23
overview 7
stopping a target execution for 23
Rational Apex Exec
FPP 18
compiling 11
GNAT HIE
configuring VectorCAST RSP for 72
compiling 11
target execution with 72
configuring VectorCAST RSP for 24

79
 Index: Rational Apex vxWorks – XGC Ada M1750A Simulator

Rational Apex vxWorks 69 VCAST_GH_INTEX_FILE 20

configuring VectorCAST RSP for 69 VCAST_GMART_FILE_IO 20
running with the debugger 71, 73 VCAST_MAX_STRING_LENGTH 15
stopping a target execution for 71, 73 VCAST_PSC_MAKE_FILE_BASE_
target execution with 70 DIRECTORY 21

target execution VCAST_RAVEN_FILE_IO 21

with the VectorCAST Monitor 24 VCAST_USE_COMPOUND_FOR_BATCH 15

target options 15-16 VCAST_VCAST_PRE_EXECUTE_CMD 16

target variants VCAST_VXWORKS_RTP_MODE 21

list of 17 VectorCAST RSP

TARGET_AE653_DATA_DIR 21 combining host and target based testing 12

TARGET_AE653_MAKE_FILE 18 environment creation 11

TARGET_AE653_UUT_DIR 21 target with the monitor 24

TARGET_APEX_LIBRARY 18 VECTORCAST_DIR 14

TARGET_BOARD_NAME 18 windsh 33

TARGET_BOOT_HOSTNAME 18 XGC Ada M1750A Simulator

TARGET_BUILD_FILE 18 configuring VectorCAST RSP for 77

TARGET_COMMAND_OPTIONS 18 running with the XGC debugger 76, 78

TARGET_COMMAND_VERB 18 target execution with 75, 77

TARGET_CPU 18
TARGET_INTEGRITY_ADDRESS_SPACE_
MODE 19
TARGET_IO_DIRECTORY 19
TARGET_SIM_CMD 19
TARGET_TFTP_DIR 19
TARGET_USE_RTSERV_COMM 19
TARGET_USE_TORNSERV 19
TARGET_VARIANT 16
TARGET_XFER_METHOD 19
TLD Ada MIL-STD-1750 Simulator
configuring VectorCAST RSP for 75
torn2serv 19
tornserv 19
VCAST_ADA_ACCESSOR_FUNCTIONS 15
VCAST_ENVIRONMENT_FILES 19
VCAST_FILE_INDEX 20
VCAST_GH_INT_CMD 20

80