/* module EXE_ROUTINES.H "X-84" * ************************************************************************* * * * Copyright 1993 Compaq Computer Corporation * * * * COMPAQ Registered in U.S. Patent and Trademark Office. * * * * Confidential computer software. Valid license from Compaq or * * authorized sublicensor required for possession, use or copying. * * Consistent with FAR 12.211 and 12.212, Commercial Computer Software, * * Computer Software Documentation, and Technical Data for Commercial * * Items are licensed to the U.S. Government under vendor's standard * * commercial license. * * * * Compaq shall not be liable for technical or editorial errors or * * omissions contained herein. The information in this document is * * subject to change without notice. * * * ************************************************************************* *++ * * FACILITY: * * VMS Executive (LIB_H) * * ABSTRACT: * * This module contains the C function prototypes for the VMS system * routines that begin with the EXE$ and EXE_STD$ prefixes and have * a standard call interface. * * NOTE: * * The conventions used in these function prototypes are: * * 1. Case * This header file supports invoking the routines by either using all * lowercase or all uppercase names for the system routines. Either * naming convention works even in the presence of the /NAME=AS_IS * compiler switch. * * 2. Integer size * The generic "int" type is used where it doesn't matter whether the * integer is 32 or 64 bits wide. Thus "int" is the returned value of * most functions and is the type for most integers passed by value. * However, an unambiguous integer type, e.g. int32, is used for any * integer that is passed by reference. Also, int64 is used for any * integer that is expected to be 64 bits wide even if it is passed by * value. * * 3. Types * The function prototypes use the types defined in [SYSLIB]SYS$LIB_C.TLB. * The definitions of all types used are included below. * * 4. Parameter names * Parameter names are used in the prototypes. Although they are ignored * by the compiler they do provide useful documentation. For example: * * void ioc_std$reqcom (int iost1, int iost2, UCB *ucb); * * is used instead of the functionally equivalent: * * void ioc_std$reqcom (int, int, UCB *); * * 5. Parameters passed by reference * The parameter name includes the "_p" suffix if the parameter is passed * by reference unless the parameter type implies that it is always passed * by reference. For example, there is no "_p" suffix in: * * UCB *ucb; * int32 iosb[2]; * * since structures and arrays are always passed by reference. However: * * int32 *outlen_p; * UCB **new_ucb_p; * * include the suffix to denote that outlen_p is a pointer to a 32 bit * integer, and to denote that new_ucb_p is a pointer to a pointer to a * UCB structure. * * 6. Mixed pointer sizes within one argument * If a 64-bit pointer is being passed by reference, the reference to * the pointer should also be 64 bits wide to avoid confusion. * For example: * * PTE_PPQ va_pte_p; * VOID_PPQ start_va_p; * * should be used instead of: * * PTE_PQ *va_pte_p; * VOID_PQ *start_va_p; * * * AUTHOR: * * Leonard S. Szubowicz * * CREATION DATE: 8-Jun-1993 * * NOTE WELL: Structure datatypes defined in STARLET must generally must be specified * as 'struct _xxxx' rather than the typedef form 'XXXX' or 'xxxx'. This * is because there is no guarantee that the module which includes * this file will have __NEW_STARLET in place. Thus you don't know * which typedef form to use. * * MODIFICATION HISTORY: * * X-84 RCL Rick Lord 6-Feb-06 * * a) Delete EXE$KP_SPL_ACQUIREL/RELEASEL/RESTOREL - we do not * store a KPB's current spinlock context anymore, instead * refreshing it when necessary (stall, re/start, end), so * these routines are no longer necessary * * b) Add EXE$SPL_CTX_SET, a no-KPB version of EXE$KP_SPL_CTX_SET * * c) Change the last parameter of EXE$KP_SPL_RE/START and the 2nd * parameter of EXE$KP_SPL_UPDATE_KPB so it's a set of flags * instead of a current spinlock context; all we really need to * know at this boundary is which spinlocks are not to be * released by the active KPB * * d) Delete the last parameter to EXE$KP_TQE_WAIT, EXE$KP_FORK * and EXE$KP_FORK_WAIT - it used to be a requested spinlock * context, but for sort-of consistency with the stock code * the KP will now be restarted with the same spinlock * context with which it stalls * * X-83 KLN3620 Karen L. Noel 1-Feb-2006 * Add exe$credit_bytcnt_bytlm_id. * * X-82 RCL Rick Lord 5-Oct-05 * Add EXE$KP_SPL_INIT_KPB * * X-81 RCL Rick Lord 23-Aug-05 * a) Add a #include of SPLDEF to resolve references to * SPL structures in EXE$KP_SPL_* routine prototypes * b) Add #defines of lower-case exe$kp_spl_* routine names * c) Add prototypes for new EXE$KP_SPL_* routines * * X-78,79 WBF Burns Fisher 07-Jun-2004 * Put in pragma linkage for EXE$REVERT_WHOLE_PGM... * * X-75,76,77 WBF Burns Fisher 18-Mar-2004 * Add whole program floating point routines * * X-74 DAG Doug Gordon 15-May-2003 * Add EXE$KP_ALLOC_MEM_STACK_USER, EXE$KP_DEALLOC_MEM_STACK_USER, * EXE$KP_USER_ALLOC_KPB, EXE$KP_STACK_PEAKS * * X-73 DAG Doug Gordon 8-Apr-2003 * exe$kp_alloc_rse_stack_p2_any is a 64-bit routine. * * X-72 KLN3248 Karen L. Noel 26-Mar-2003 * Add exe$setstk_64_int. * * X-71 KLN3246 Karen L. Noel 21-Mar-2003 * o Promote exe_std$expandstk to 64-bits. * o Add exe$kp_alloc_rse_stack_p2_any. * * X-70 Anne McElearney 14-Feb-2003 * Remove stdarg.h due to build conflicts * and instead define va_list parameter to be char * * * X-69 Anne McElearney 13-Feb-2003 * In addition to the va_list change, also include * stdarg.h to make sure we get the va_* definitions. * (Eiche) * * X-68 Anne McElearney 13-Feb-2003 * Fix exe$kvprintf prototype. Ghostwriter: Eiche * * X-67 Anne McElearney 12-Feb-2003 * Add exe$kprintf,exe$kvprintf prototypes * * X-66 KLN3210 Karen L. Noel 5-Feb-2003 * Two more exe$rseregs routines. * * X-65 KLN3190 Karen L. Noel 15-Jan-2003 * Add exe$rseregs routines. * * X-64 DAG Doug Gordon 17-Dec-2002 * Add the new KP stack allocation routines. * * X-63 DAG Doug Gordon 22-Nov-2002 * Promote exe$lal_insert_first and exe$lal_remove_first * to use long pointers. (And yes, the listhead can be * in 64-bit space, the list elements are 32-bit only) * * X-62 WBF Burns Fisher 11-Nov-2002 * Change comment to slash-star for STANDARD=VAXC * * X-61 WBF Burns Fisher 23-Oct-2002 * Add exe_std$expandstk and for IA64, add the floating save * routines * * X-60 RAB Richard A. Bishop 31-Oct-2001 * The changes in X-59 give problems with level4 checking. * Disable NOPARMLIST errors around them. * * X-59 Anne McElearney 20-Jul-2001 * Remove argument declaration from error_rtn in exe_std$readlock, * exe_std$writelock, and exe_std$modifylock. They were not accounting * for an optional argument as the last parameter to the error routine. * The routine still expects the parameters, they are just not defined * in the prototype. The addition of the last parameter could not * be added and still allow backward compatability. This fixes * PTR 75-45-194. * * X-58 JRK Jim Kauffman 12-Jun-2001 * Add exe$cbb_zero_range * * X-57 WBF Burns Fisher 14-Jul-2000 * Add optional arguments to exe$allocate_pool and friends. * Happy Bastille Day! Liberté, égalité, fraternité! * * X-56 TJP Tom Provost 13-Jul-2000 * Add exe_std$iofork_cpu prototype to provide a C-callable * interface to iofork_cpu macro in iomar.mar. * * X-55 JMB218 James M. Blue 9-Mar-2000 * Add exe_std$qioserver_new_unit prototype for activating a * newly discovered QIOServer capabale unit. Delete the * exe_std$qsrv_srvr_fdt prototype, it has been replaced with * a DDT entry at QSRV_HELPER. * * X-54 LSS0406 Leonard S. Szubowicz 10-Feb-2000 * Part of the fix for CLDs 70-3-2729 and 70-3-2599: Multipath * internal I/O that was sent to a UCB by calling EXE_STD$INSIOQC * would increment UCB$L_QLEN but never decrement it on completion. * Add prototype for new routine EXE_STD$INSIOQ_SIMPLE. * * X-53 KLN2123 Karen L. Noel 14-Jan-2000 * Add exe_std$alophycntg_color[_s2]. * * X-52 RAE Rae Eastland 15-Oct-1999 * Add routine prototypes for exe$lal_insert_first and * exe$lal_remove_first. * * X-51 JMB James M. Blue 22-Jul-1999 * Add routine prototype for a QIOServer server to call * a FDT routine to fix-up a client's request. * * X-50 Ruth Goldenberg 06-Jul-1998 * Change EXE_STD$WRTMAILBOX to accept variable number * of arguments so CSP can call it with the EPID to be * associated with a termination message for a remotely * created process. * * X-49 KLN2084 Karen L. Noel 05-June-1998 * Correct the prototype for exe$register_pool_info to * accept 64-bit pointers. * * X-48 KLN2082 Karen L. Noel 04-Jun-1998 * Surround this file with short pointer pragmas in case someone * wants to compile with long pointers from the command line. * * X-47 KLN2077 Karen L. Noel 20-May-1998 * Ignore NOPARMLIST informationals where approriate so that * level4 checking can be used with the C compiler. * * X-46 EMB Ellen M. Batbouta 02-Apr-1998 * Add prototype definition for routines, Exe$cbb_insert_ * bitmask and Exe$cbb_boolean_oper. Remove definitions * for routines, Exe$cbb_set_bits and Exe$cbb_clear_bits. * * X-45 EMB Ellen M. Batbouta 04-Mar-1998 * Add prototype definition for routine, Exe$cbb_zero. * * X-44 EMB Ellen M. Batbouta 25-Feb-1998 * Add a flags input parameter to the following routines: * Exe$cbb_copy, Exe$find_first_set, Exe$find_first_clear, * Exe$cbb_empty, Exe$cbb_test_bit, Exe$cbb_rebuild, * Exe$cbb_extract_bitmask, Exe$cbb_set_bit, Exe$cbb_clear_ * bit, Exe$cbb_set_bits, and Exe$cbb_clear_bits. * * Add prototype definition for routine, Exe$cbb_validate. * * X-43 EMB Ellen M. Batbouta 13-Feb-1998 * Bugfix for X-42 - missing ; (how embarrassing!) * * X-42 EMB Ellen M. Batbouta 12-Feb-1998 * Add prototype definition for routine, Exe$cbb_extract_ * bitmask. * * X-41 EMB Ellen M. Batbouta 11-Feb-1998 * Add prototype definition for routine, Exe$event_notify. * * X-40 EMB Ellen M. Batbouta 16-Jan-1998 * Add prototype definition for routine, Exe$cbb_copy. * * X-39 EMB Ellen M. Batbouta 17-Dec-1997 * Change the prototypes for the routines, Exe$cbb_set_bit * (remove ccode parameter) and Exe$cbb_test_bit (remove state * parameter). * * X-38 EMB Ellen M. Batbouta 11-Dec-1997 * Change the prototype for the Exe$cbb_allocate routine. * The output parameter, cbb, should be cast as CBB_PPQ * rather than CBB_PQ. A level of indirection was missing. * * X-37 EMB Ellen M. Batbouta 04-Dec-1997 * Add timeout_value parameter to the routines, exe$cbb_allocate * and exe$cbb_initialize * * X-36 JRK388 Jim Kauffman 10-Nov-1997 * Clean up far_pointer prototype definitions for CBBs * * X-35 JRK388 Jim Kauffman 6-Nov-1997 * Add CBB routine prototypes * * X-34 Ken Follien 25-Jul-1997 * Changed exe$primitive_mcheck prototype. * * X-33 Andy Kuehnel 17-Jun-1997 * Remove never implemented callback interface. * * (get back in line with VDE) * * X-30 KJF Ken Follien 21-Apr-1997 * Add exe$primitive_mcheck, exe$setup_memtest_env, * and exe$clear_memtest_env. * * X-28 EMB Ellen M. Batbouta 04-Nov-1996 * Add exe$check_for_mem_error. * * X-27 WBF Burns Fisher 06-Aug-1996 * Add new user param to EXE$REGISTER_POOL_INFO * * X-27 Andy Kuehnel 9-Jul-1996 * Add exe_std$chkflupages. * * X-26 WBF Burns Fisher 29-May-1996 * Update exe$register_pool_info parameters to match spec * * X-25 PKW350 Paul K. M. Weiss 14-May-1996 * Add exe$lock_pkta and exe$unlock_pkta * * X-24 DMB Dave Bernardo 04-May-1996 * Change POOL_TYPE to MMG$POOL_TYPE * * X-23 WBF Burns Fisher 2-May-1996 * Add function protos for exe$allocate_pool routines * * X-22 NYK538 Nitin Y. Karkhanis 31-Jan-1996 * Modify function prototype for EXE_STD$NAM_TO_PCB such * that the PIDADR and PRCNAM arguments are 64-bit pointers. * * X-21 NYK455 Nitin Y. Karkhanis 20-Jul-1995 * Add function prototypes for exe$bugchk_remove_va and * exe$bugchk_cancel_remove_va. * * X-20 KLN1458 Karen L. Noel 17-Jul-1995 * Change desciptor pointer types to void pointers and remove * the include of descrip.h (it causes library version mismatch * headaches when one library includes a module from another). * * X-19 KLN1457 Karen L. Noel 05-Jun-1995 * Add some posix routines. * * X-18 JRK369 Jim Kauffman 23-May-1995 * Add exe$nam_to_pcb * * X-17 KLN1447 Karen L. Noel 26-Apr-1995 * Conditionalize exe_std$probe*_dsc64 protos on * __INITIAL_POINTER_SIZE. * * X-16 KLN1445 Karen L. Noel 25-Apr-1995 * Add protos for 64-bit descriptor probe routines. * * X-15 JCH703b John C. Hallyburton, Jr. 6-Mar-1995 * Add EXE_STD$CREDIT_BYTCNT. * * X-14 LSS0325 Leonard S. Szubowicz 24-Feb-1995 * 64-Bit Virtual Addressing: Add EXE_STD$LOCK_ERR_CLEANUP. * * X-13 LSS0320 Leonard S. Szubowicz 15-Feb-1995 * 64-Bit Virtual Addressing: Support 64-bit buffer addresses on * the EXE_STD$xCHK and EXE_STD$xLOCK prototypes if the compiler * supports them. * * X-12 LSS0321 Leonard S. Szubowicz 10-Feb-1995 * 64-bit IOSB address on EXE_STD$SYNCH_LOOP. * * X-11 WDB64B1 Walter D. Blaschuk, Jr. 2-Feb-1995 * 64-bit Virtual Addressing/BUFIO changes: Add * exe_std$alloc_bufio_32, exe_std$alloc_bufio_64 and * exe_std$alloc_diagbuf. * * X-10 KLN1365 Karen L. Noel 19-Jan-1995 * Add exe_std$debit_bytcnt_bytlm_alo. * * X-9 KLN1360 Karen L. Noel 5-Jan-1995 * Add exe_std$alopaged and exe_std$deapaged * * X-8 JCH703a John C. Hallyburton, Jr. 6-Dec-1994 * Add EXE_STD$CHECK_DEVICE_ACCESS * * X-7 NYK143 Nitin Y. Karkhanis 18-Nov-1994 * Add exe_std$alophycntg_s2. * * X-6 JCH703 John C. Hallyburton, Jr. 3-Nov-1994 * Add EXE_STD$*P1* memory allocation/dealllocation. * * X-5 LSS0308 Leonard S. Szubowicz 11-May-1994 * Add function prototype for ini$brk. Although this routine * does not begin with the exe prefix, this is probably the best * place for it. * * X-4 LSS0308 Leonard S. Szubowicz 5-May-1994 * Add function prototypes for exe$kp_find_kpb and exe$kp_tqe_wait. * * X-3 SDD Steve DiPirro 04-Feb-1994 * Reverse parameter order in exe_std$deanonpgdsiz function * prototype definition. * * X-2 DEE0198 David E. Eiche 16-Sep-1993 * Add definitions for EXE_STD_PROBEW and EXE_STD$PROBEW_DSC. * * X-1 LSS0279 Leonard S. Szubowicz 8-Jun-1993 * Initial version containing only those routines commonly used * by device drivers. * *-- */ #ifndef __EXE_ROUTINES_LOADED #define __EXE_ROUTINES_LOADED 1 #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __save /* Save the previously-defined required ptr size */ #pragma __required_pointer_size __short /* And set ptr size default to 32-bit pointers */ #endif /* * Define all types that are used in the following function prototypes. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* X-81a */ #include #include #ifdef __ia64 /* Verified for IA64 port - KLN */ #include #include #endif /* VMS system routine entry points are defined externally using uppercase names. The following macros allow the usage of the lowercase versions of these names even in the presence of the /NAME=AS_IS compiler switch. */ #define exe_std$abortio EXE_STD$ABORTIO #define exe_std$alloc_bufio_32 EXE_STD$ALLOC_BUFIO_32 #define exe_std$alloc_bufio_64 EXE_STD$ALLOC_BUFIO_64 #define exe_std$alloc_diagbuf EXE_STD$ALLOC_DIAGBUF #define exe_std$allocbuf EXE_STD$ALLOCBUF #define exe_std$allocceb EXE_STD$ALLOCCEB #define exe_std$allocirp EXE_STD$ALLOCIRP #define exe_std$allocjib EXE_STD$ALLOCJIB #define exe_std$allocpcb EXE_STD$ALLOCPCB #define exe_std$alloctqe EXE_STD$ALLOCTQE #define exe_std$alononpaged EXE_STD$ALONONPAGED #define exe_std$alopaged EXE_STD$ALOPAGED #define exe_std$alop1imag EXE_STD$ALOP1IMAG #define exe_std$alop1proc EXE_STD$ALOP1PROC #define exe_std$alophycntg EXE_STD$ALOPHYCNTG #define exe_std$alophycntg_s2 EXE_STD$ALOPHYCNTG_S2 #define exe_std$alophycntg_color EXE_STD$ALOPHYCNTG_COLOR #define exe_std$alophycntg_color_s2 EXE_STD$ALOPHYCNTG_COLOR_S2 #define exe_std$altquepkt EXE_STD$ALTQUEPKT #define exe$bugchk_cancel_remove_va EXE$BUGCHK_CANCEL_REMOVE_VA #define exe$bugchk_remove_va EXE$BUGCHK_REMOVE_VA #define exe$bus_delay EXE$BUS_DELAY #define exe$delay EXE$DELAY #define exe_std$carriage EXE_STD$CARRIAGE #define exe$cbb_allocate EXE$CBB_ALLOCATE #define exe$cbb_clear_bit EXE$CBB_CLEAR_BIT #define exe$cbb_clear_range EXE$CBB_CLEAR_RANGE #define exe$cbb_empty EXE$CBB_EMPTY #define exe$cbb_find_first_clear EXE$CBB_FIND_FIRST_CLEAR #define exe$cbb_find_first_clear_nolock EXE$CBB_FIND_FIRST_CLEAR_NOLOCK #define exe$cbb_find_first_set EXE$CBB_FIND_FIRST_SET #define exe$cbb_find_first_set_nolock EXE$CBB_FIND_FIRST_SET_NOLOCK #define exe$cbb_get_size EXE$CBB_GET_SIZE #define exe$cbb_initialize EXE$CBB_INITIALIZE #define exe$cbb_lock EXE$CBB_LOCK #define exe$cbb_rebuild EXE$CBB_REBUILD #define exe$cbb_set_bit EXE$CBB_SET_BIT #define exe$cbb_test_bit EXE$CBB_TEST_BIT #define exe$cbb_unlock EXE$CBB_UNLOCK #define exe$cbb_copy EXE$CBB_COPY #define exe$cbb_extract_bitmask EXE$CBB_EXTRACT_BITMASK #define exe$cbb_insert_bitmask EXE$CBB_INSERT_BITMASK #define exe$cbb_validate EXE$CBB_VALIDATE #define exe$cbb_zero EXE$CBB_ZERO #define exe$cbb_boolean_oper EXE$CBB_BOOLEAN_OPER #define exe_std$check_device_access EXE_STD$CHECK_DEVICE_ACCESS #define exe_std$chkpro_int EXE_STD$CHKPRO_INT #define exe_std$chkcreacces EXE_STD$CHKCREACCES #define exe_std$chkdelacces EXE_STD$CHKDELACCES #define exe_std$chkexeacces EXE_STD$CHKEXEACCES #define exe_std$chklogacces EXE_STD$CHKLOGACCES #define exe_std$chkphyacces EXE_STD$CHKPHYACCES #define exe_std$chkrdacces EXE_STD$CHKRDACCES #define exe_std$chkwrtacces EXE_STD$CHKWRTACCES #define exe_std$credit_bytcnt EXE_STD$CREDIT_BYTCNT #define exe_std$credit_bytcnt_bytlm EXE_STD$CREDIT_BYTCNT_BYTLM #define exe$credit_bytcnt_bytlm_id EXE$CREDIT_BYTCNT_BYTLM_ID #define exe_std$cvt_ipid_to_epid EXE_STD$CVT_IPID_TO_EPID #define exe_std$cvt_ipid_to_pcb EXE_STD$CVT_IPID_TO_PCB #define exe_std$deapaged EXE_STD$DEAPAGED #define exe_std$deanonpaged EXE_STD$DEANONPAGED #define exe_std$deanonpgdsiz EXE_STD$DEANONPGDSIZ #define exe_std$deap1block EXE_STD$DEAP1BLOCK #define exe_std$deap1 EXE_STD$DEAP1 #define exe_std$debit_bytcnt EXE_STD$DEBIT_BYTCNT #define exe_std$debit_bytcnt_alo EXE_STD$DEBIT_BYTCNT_ALO #define exe_std$debit_bytcnt_bytlm_nw EXE_STD$DEBIT_BYTCNT_BYTLM_NW #define exe_std$debit_bytcnt_bytlm_alo EXE_STD$DEBIT_BYTCNT_BYTLM_ALO #define exe_std$finishio EXE_STD$FINISHIO #define exe$illiofunc EXE$ILLIOFUNC #define exe_std$insert_irp EXE_STD$INSERT_IRP #define exe_std$insioq EXE_STD$INSIOQ #define exe_std$insioqc EXE_STD$INSIOQC #define exe_std$insioq_simple EXE_STD$INSIOQ_SIMPLE #define exe_std$instimq EXE_STD$INSTIMQ #define exe_std$iofork_cpu EXE_STD$IOFORK_CPU #define exe_std$iorsnwait EXE_STD$IORSNWAIT #define exe$kp_allocate_kpb EXE$KP_ALLOCATE_KPB #define exe$kp_alloc_rse_stack_p2_any EXE$KP_ALLOC_RSE_STACK_P2_ANY #define exe$kp_deallocate_kpb EXE$KP_DEALLOCATE_KPB #define exe$kp_end EXE$KP_END #define exe$kp_find_kpb EXE$KP_FIND_KPB #define exe$kp_fork EXE$KP_FORK #define exe$kp_fork_wait EXE$KP_FORK_WAIT #define exe$kp_restart EXE$KP_RESTART #define exe$kp_stall_general EXE$KP_STALL_GENERAL #define exe$kp_start EXE$KP_START #define exe_std$kp_startio EXE_STD$KP_STARTIO #define exe$kp_tqe_wait EXE$KP_TQE_WAIT #define exe$kp_alloc_mem_stack_user EXE$KP_ALLOC_MEM_STACK_USER #define exe$kp_dealloc_mem_stack_user EXE$KP_DEALLOC_MEM_STACK_USER #define exe$kp_user_alloc_kpb EXE$KP_USER_ALLOC_KPB #define exe$kp_stack_peaks EXE$KP_STACK_PEAKS #define exe$kp_spl_start EXE$KP_SPL_START /* X-81b Start */ #define exe$kp_spl_restart EXE$KP_SPL_RESTART #define exe$kp_spl_update_kpb EXE$KP_SPL_UPDATE_KPB #define exe$kp_spl_ctx_set EXE$KP_SPL_CTX_SET #define exe$kp_spl_stall_general EXE$KP_SPL_STALL_GENERAL #define exe$kp_spl_tqe_wait EXE$KP_SPL_TQE_WAIT #define exe$kp_rmvtimq EXE$KP_RMVTIMQ #define exe$kp_spl_fork EXE$KP_SPL_FORK #define exe$kp_spl_fork_wait EXE$KP_SPL_FORK_WAIT /* X-81b End */ #define exe$kp_spl_init_kpb EXE$KP_SPL_INIT_KPB /* X-82 */ #define exe$spl_ctx_set EXE$SPL_CTX_SET /* X-84b */ #define exe_std$lcldskvalid EXE_STD$LCLDSKVALID #define exe_std$lock_err_cleanup EXE_STD$LOCK_ERR_CLEANUP #define exe_std$maxacmode EXE_STD$MAXACMODE #define exe_std$mntversio EXE_STD$MNTVERSIO #define exe_std$modify EXE_STD$MODIFY #define exe_std$modifylock EXE_STD$MODIFYLOCK #define exe_std$mount_ver EXE_STD$MOUNT_VER #define exe_std$nam_to_pcb EXE_STD$NAM_TO_PCB #define exe_std$oneparm EXE_STD$ONEPARM #define exe_std$outzstring EXE_STD$OUTZSTRING #define exe_std$primitive_fork EXE_STD$PRIMITIVE_FORK #define exe_std$primitive_fork_wait EXE_STD$PRIMITIVE_FORK_WAIT #define exe_std$prober EXE_STD$PROBER #define exe_std$prober_dsc EXE_STD$PROBER_DSC #define exe_std$prober_dsc64 EXE_STD$PROBER_DSC64 #define exe_std$probew EXE_STD$PROBEW #define exe_std$probew_dsc EXE_STD$PROBEW_DSC #define exe_std$probew_dsc64 EXE_STD$PROBEW_DSC64 #define exe$psx_resume_and_wait EXE$PSX_RESUME_AND_WAIT #define exe$psx_set_fork_status EXE$PSX_SET_FORK_STATUS #define exe_std$qioacppkt EXE_STD$QIOACPPKT #define exe_std$qiodrvpkt EXE_STD$QIODRVPKT #define exe_std$qioserver_new_unit EXE_STD$QIOSERVER_NEW_UNIT #define exe_std$queue_fork EXE_STD$QUEUE_FORK #define exe_std$read EXE_STD$READ #define exe_std$readchk EXE_STD$READCHK #define exe_std$readlock EXE_STD$READLOCK #define exe_std$rmvtimq EXE_STD$RMVTIMQ #define exe_std$sensemode EXE_STD$SENSEMODE #define exe_std$setchar EXE_STD$SETCHAR #define exe_std$setmode EXE_STD$SETMODE #define exe_std$sndevmsg EXE_STD$SNDEVMSG #define exe_std$snglequota_long EXE_STD$SNGLEQUOTA_LONG #define exe_std$synch_loop EXE_STD$SYNCH_LOOP #define exe$timedwait_complete EXE$TIMEDWAIT_COMPLETE #define exe$timedwait_setup EXE$TIMEDWAIT_SETUP #define exe$timedwait_setup_10us EXE$TIMEDWAIT_SETUP_10US #define exe_std$write EXE_STD$WRITE #define exe_std$writechk EXE_STD$WRITECHK #define exe_std$writelock EXE_STD$WRITELOCK #define exe_std$wrtmailbox EXE_STD$WRTMAILBOX #define exe_std$zeroparm EXE_STD$ZEROPARM #define ini$brk INI$BRK #define exe$allocate_pool EXE$ALLOCATE_POOL #define exe$deallocate_pool EXE$DEALLOCATE_POOL #define exe$trim_pool_list EXE$TRIM_POOL_LIST #define exe$register_pool_info EXE$REGISTER_POOL_INFO #define exe$lock_pkta EXE$LOCK_PKTA #define exe$unlock_pkta EXE$UNLOCK_PKTA #define exe$lal_insert_first EXE$LAL_INSERT_FIRST #define exe$lal_remove_first EXE$LAL_REMOVE_FIRST #define exe$kprintf EXE$KPRINTF #define exe$kvprintf EXE$KVPRINTF #ifdef __ia64 /* Verified for IA64 port - KLN */ #define exe$save_f12_f15 EXE$SAVE_F12_F15 #define exe$save_hfp_registers EXE$SAVE_HFP_REGISTERS #define exe$restore_f12_f15 EXE$RESTORE_F12_F15 #define exe$restore_hfp_registers EXE$RESTORE_HFP_REGISTERS #define exe$rseregs_before EXE$RSEREGS_BEFORE #define exe$rseregs_between EXE$RSEREGS_BETWEEN #define exe$rseregs_beyond EXE$RSEREGS_BEYOND #define exe$rseregs_save EXE$RSEREGS_SAVE #define exe$rseregs_restore EXE$RSEREGS_RESTORE #endif #define exe$setstk_64_int EXE$SETSTK_64_INT /* Function prototypes for system routines with the EXE$ and EXE_STD$ prefix. */ int exe_std$abortio (IRP *irp, PCB *pcb, UCB *ucb, int qio_sts); int exe_std$alloc_bufio_32 (IRP *irp, PCB *pcb, void *uva32, int pktdatsiz); int exe_std$alloc_bufio_64 (IRP *irp, PCB *pcb, VOID_PQ uva64, int pktdatsiz); int exe_std$alloc_diagbuf (IRP *irp, VOID_PQ uva64, int pktdatsiz); int exe_std$allocbuf (int reqsize, int32 *alosize_p, void **bufptr_p); int exe_std$allocceb (int32 *alosize_p, CEB **ceb_p); int exe_std$allocirp (IRP **irp_p); int exe_std$allocjib (int32 *alosize_p, JIB **jib_p); int exe_std$allocpcb (int32 *alosize_p, PCB **pcb_p); int exe_std$alloctqe (int32 *alosize_p, TQE **tqe_p); int exe_std$alononpaged (int reqsize, int32 *alosize_p, void **pool_p); int exe_std$alopaged (int reqsize, int32 *alosize_p, void **pool_p); int exe_std$alop1imag (int reqsize, int32 *alosize_p, void **pool_p); int exe_std$alop1proc (int reqsize, int32 *alosize_p, void **pool_p); int exe_std$alophycntg (int npages, void **sva_p); int exe_std$alophycntg_s2 (int npages, VOID_PPQ sva_p); int exe_std$alophycntg_color (int npages, int rad, int byte_align, void **sva_p); int exe_std$alophycntg_color_s2 (int npages, int rad, int byte_align, VOID_PPQ sva_p); void exe_std$altquepkt (IRP *irp, UCB *ucb); int exe$bugchk_cancel_remove_va (VOID_PQ start_va, uint64 size_in_bytes); int exe$bugchk_remove_va (VOID_PQ start_va, uint64 size_in_bytes); int exe$bus_delay (ADP *adp); int exe$delay (int64 *delay_nanos); void exe_std$carriage (IRP *irp); int exe$cbb_allocate (CBB_PPQ cbb, int unitsize, int bits, int ipl, uint64 flags, int timeout_value); int exe$cbb_clear_bit (int flags, int bitpos, CBB_PQ src, CBB_PQ dst, INT_PQ ccode); int exe$cbb_clear_range (int flags, int start, int length, CBB_PQ src, CBB_PQ dst, INT_PQ ccode); int exe$cbb_empty (CBB_PQ cbb, int flags, INT_PQ state); int exe$cbb_find_first_clear (CBB_PQ cbb, int start, int flags, INT_PQ bitpos, INT_PQ ccode); int exe$cbb_find_first_set (CBB_PQ cbb, int start, int flags, INT_PQ bitpos, INT_PQ ccode); int exe$cbb_get_size (int unitsize, int bits, INT_PQ resultsize); int exe$cbb_initialize (CBB_PQ cbb, int blksiz, int unitsize, int bits, int ipl, uint64 flags, int timeout_value); int exe$cbb_lock (CBB_PQ cbb); int exe$cbb_rebuild (CBB_PQ cbb, int flags); int exe$cbb_set_bit (int flags, int bitpos, CBB_PQ src, CBB_PQ dst); int exe$cbb_test_bit (CBB_PQ cbb, int bitpos, int flags); int exe$cbb_unlock (CBB_PQ cbb); int exe$cbb_copy( CBB_PQ src, CBB_PQ dst, int length, int flags); int exe$cbb_extract_bitmask( CBB_PQ src, int start, int length, int flags, VOID_PQ bitmask_addr); int exe$cbb_insert_bitmask( int start, int length, int flags, VOID_PQ bitmask_addr, CBB_PQ cbb); int exe$cbb_validate (CBB_PQ cbb, int unitsize, int bits, int ipl, uint64 flags, int timeout_value, UINT64_PQ ret_flags); int exe$cbb_zero (CBB_PQ cbb, int flags); int exe$cbb_boolean_oper (int flags, int function, CBB_PQ cbb1, CBB_PQ cbb2, CBB_PQ dst, INT_PQ ccode); int exe_std$check_device_access(int, int, PCB *pcb, UCB *ucb); int exe_std$chkflupages (void); int exe_std$chkpro_int (ARB *arb, ORB *orb, CHPCTL *chpctl, CHPRET *chpret); int exe_std$chkcreacces (ARB *arb, ORB *orb, PCB *pcb, UCB *ucb); int exe_std$chkdelacces (ARB *arb, ORB *orb, PCB *pcb, UCB *ucb); int exe_std$chkexeacces (ARB *arb, ORB *orb, PCB *pcb, UCB *ucb); int exe_std$chklogacces (ARB *arb, ORB *orb, PCB *pcb, UCB *ucb); int exe_std$chkphyacces (ARB *arb, ORB *orb, PCB *pcb, UCB *ucb); int exe_std$chkrdacces (ARB *arb, ORB *orb, PCB *pcb, UCB *ucb); int exe_std$chkwrtacces (ARB *arb, ORB *orb, PCB *pcb, UCB *ucb); void exe_std$credit_bytcnt (int credit, PCB *pcb); void exe_std$credit_bytcnt_bytlm (int credit, PCB *pcb); int exe$credit_bytcnt_bytlm_id (int credit, int ipid); int exe_std$cvt_ipid_to_epid (int ipid); PCB *exe_std$cvt_ipid_to_pcb (int ipid); void exe_std$deapaged (void *pool); int exe_std$deanonpaged (void *pool); int exe_std$deanonpgdsiz (void *pool, int size); int exe_std$deap1 (void *pool, int size); int exe_std$deap1block (void *pool); int exe_std$debit_bytcnt (int debit, PCB *pcb); int exe_std$debit_bytcnt_alo (int debit, PCB *pcb, int32 *alosize_p, void **pool_p); int exe_std$debit_bytcnt_bytlm_alo (int debit, PCB *pcb, int32 *alosize_p, void **pool_p); int exe_std$debit_bytcnt_bytlm_nw (int debit, PCB *pcb); int exe_std$expandstk (VOID_PQ va); int exe_std$finishio (IRP *irp, UCB *ucb); int exe$illiofunc (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb); int exe_std$insert_irp (IRP **irp_lh, IRP *irp); void exe_std$insioq (IRP *irp, UCB *ucb); void exe_std$insioqc (IRP *irp, UCB *ucb); void exe_std$insioq_simple (IRP *irp, UCB *ucb); void exe_std$instimq (int duetim_lo, int duetim_hi, TQE *tqe); void exe_std$iofork_cpu (FKB *fkb, CPU *destcpudb); int exe_std$iorsnwait (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb, int qio_sts, int rsn); int exe$kp_allocate_kpb (KPB **kpb_p, int stksiz, int flags, int paramsiz); int exe$kp_alloc_rse_stack_p2_any (KPB_PQ kpb, const int stack_pages, unsigned int region_prot, unsigned int acmode); int exe$kp_deallocate_kpb (KPB *kpb); int exe$kp_end (KPB *kpb); KPB *exe$kp_find_kpb (void); int exe$kp_fork (KPB *kpb, FKB *fkb); int exe$kp_fork_wait (KPB *kpb, FKB *fkb); int exe$kp_restart (KPB *kpb, int thread_sts); int exe$kp_stall_general (KPB *kpb); int exe$kp_start (KPB *kpb, void (*rout)(KPB *kpb), int64 regmask); void exe_std$kp_startio (IRP *irp, UCB *ucb); int exe$kp_tqe_wait (KPB *kpb, int64 *ticks, int spnlidx); int exe$kp_alloc_mem_stack(KPB_PQ kpb, int stack_pages); int exe$kp_dealloc_mem_stack(KPB_PQ kpb); int exe$kp_alloc_rse_stack(KPB_PQ kpb, int stack_pages); int exe$kp_dealloc_rse_stack(KPB_PQ kpb); int exe$kp_alloc_rse_stack_p2(KPB_PQ kpb, int stack_pages); int exe$kp_dealloc_rse_stack_p2(KPB_PQ kpb); int exe$kp_alloc_mem_stack_user(KPB_PQ kpb, const int stack_pages); int exe$kp_dealloc_mem_stack_user(KPB_PQ kpb); int exe$kp_stack_peaks(KPB_PQ kpb); int exe$kp_user_alloc_kpb(KPB **kpb_p, int flags, int param_size, int (*kpb_alloc)(), int mem_stack_bytes, int (*memstk_alloc)(), int rse_stack_bytes, int (*rsestk_alloc)(), void (*end_rtn)()); /* X-81c Begin */ int exe$kp_spl_start (KPB *kpb, /* Kernel Process Block address */ void (*rout)(KPB *kpb), /* Routine to execute as KPB */ int64 regmask, /* Register mask (0 to default) */ int64 flags); /* X-84c Not-releaseable flags */ int exe$kp_spl_restart (KPB *kpb, /* Kernel Process Block address */ int thread_sts, /* Status to pass to restarted thread */ int64 flags); /* X-84c Not-releaseable flags */ int exe$kp_spl_update_kpb (KPB *kpb, /* Kernel Process Block address */ int64 flags, /* X-84c Not-releaseable flags to add */ SPL *spl_fork, /* Fork spinlock address */ SPL *spl_port, /* Port spinlock address */ SPL *spl_dyn); /* Dynamic spinlock address */ int exe$kp_spl_ctx_set (KPB *kpb, /* Kernel Process Block address */ int64 req_spl_ctx, /* Spinlock control flags */ int64 *prev_spl_ctx); /* Returned previous spinlock context (opt) */ int exe$spl_ctx_set /* X-84b */ (int64 req_spl_ctx, /* Requested spinlock context & control bits */ SPL *spl_fork, /* Fork spinlock address */ SPL *spl_port, /* Port spinlock address */ SPL *spl_dyn, /* Dynamic spinlock address */ int64 *prev_spl_ctx); /* Returned previous spinlock context (opt) */ int exe$kp_spl_stall_general (KPB *kpb, /* Kernel Process Block address */ void (*sch_stall_rtn)()); /* Schedule stall routine (opt) */ int exe$kp_spl_tqe_wait /* X-84d */ (KPB *kpb, /* Kernel Process Block address */ int64 *ticks); /* EXE$GQ_SYSTIME ticks */ int exe$kp_rmvtimq (KPB *kpb); /* Kernel Process Block address */ int exe$kp_spl_fork /* X-84d */ (KPB *kpb, /* Kernel Process Block address */ FKB *fkb); /* Fork Block address */ int exe$kp_spl_fork_wait /* X-84d */ (KPB *kpb, /* Kernel Process Block address */ FKB *fkb); /* Fork Block address */ /* X-81c End */ int exe$kp_spl_init_kpb /* X-82 */ (KPB *kpb, /* Kernel Process Block address */ SPL *spl_fork, /* Fork spinlock address */ SPL *spl_port, /* Port spinlock address */ SPL *spl_dyn); /* Dynamic spinlock address */ int exe$kprintf(char *form, ...); int exe$kvprintf (char *form, char *__va_list_arg); int exe_std$lcldskvalid (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb); void exe_std$lock_err_cleanup (IRP *irp); int exe_std$maxacmode (int acmode); void exe$lal_insert_first(void *packet, VOID_PQ listhead); void *exe$lal_remove_first(VOID_PQ listhead); #pragma message save #pragma message disable noparmlist void exe_std$mntversio (void (*rout)(), IRP *irp, UCB *ucb); #pragma message restore int exe_std$modify (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb); #pragma message save #pragma message disable noparmlist #ifdef __INITIAL_POINTER_SIZE /* Defined if support for 64-bit pointers */ int exe_std$modifylock (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb, VOID_PQ buf, int bufsiz, void (*err_rout)()); #else int exe_std$modifylock (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb, void *buf, int bufsiz, void (*err_rout()); #endif /* __INITIAL_POINTER_SIZE */ #pragma message restore int exe_std$mount_ver (int iost1, int iost2, IRP *irp, UCB *ucb); #ifdef __INITIAL_POINTER_SIZE /* Defined if support for 64-bit pointers */ int exe_std$nam_to_pcb(INT_PQ pid_p,VOID_PQ prcnam_p,int nsa_id,PCB *pcb, int *rpid_p,KTB **rktb_p,PCB **rpcb_p); #else int exe_std$nam_to_pcb(int *pid_p,void *prcnam_p,int nsa_id,PCB *pcb, int *rpid_p,KTB **rktb_p,PCB **rpcb_p); #endif /* __INITIAL_POINTER_SIZE */ int exe_std$oneparm (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb); void exe_std$outzstring (char *string); void exe_std$primitive_fork (int64 fr3, int64 fr4, FKB *fkb); void exe_std$primitive_fork_wait (int64 fr3, int64 fr4, FKB *fkb); int exe_std$prober (VOID_PQ buf, int bufsiz, int acmode); int exe_std$prober_dsc (void *dsc_p); int exe_std$probew (VOID_PQ buf, int bufsiz, int acmode); int exe_std$probew_dsc (void *dsc_p); int exe_std$prober_dsc64 (VOID_PQ dsc_p, UINT64_PQ ret_length, CHAR_PPQ ret_bufadr); int exe_std$probew_dsc64 (VOID_PQ dsc_p, UINT64_PQ ret_length, CHAR_PPQ ret_bufadr); int exe_std$qioacppkt (IRP *irp, PCB *pcb, UCB *ucb); int exe_std$qiodrvpkt (IRP *irp, UCB *ucb); int exe_std$qioserver_new_unit (UCB *ucb); void exe_std$queue_fork (FKB *fkb); int exe$psx_resume_and_wait (PCB *child_pcb); void exe$psx_set_fork_status (PCB *child_pcb, int status); int exe_std$read (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb); #ifdef __INITIAL_POINTER_SIZE /* Defined if support for 64-bit pointers */ int exe_std$readchk (IRP *irp, PCB *pcb, UCB *ucb, VOID_PQ buf, int bufsiz); #else int exe_std$readchk (IRP *irp, PCB *pcb, UCB *ucb, void *buf, int bufsiz); #endif /* __INITIAL_POINTER_SIZE */ #pragma message save #pragma message disable noparmlist #ifdef __INITIAL_POINTER_SIZE /* Defined if support for 64-bit pointers */ int exe_std$readlock (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb, VOID_PQ buf, int bufsiz, void (*err_rout)()); #else int exe_std$readlock (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb, void *buf, int bufsiz, void (*err_rout)()); #endif /* __INITIAL_POINTER_SIZE */ #pragma message restore int exe_std$rmvtimq (int acmode, int reqid, int remval, int ipid); int exe_std$sensemode (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb); int exe_std$setchar (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb); int exe_std$setmode (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb); int exe_std$sndevmsg (MB_UCB *mb_ucb, int msgtyp, UCB *ucb); int exe_std$snglequota_long (int32 *quota_p, PCB *pcb); int exe_std$synch_loop (int efn, VOID_PQ iosb); int exe$timedwait_complete (int64 *end_value_p); int exe$timedwait_setup (int64 *delay_nanos, int64 *end_value_p); int exe$timedwait_setup_10us (int64 *delay_10us, int64 *end_value_p); int exe_std$write (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb); #ifdef __INITIAL_POINTER_SIZE /* Defined if support for 64-bit pointers */ int exe_std$writechk (IRP *irp, PCB *pcb, UCB *ucb, VOID_PQ buf, int bufsiz); #else int exe_std$writechk (IRP *irp, PCB *pcb, UCB *ucb, void *buf, int bufsiz); #endif /* __INITIAL_POINTER_SIZE */ #pragma message save #pragma message disable noparmlist #ifdef __INITIAL_POINTER_SIZE /* Defined if support for 64-bit pointers */ int exe_std$writelock (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb, VOID_PQ buf, int bufsiz, void (*err_rout)()); #else int exe_std$writelock (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb, void *buf, int bufsiz, void (*err_rout)()); #endif /* __INITIAL_POINTER_SIZE */ #pragma message restore int exe_std$wrtmailbox (MB_UCB *mb_ucb, int msgsiz, void *msg,...); int exe_std$zeroparm (IRP *irp, PCB *pcb, UCB *ucb, CCB *ccb); void ini$brk (void); /* The definition of these funcs must have their own prototypes. That is because they have optional parameters, and it works much better to specify "..." for callers and the actual args for the function itself. */ #if !defined(MEMORYALC_POOL_SRC) #ifdef __INITIAL_POINTER_SIZE /* Defined if support for 64-bit pointers */ int exe$allocate_pool(int requestSize, MMG$POOL_TYPE poolType, int alignment, UINT64_PQ allocatedSize, VOID_PPQ returnBlock,...); void exe$deallocate_pool(VOID_PQ returnBlock, MMG$POOL_TYPE poolType, int size,...); int exe$trim_pool_list(int reqSize, MMG$POOL_TYPE poolType, int percent,...); #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __long #endif #pragma message save #pragma message disable noparmlist int exe$register_pool_info(int (*need_memory_callback)(), MMG$POOL_TYPE poolType, uint64 userParam, int maxSize, int minSize, uint64 extra_param_1,uint64 extra_param_2); #pragma message restore #ifdef __INITIAL_POINTER_SIZE #pragma __required_pointer_size __short #endif /* Extra_param_n have pool_type-specific semantics. They are PA base and length for BAP*/ /* No 32-bit only version */ #endif #endif /*MEMORYALC_POOL_SRC*/ int exe$lock_pkta(void); int exe$unlock_pkta(void); void exe$check_for_mem_error(CPU *cpudb); int exe$primitive_mcheck(int vec); int exe$setup_memtest_env(void); int exe$clear_memtest_env(void); /* Routine for System event notification */ #define exe$event_notify EXE$EVENT_NOTIFY void exe$event_notify (uint64 event_mask); #ifdef __ia64 /*Verified for IA64 port BF*/ #pragma __required_pointer_size __long /* Floating point save/restore routines */ void exe$save_f12_f15(void *save_area); void exe$save_hfp_registers(void *area); void exe$restore_f12_f15(void *save_area); void exe$restore_hfp_registers(void *area); uint64 *exe$rseregs_before (uint64 *baseAddress, uint64 slots); uint64 exe$rseregs_between (uint64 *greaterAddress, uint64 *lesserAddress); uint64 *exe$rseregs_beyond (uint64 *baseAddress, uint64 slots); int exe$rseregs_save (INTSTK const * const intframe, uint64 regOutput[96], uint64 *addrOutput[96], uint64 natOutput[2], uint64 * * const endBackingStore, uint64 * * const endLastNaTSlot, RSC * const endSaveRsc); void exe$rseregs_restore (INTSTK const * const intframe, uint64 regOutput[96], uint64 natOutput[2], uint64 * const startBackingStore, uint64 * const startLastNaTSlot, RSC const saveRsc); #pragma __required_pointer_size __short #endif /* Routine for setting memory and register stack limits */ int exe$setstk_64_int (VOID_PQ start_va, uint64 length, int acmode, uint64 flags, VOID_PPQ prev_start_va, UINT64_PQ prev_length); /* Routines for dealing with whole program floating point modes */ #pragma __required_pointer_size __long typedef struct _return_2quads_t { unsigned __int64 quad0; unsigned __int64 quad1; } RETURN_2QUADS_T; void exe$set_whole_pgm_fp_mode(struct _ieee *wpfpValue); RETURN_2QUADS_T exe$revert_whole_pgm_fp_mode(unsigned __int64 newHW,struct _ieee newSW); #pragma message save #ifdef __ia64 #pragma message disable showmaplinkage #endif #pragma linkage exe$$linkage_return_r0_and_r1=(result(r0,r1)) #pragma use_linkage exe$$linkage_return_r0_and_r1 (exe$revert_whole_pgm_fp_mode) #pragma message restore #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __restore /* Restore the previously-defined required ptr size */ #endif #endif /* __EXE_ROUTINES_LOADED */