SPLash!/iX : The Native Mode SPL Compiler for the HP 3000 Series 9XX

If you are contemplating a move from the "classic" HP 3000 minicomputer operating under MPE/V to the Series 9XX family of HP 3000 computers operating under MPE/IX, you have a right to be concerned about migrating your current SPL language code.

SPL was often the language of choice among system programmers who needed speed and efficiency. Many sites developed entire applications in SPL. Making the move to the Series 9XX does present a challenge: Hewlett-Packard does not market a Native Mode version of SPL.

There are three HP migration paths available to you. The first option from HP is to run your SPL application in Compatibility Mode (CM). The problem here is that if part of the application is in another language and you move those programs or subroutines to Native Mode (NM), you must create stubs to allow the CM-based software to interact with the NM-based software. The stubs cost you time to build, and time to execute.

The second option from HP is to use the Object Code Translator. This will permit your stand-alone SPL applications to run faster than emulated Compatibility Mode, but you will be forced to maintain a source, an object, and a translated object. And you still must create stubs for the software.

The third option, of course, is to rewrite your program into another language. This is clearly the best path in the long run, because you can make full use of Native Mode features that will return the best possible performance. However, if you simply rewrite your application, rather than redesign it for the new environment, you will carry over many limitations of the old HP 3000 architecture, and risk the introduction of new bugs to your program. While the application will be fully Native and will run faster, you will have spent a good deal of your precious programming resources for only a modest gain.

A better alternative is available: the SPLash! Native Mode SPL Compiler. By simply recompiling your SPL code into Native Mode SPLash! code, you gain the immediate performance improvement that rewriting your code in another language would give you, but without introducing new bugs or making a large investment in programming time. You can then use that time in other, more productive ways -- such as learning the facets of the new architecture and making plans for the next generation of your application, written expressly for the new environment.

Examine the choices...and choose SPLash! as your SPL migration tool.

The SPLash! Approach to Native Mode

The default mode of operation for the SPLash! compiler is to conform to the addressing conventions and processing philosophy of the MPE/V-based HP 3000 line, making migration of your source code as painless as possible. This means that all address modes and data types are treated as they would be on the 16-bit HP 3000, not the 32-bit PA-RISC machines. For example, Pascal/iX has a pre-defined data type SHORTINT which is 16 bits, while SHORTINT must be declared as a subrange in Pascal/V. Pascal/iX is thus not totally compatible with its own MPE/V-based counterpart. The adherence of SPLash! to the SPL/V processing philosophy facilitates conversion to the new 32-bit architecture.

Procedures written in SPLash! come in two modes: Native Mode procedures and SPLash! Mode procedures. Native Mode procedures use the full Native Mode calling conventions, and are completely callable from any Native Mode language, including Pascal/iX, SPLash!, COBOL, FORTRAN, and C. Native Mode procedures deal solely with 32-bit and 64-bit addressing.

SPLash! Mode procedures use the traditional stack-based method of calling procedures. As such they are callable only from a SPLash! outer block or from other SPLash! Mode procedures. By default, SPLash! Mode procedures use 16-bit "DB" relative addresses, but these addresses are automatically converted to 32-bit and 64-bit addresses when calling Native Mode procedures (e.g., FREAD). SPLash! Mode procedures can also declare pointers and arrays which will use 32-bit and 64-bit addresses, thereby allowing access beyond the bounds of the emulated 64KB stack.

The SPL features not supported by SPLash! are usually not supported by HP’s Compatibility Mode either. They typically fall into one of two categories: architectural features of the classic HP 3000 that do not exist or are meaningless in PA-RISC Architecture, or non-privileged features where the meaning of the operation is difficult to discern at run time or would cause a considerable amount of overhead.

Much of the PM code written in SPL is functionally obsolete under MPE/IX. While it is possible to map these privileged operations into PA-RISC, typically the data objects that are accessed by these operations are changed or non-existent.

In the design and implementation of SPLash!, every attempt has been made to maintain full compatibility with the existing SPL language.

In general, all statements in the SPL language as documented in the SPL reference Manual (HP part number 32100-90000) and the SPL Pocket Guide (HP part number 32100-90001) are supported by the SPLash! compiler.

There are three issues that are most often raised concerning the implementation of SPL in Native Mode: (1) access to both "classic" as well as "native" intrinsics,
(2) compatibility with the MPE/IX Debugging facility, and (3) support for the ASSEMBLE statement.

Intrinsic access is fully functional within the SPLash! compiler. To promote portability, SPLash! can be directed to read descriptions of either user or system "classic" intrinsics from a SPLINTR file or default to read from a user or system SYSINTR file.

The SPLash! compiler emits code which is fully compatible with the system debugging facility. Furthermore, SPLash! can be directed to emit code that causes breakpoints at the statement level, the procedure entry level, and/or the procedure exit level. Breakpoints can be enabled or disabled at any level within the system debugger. SPLash! can also be directed to emit statement numbers which will quickly relate machine code to statement numbers within the source code.

To see a sample of the PA-RISC assembler code SPLash! emits, look here.

You may also wish to examine some additional online documentation.

The following lists include supported and unsupported opcodes via the ASSEMBLE statement. The third list contains SPLash! opcode extensions.

Fully supported opcodes:

ADAX BLE  CON  DECB DXBZ FNEG LDPN MFDS ORI  SCU  SUBI XBR
ADBX BNCY CPRB DECM DXCH FSUB LDPP MOVE PARC SCW  SUBM XBX
ADD  BNE  CSL  DECX DZRO HALT LDX  MPY  PAUS SDEA SUBS XCH
ADDD BNOV CSR  DEL  EADD IABZ LDXA MPYD PCAL SED  SXIT XCHD
ADDI BOV  CVAD DELB ECMP INCA LDXB MPYI PCN  SETR TASL XEQ
ADDM BR   CVBD DFLT EDIV INCB LDXI MPYL PLDA SIN  TASR XOR
ADDS BRE  CVDA DISP EMPY INCM LDXN MPYM PSDB SIO  TBA  XORI
ADXA BRO  CVDB DIV  ENEG INCX LLBL MTBA PSEB SLD  TBC  ZERO
ADXB BTST DABZ DIVI ENDP INIT LLSH MTBX PSHR SMSK TBX  ZROB
ADXI CAB  DADD DIVL ESUS IXBZ LMPY MTDS PSTA SRD  TCBC ZROX
AND  CIO  DASL DLSL EXF  IXIT LOAD MVS  QASL SSEA TEST
ANDI CMD  DASR DLSR EXIT LADD LOCK MVBL QASR SST  TIO
ASL  CMP  DCMP DMPY FADD LCMP LRA  MVBW RCLK STAX TNSL
ASR  CMPB DCSL DMUL FCMP LDB  LSL  MVLB RMSK STB  TNSR
BCY  CMPD DCSR DNEG FDIV LDD  LSR  NEG  RSW  STBX TRBC
BE   CMPI DDEL DPF  FIXR LDEA LST  NOP  SBXI STD  TSBC
BG   CMPM DDIV DSUB FIXT LDI  LSUB NOT  SCAC STOR UNLK
BGE  CMPN DDUP DTST FLT  LDIV MABS NSLD SCAN SUB  WIO
BL   CMPT DECA DUP  FMPY LDNI MOS  OR   SCLK SUBD XAX

Unsupported opcodes:

ABSD ALGN CVND EDIT LDW  MQFV NEGD SEML SIOP WIOC
ABSN CMPS DUMP HIOP LDDW MQTV RIOC SINC STRT

Opcode extensions:

BRK  BRK2 CLOV DLSZ EPID   KSO  MFSP MTSP PROBER RSYSG SWT2 WTOB
BRK1 CLCY DIVD DPID FINDDB MCAL MFVA MTVA PROBEW SWT   SWT3

Updated: 1999-05-26