void fgncal_zlinit (void)
{
void fgncal_rtn(), gtm$fgncall();
bool dummy;
dummy = zlput_rname(CODE_ADDRESS(fgncal_rtn));
assert(TRUE == dummy);
dummy = zlput_rname(CODE_ADDRESS(gtm$fgncall));
assert(TRUE == dummy);
}
/* NOTE: every malloc'd storage here should be free'd in a nested call-in environment.
* gtmci_isv_restore (in gtmci_isv.c) needs to be reflected for any future mallocs added here. */
void ecode_init(void)
{
dollar_ecode.begin = (char *)malloc(DOLLAR_ECODE_ALLOC);
dollar_ecode.top = dollar_ecode.begin + DOLLAR_ECODE_ALLOC;
dollar_ecode.array = (dollar_ecode_struct *)malloc(SIZEOF(dollar_ecode_struct) * DOLLAR_ECODE_MAXINDEX);
dollar_ecode.error_rtn_addr = NON_IA64_ONLY(CODE_ADDRESS(ERROR_RTN)) IA64_ONLY(CODE_ADDRESS_C(ERROR_RTN));
dollar_ecode.error_rtn_ctxt = GTM_CONTEXT(ERROR_RTN);
dollar_ecode.error_return_addr = (error_ret_fnptr)ERROR_RETURN;
dollar_stack.begin = (char *)malloc(DOLLAR_STACK_ALLOC);
dollar_stack.top = dollar_stack.begin + DOLLAR_STACK_ALLOC;
dollar_stack.array = (dollar_stack_struct *)malloc(SIZEOF(dollar_stack_struct) * DOLLAR_STACK_MAXINDEX);
NULLIFY_DOLLAR_ECODE; /* this macro resets dollar_ecode.{end,index}, dollar_stack.{begin,index,incomplete} and
* first_ecode_error_frame to point as if no error occurred at all */
}
void gtm_startup(struct startup_vector *svec)
/* Note: various references to data copied from *svec could profitably be referenced directly */
{
unsigned char *mstack_ptr;
void gtm_ret_code();
static readonly unsigned char init_break[1] = {'B'};
int4 lct;
int i;
static char other_mode_buf[] = "OTHER";
mstr log_name;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(INVALID_IMAGE != image_type);
assert(svec->argcnt == SIZEOF(*svec));
IA64_ONLY(init_xfer_table());
get_page_size();
cache_table_relobjs = &cache_table_rebuild;
ht_rhash_ch = &hashtab_rehash_ch;
jbxm_dump_ch = &jobexam_dump_ch;
heartbeat_timer_ptr = &heartbeat_timer;
stpgc_ch = &stp_gcol_ch;
rtn_fst_table = rtn_names = (rtn_tabent *)svec->rtn_start;
rtn_names_end = rtn_names_top = (rtn_tabent *)svec->rtn_end;
if (svec->user_stack_size < 4096)
svec->user_stack_size = 4096;
if (svec->user_stack_size > 8388608)
svec->user_stack_size = 8388608;
mstack_ptr = (unsigned char *)malloc(svec->user_stack_size);
msp = stackbase = mstack_ptr + svec->user_stack_size - mvs_size[MVST_STORIG];
/* mark the stack base so that if error occur during call-in gtm_init(), the unwind
* logic in gtmci_ch() will get rid of the stack completely
*/
fgncal_stack = stackbase;
mv_chain = (mv_stent *)msp;
mv_chain->mv_st_type = MVST_STORIG; /* Initialize first (anchor) mv_stent so doesn't do anything */
mv_chain->mv_st_next = 0;
mv_chain->mv_st_cont.mvs_storig = 0;
stacktop = mstack_ptr + 2 * mvs_size[MVST_NTAB];
stackwarn = stacktop + (16 * 1024);
break_message_mask = svec->break_message_mask;
if (svec->user_strpl_size < STP_INITSIZE)
svec->user_strpl_size = STP_INITSIZE;
else if (svec->user_strpl_size > STP_MAXINITSIZE)
svec->user_strpl_size = STP_MAXINITSIZE;
stp_init(svec->user_strpl_size);
if (svec->user_indrcache_size > MAX_INDIRECTION_NESTING || svec->user_indrcache_size < MIN_INDIRECTION_NESTING)
svec->user_indrcache_size = MIN_INDIRECTION_NESTING;
TREF(ind_result_array) = (mval **)malloc(SIZEOF(mval *) * svec->user_indrcache_size);
TREF(ind_source_array) = (mval **)malloc(SIZEOF(mval *) * svec->user_indrcache_size);
TREF(ind_result_sp) = TREF(ind_result_array);
TREF(ind_result_top) = TREF(ind_result_sp) + svec->user_indrcache_size;
TREF(ind_source_sp) = TREF(ind_source_array);
TREF(ind_source_top) = TREF(ind_source_sp) + svec->user_indrcache_size;
rts_stringpool = stringpool;
TREF(compile_time) = FALSE;
/* assert that is_replicator and run_time is properly set by gtm_imagetype_init invoked at process entry */
# ifdef DEBUG
switch (image_type)
{
case GTM_IMAGE:
case GTM_SVC_DAL_IMAGE:
assert(is_replicator && run_time);
break;
case MUPIP_IMAGE:
assert(!is_replicator && !run_time);
break;
default:
assert(FALSE);
}
# endif
gtm_utf8_init(); /* Initialize the runtime for Unicode */
/* Initialize alignment requirement for the runtime stringpool */
log_name.addr = DISABLE_ALIGN_STRINGS;
log_name.len = STR_LIT_LEN(DISABLE_ALIGN_STRINGS);
/* mstr_native_align = logical_truth_value(&log_name, FALSE, NULL) ? FALSE : TRUE; */
mstr_native_align = FALSE; /* TODO: remove this line and uncomment the above line */
getjobname();
INVOKE_INIT_SECSHR_ADDRS;
getzprocess();
getzmode();
geteditor();
zcall_init();
cmd_qlf.qlf = glb_cmd_qlf.qlf;
cache_init();
# ifdef __sun
if (NULL != GETENV(PACKAGE_ENV_TYPE)) /* chose xcall (default) or rpc zcall */
xfer_table[xf_fnfgncal] = (xfer_entry_t)op_fnfgncal_rpc; /* using RPC */
# endif
msp -= SIZEOF(stack_frame);
frame_pointer = (stack_frame *)msp;
memset(frame_pointer,0, SIZEOF(stack_frame));
frame_pointer->temps_ptr = (unsigned char *)frame_pointer;
frame_pointer->ctxt = GTM_CONTEXT(gtm_ret_code);
frame_pointer->mpc = CODE_ADDRESS(gtm_ret_code);
frame_pointer->type = SFT_COUNT;
frame_pointer->rvector = (rhdtyp*)malloc(SIZEOF(rhdtyp));
memset(frame_pointer->rvector, 0, SIZEOF(rhdtyp));
symbinit();
/* Variables for supporting $ZSEARCH sorting and wildcard expansion */
TREF(zsearch_var) = lv_getslot(curr_symval);
TREF(zsearch_dir1) = lv_getslot(curr_symval);
TREF(zsearch_dir2) = lv_getslot(curr_symval);
LVVAL_INIT((TREF(zsearch_var)), curr_symval);
LVVAL_INIT((TREF(zsearch_dir1)), curr_symval);
LVVAL_INIT((TREF(zsearch_dir2)), curr_symval);
/* Initialize global pointer to control-C handler. Also used in iott_use */
ctrlc_handler_ptr = &ctrlc_handler;
io_init(IS_MUPIP_IMAGE); /* starts with nocenable for GT.M runtime, enabled for MUPIP */
if (!IS_MUPIP_IMAGE)
{
sig_init(generic_signal_handler, ctrlc_handler_ptr, suspsigs_handler, continue_handler);
atexit(gtm_exit_handler);
cenable(); /* cenable unless the environment indicates otherwise - 2 steps because this can report errors */
}
jobinterrupt_init();
getzdir();
dpzgbini();
zco_init();
/* a base addr of 0 indicates a gtm_init call from an rpc server */
if ((GTM_IMAGE == image_type) && (NULL != svec->base_addr))
jobchild_init();
else
{ /* Trigger enabled utilities will enable through here */
(TREF(dollar_zmode)).mvtype = MV_STR;
(TREF(dollar_zmode)).str.addr = other_mode_buf;
(TREF(dollar_zmode)).str.len = SIZEOF(other_mode_buf) -1;
}
svec->frm_ptr = (unsigned char *)frame_pointer;
dollar_ztrap.mvtype = MV_STR;
dollar_ztrap.str.len = SIZEOF(init_break);
dollar_ztrap.str.addr = (char *)init_break;
dollar_zstatus.mvtype = MV_STR;
dollar_zstatus.str.len = 0;
dollar_zstatus.str.addr = NULL;
ecode_init();
zyerror_init();
ztrap_form_init();
ztrap_new_init();
zdate_form_init(svec);
dollar_system_init(svec);
init_callin_functable();
gtm_env_xlate_init();
SET_LATCH_GLOBAL(&defer_latch, LOCK_AVAILABLE);
curr_pattern = pattern_list = &mumps_pattern;
pattern_typemask = mumps_pattern.typemask;
initialize_pattern_table();
ce_init(); /* initialize compiler escape processing */
/* Initialize local collating sequence */
TREF(transform) = TRUE;
lct = find_local_colltype();
if (lct != 0)
{
TREF(local_collseq) = ready_collseq(lct);
if (!TREF(local_collseq))
{
exi_condition = -ERR_COLLATIONUNDEF;
gtm_putmsg(VARLSTCNT(3) ERR_COLLATIONUNDEF, 1, lct);
exit(exi_condition);
}
} else
TREF(local_collseq) = 0;
prealloc_gt_timers();
gt_timers_add_safe_hndlrs();
for (i = 0; FNPC_MAX > i; i++)
{ /* Initialize cache structure for $Piece function */
(TREF(fnpca)).fnpcs[i].pcoffmax = &(TREF(fnpca)).fnpcs[i].pstart[FNPC_ELEM_MAX];
(TREF(fnpca)).fnpcs[i].indx = i;
}
(TREF(fnpca)).fnpcsteal = (TREF(fnpca)).fnpcs; /* Starting place to look for cache reuse */
(TREF(fnpca)).fnpcmax = &(TREF(fnpca)).fnpcs[FNPC_MAX - 1]; /* The last element */
/* Initialize zwrite subsystem. Better to do it now when we have storage to allocate than
* if we fail and storage allocation may not be possible. To that end, pretend we have
* seen alias acitivity so those structures are initialized as well.
*/
assert(FALSE == curr_symval->alias_activity);
curr_symval->alias_activity = TRUE;
lvzwr_init((enum zwr_init_types)0, (mval *)NULL);
curr_symval->alias_activity = FALSE;
if ((NULL != (TREF(mprof_env_gbl_name)).str.addr))
turn_tracing_on(TADR(mprof_env_gbl_name), TRUE, (TREF(mprof_env_gbl_name)).str.len > 0);
return;
}
void trans_code_cleanup(void)
{
stack_frame *fp;
uint4 err;
error_def(ERR_STACKCRIT);
error_def(ERR_ERRWZTRAP);
error_def(ERR_ERRWETRAP);
error_def(ERR_ERRWIOEXC);
assert(!(SFT_ZINTR & proc_act_type));
/* With no extra ztrap frame being pushed onto stack, we may miss error(s)
* during trans_code if we don't check proc_act_type in addition to
* frame_pointer->type below.
*/
if (SFT_ZTRAP == proc_act_type)
{
if (0 < dollar_ztrap.str.len)
err = (int)ERR_ERRWZTRAP;
else
{
assert(0 < dollar_etrap.str.len);
err = (int)ERR_ERRWETRAP;
}
frame_pointer->flags |= SFF_ZTRAP_ERR;
} else if (SFT_DEV_ACT == proc_act_type)
{
err = ERR_ERRWIOEXC;
frame_pointer->flags |= SFF_DEV_ACT_ERR;
} else
err = 0;
proc_act_type = 0;
if (compile_time)
{
compile_time = FALSE;
if (stringpool.base != rts_stringpool.base)
stringpool = rts_stringpool;
}
for (fp = frame_pointer; fp; fp = fp->old_frame_pointer)
{
if (fp->type & SFT_DM)
break;
if (fp->type & SFT_COUNT)
{
assert(NULL != err_act);
if (!IS_ETRAP)
dm_setup();
break;
}
if (fp->type)
{
SET_ERR_CODE(fp, err);
}
/* If this frame is indicated for cache cleanup, do that cleanup
now before we get rid of the pointers used by that cleanup.
*/
IF_INDR_FRAME_CLEANUP_CACHE_ENTRY_AND_UNMARK(fp);
fp->mpc = CODE_ADDRESS(pseudo_ret);
fp->ctxt = CONTEXT(pseudo_ret);
}
transform = TRUE;
if (err)
dec_err(VARLSTCNT(1) err);
}
void trans_code_cleanup(void)
{
stack_frame *fp, *fpprev;
uint4 errmsg;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(!(SFT_ZINTR & proc_act_type));
/* With no extra ztrap frame being pushed onto stack, we may miss error(s)
* during trans_code if we don't check proc_act_type in addition to
* frame_pointer->type below.
*/
if (SFT_ZTRAP == proc_act_type)
{
if (0 < dollar_ztrap.str.len)
errmsg = ERR_ERRWZTRAP;
else
errmsg = ERR_ERRWETRAP;
} else if (SFT_DEV_ACT == proc_act_type)
errmsg = ERR_ERRWIOEXC;
else
errmsg = 0;
proc_act_type = 0;
if (TREF(compile_time))
{
TREF(compile_time) = FALSE;
if (stringpool.base != rts_stringpool.base)
stringpool = rts_stringpool;
}
for (fp = frame_pointer; fp; fp = fpprev)
{
fpprev = fp->old_frame_pointer;
# ifdef GTM_TRIGGER
if (SFT_TRIGR & fpprev->type)
fpprev = *(stack_frame **)(fpprev + 1);
# endif
if (fp->type & SFT_DM)
break;
if (fp->type & SFT_COUNT)
{
if ((ERR_ERRWZTRAP == errmsg) || (ERR_ERRWETRAP == errmsg))
{ /* Whether ETRAP or ZTRAP we want to rethrow the error at one level down */
SET_ERROR_FRAME(fp); /* reset error_frame to point to the closest counted frame */
assert(fp->flags & SFF_ETRAP_ERR);
/* Turn off any device exception related flags now that we are going to handle errors using
* $ETRAP or $ZTRAP AT THE PARENT LEVEL only (no more device exceptions).
*/
dollar_ztrap.str.len = 0;
ztrap_explicit_null = FALSE;
fp->flags &= SFF_DEV_ACT_ERR_OFF;
fp->flags &= SFF_ZTRAP_ERR_OFF;
err_act = &dollar_etrap.str;
break;
} else if (ERR_ERRWIOEXC == errmsg)
{ /* Error while compiling device exception. Set SFF_ETRAP_ERR bit so control is transferred to
* error_return() which in turn will rethrow the error AT THE SAME LEVEL in order to try and
* use $ZTRAP or $ETRAP whichever is active. Also set the SFF_DEV_ACT_ERR bit to signify this
* is a device exception that is rethrown instead of a ztrap/etrap error. Also assert that
* the rethrow will not use IO exception again (thereby ensuring error processing will
* eventually terminate instead of indefinitely recursing).
*/
fp->flags |= (SFF_DEV_ACT_ERR | SFF_ETRAP_ERR);
assert(NULL == active_device); /* mdb_condition_handler should have reset it */
break;
} else if ((ERR_ERRWZBRK == errmsg) || (ERR_ERRWEXC == errmsg))
{ /* For typical exceptions in ZBREAK and ZSTEP, get back to direct mode */
dm_setup();
break;
} else
{ /* The only known way to be here is if the command is a command given in direct mode as
* mdb_condition_handler won't drive an error handler in that case which would be caught in
* one of the above conditions. Not breaking out of the loop here means the frame will just
* unwind and we'll break on the direct mode frame which will be redriven. If the parent frame
* is not a direct mode frame, we'll assert in debug or break in pro and just continue.
* to direct mode.
*/
assert(fp->flags && (SFF_INDCE));
if (!fp->old_frame_pointer || !(fp->old_frame_pointer->type & SFT_DM))
{
assert(FALSE);
break;
}
}
}
if (fp->type)
{
SET_ERR_CODE(fp, errmsg);
}
/* If this frame is indicated for cache cleanup, do that cleanup
* now before we get rid of the pointers used by that cleanup.
*/
IF_INDR_FRAME_CLEANUP_CACHE_ENTRY_AND_UNMARK(fp);
fp->mpc = CODE_ADDRESS(pseudo_ret);
fp->ctxt = GTM_CONTEXT(pseudo_ret);
fp->flags &= SFF_IMPLTSTART_CALLD_OFF; /* Frame enterable now with mpc reset */
GTMTRIG_ONLY(DBGTRIGR((stderr, "trans_code_cleanup: turning off SFF_IMPLTSTART_CALLD in frame 0x"lvaddr"\n",
frame_pointer)));
}
TREF(transform) = TRUE;
if (0 != errmsg)
dec_err(VARLSTCNT(1) errmsg);
}
int gtm_trigger(gv_trigger_t *trigdsc, gtm_trigger_parms *trigprm)
{
mval *lvvalue;
lnr_tabent *lbl_offset_p;
uchar_ptr_t transfer_addr;
lv_val *lvval;
mname_entry *mne_p;
uint4 *indx_p;
ht_ent_mname *tabent;
boolean_t added;
int clrlen, rc, i, unwinds;
mval **lvvalarray;
mv_stent *mv_st_ent;
symval *new_symval;
uint4 dollar_tlevel_start;
stack_frame *fp, *fpprev;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(!skip_dbtriggers); /* should not come here if triggers are not supposed to be invoked */
assert(trigdsc);
assert(trigprm);
assert((NULL != trigdsc->rtn_desc.rt_adr) || ((MV_STR & trigdsc->xecute_str.mvtype)
&& (0 != trigdsc->xecute_str.str.len)
&& (NULL != trigdsc->xecute_str.str.addr)));
assert(dollar_tlevel);
/* Determine if trigger needs to be compiled */
if (NULL == trigdsc->rtn_desc.rt_adr)
{ /* No routine hdr addr exists. Need to do compile */
if (0 != gtm_trigger_complink(trigdsc, TRUE))
{
PRN_ERROR; /* Leave record of what error caused the compilation failure if any */
rts_error(VARLSTCNT(4) ERR_TRIGCOMPFAIL, 2, trigdsc->rtn_desc.rt_name.len, trigdsc->rtn_desc.rt_name.addr);
}
}
assert(trigdsc->rtn_desc.rt_adr);
assert(trigdsc->rtn_desc.rt_adr == CURRENT_RHEAD_ADR(trigdsc->rtn_desc.rt_adr));
/* Setup trigger environment stack frame(s) for execution */
if (!(frame_pointer->type & SFT_TRIGR))
{ /* Create new trigger base frame first that back-stops stack unrolling and return to us */
if (GTM_TRIGGER_DEPTH_MAX < (gtm_trigger_depth + 1)) /* Verify we won't nest too deep */
rts_error(VARLSTCNT(3) ERR_MAXTRIGNEST, 1, GTM_TRIGGER_DEPTH_MAX);
DBGTRIGR((stderr, "gtm_trigger: PUSH: frame_pointer 0x%016lx ctxt value: 0x%016lx\n", frame_pointer, ctxt));
/* Protect against interrupts while we have only a trigger base frame on the stack */
DEFER_INTERRUPTS(INTRPT_IN_TRIGGER_NOMANS_LAND);
/* The current frame invoked a trigger. We cannot return to it for a TP restart or other reason unless
* either the total operation (including trigger) succeeds and we unwind normally or unless the mpc is reset
* (like what happens in various error or restart conditions) because right now it returns to where a database
* command (KILL, SET or ZTRIGGER) was entered. Set flag in the frame to prevent MUM_TSTART unless the frame gets
* reset.
*/
frame_pointer->flags |= SFF_TRIGR_CALLD; /* Do not return to this frame via MUM_TSTART */
DBGTRIGR((stderr, "gtm_trigger: Setting SFF_TRIGR_CALLD in frame 0x"lvaddr"\n", frame_pointer));
base_frame(trigdsc->rtn_desc.rt_adr);
/* Finish base frame initialization - reset mpc/context to return to us without unwinding base frame */
frame_pointer->type |= SFT_TRIGR;
# if defined(__hpux) && defined(__hppa)
/* For HPUX-HPPA (PA-RISC), we use longjmp() to return to gtm_trigger() to avoid some some space register
* corruption issues. Use call-ins already existing mechanism for doing this. Although we no longer support
* HPUX-HPPA for triggers due to some unlocated space register error, this code (effectively always ifdef'd
* out) left in in case it gets resurrected in the future (01/2010 SE).
*/
frame_pointer->mpc = CODE_ADDRESS(ci_ret_code);
frame_pointer->ctxt = GTM_CONTEXT(ci_ret_code);
# else
frame_pointer->mpc = CODE_ADDRESS(gtm_levl_ret_code);
frame_pointer->ctxt = GTM_CONTEXT(gtm_levl_ret_code);
# endif
/* This base stack frame is also where we save environmental info for all triggers invoked at this stack level.
* Subsequent triggers fired at this level in this trigger invocation need only reinitialize a few things but
* can avoid "the big save".
*/
if (NULL == trigr_symval_list)
{ /* No available symvals for use with this trigger, create one */
symbinit(); /* Initialize a symbol table the trigger will use */
curr_symval->trigr_symval = TRUE; /* Mark as trigger symval so will be saved not decommissioned */
} else
{ /* Trigger symval is available for reuse */
new_symval = trigr_symval_list;
assert(new_symval->trigr_symval);
trigr_symval_list = new_symval->last_tab; /* dequeue new curr_symval from list */
REINIT_SYMVAL_BLK(new_symval, curr_symval);
curr_symval = new_symval;
PUSH_MV_STENT(MVST_STAB);
mv_chain->mv_st_cont.mvs_stab = new_symval; /* So unw_mv_ent() can requeue it for later use */
}
/* Push our trigger environment save mv_stent onto the chain */
PUSH_MV_STENT(MVST_TRIGR);
mv_st_ent = mv_chain;
/* Initialize the mv_stent elements processed by stp_gcol which can be called by either op_gvsavtarg() or
* by the extnam saving code below. This initialization keeps stp_gcol - should it be called - from attempting
* to process unset fields filled with garbage in them as valid mstr address/length pairs.
*/
mv_st_ent->mv_st_cont.mvs_trigr.savtarg.str.len = 0;
mv_st_ent->mv_st_cont.mvs_trigr.savextref.len = 0;
mv_st_ent->mv_st_cont.mvs_trigr.dollar_etrap_save.str.len = 0;
mv_st_ent->mv_st_cont.mvs_trigr.dollar_ztrap_save.str.len = 0;
mv_st_ent->mv_st_cont.mvs_trigr.saved_dollar_truth = dollar_truth;
op_gvsavtarg(&mv_st_ent->mv_st_cont.mvs_trigr.savtarg);
if (extnam_str.len)
{
ENSURE_STP_FREE_SPACE(extnam_str.len);
mv_st_ent->mv_st_cont.mvs_trigr.savextref.addr = (char *)stringpool.free;
memcpy(mv_st_ent->mv_st_cont.mvs_trigr.savextref.addr, extnam_str.addr, extnam_str.len);
stringpool.free += extnam_str.len;
assert(stringpool.free <= stringpool.top);
}
mv_st_ent->mv_st_cont.mvs_trigr.savextref.len = extnam_str.len;
mv_st_ent->mv_st_cont.mvs_trigr.ztname_save = dollar_ztname;
mv_st_ent->mv_st_cont.mvs_trigr.ztdata_save = dollar_ztdata;
mv_st_ent->mv_st_cont.mvs_trigr.ztoldval_save = dollar_ztoldval;
mv_st_ent->mv_st_cont.mvs_trigr.ztriggerop_save = dollar_ztriggerop;
mv_st_ent->mv_st_cont.mvs_trigr.ztupdate_save = dollar_ztupdate;
mv_st_ent->mv_st_cont.mvs_trigr.ztvalue_save = dollar_ztvalue;
mv_st_ent->mv_st_cont.mvs_trigr.ztvalue_changed_ptr = ztvalue_changed_ptr;
# ifdef DEBUG
/* In a debug process, these fields give clues of what trigger we are working on */
mv_st_ent->mv_st_cont.mvs_trigr.gtm_trigdsc_last_save = trigdsc;
mv_st_ent->mv_st_cont.mvs_trigr.gtm_trigprm_last_save = trigprm;
# endif
assert(((0 == gtm_trigger_depth) && (ch_at_trigger_init == ctxt->ch))
|| ((0 < gtm_trigger_depth) && (&mdb_condition_handler == ctxt->ch)));
mv_st_ent->mv_st_cont.mvs_trigr.ctxt_save = ctxt;
mv_st_ent->mv_st_cont.mvs_trigr.gtm_trigger_depth_save = gtm_trigger_depth;
if (0 == gtm_trigger_depth)
{ /* Only back up $*trap settings when initiating the first trigger level */
mv_st_ent->mv_st_cont.mvs_trigr.dollar_etrap_save = dollar_etrap;
mv_st_ent->mv_st_cont.mvs_trigr.dollar_ztrap_save = dollar_ztrap;
mv_st_ent->mv_st_cont.mvs_trigr.ztrap_explicit_null_save = ztrap_explicit_null;
dollar_ztrap.str.len = 0;
ztrap_explicit_null = FALSE;
if (NULL != gtm_trigger_etrap.str.addr)
/* An etrap was defined for the trigger environment - Else existing $etrap persists */
dollar_etrap = gtm_trigger_etrap;
}
mv_st_ent->mv_st_cont.mvs_trigr.mumps_status_save = mumps_status;
mv_st_ent->mv_st_cont.mvs_trigr.run_time_save = run_time;
/* See if a MERGE launched the trigger. If yes, save some state so ZWRITE, ZSHOW and/or MERGE can be
* run in the trigger we dispatch. */
if ((0 != merge_args) || TREF(in_zwrite))
PUSH_MVST_MRGZWRSV;
mumps_status = 0;
run_time = TRUE; /* Previous value saved just above restored when frame pops */
} else
{ /* Trigger base frame exists so reinitialize the symbol table for new trigger invocation */
REINIT_SYMVAL_BLK(curr_symval, curr_symval->last_tab);
/* Locate the MVST_TRIGR mv_stent containing the backed up values. Some of those values need
* to be restored so the 2nd trigger has the same environment as the previous trigger at this level
*/
for (mv_st_ent = mv_chain;
(NULL != mv_st_ent) && (MVST_TRIGR != mv_st_ent->mv_st_type);
mv_st_ent = (mv_stent *)(mv_st_ent->mv_st_next + (char *)mv_st_ent))
;
assert(NULL != mv_st_ent);
assert((char *)mv_st_ent < (char *)frame_pointer); /* Ensure mv_stent associated this trigger frame */
/* Reinit backed up values from the trigger environment backup */
dollar_truth = mv_st_ent->mv_st_cont.mvs_trigr.saved_dollar_truth;
op_gvrectarg(&mv_st_ent->mv_st_cont.mvs_trigr.savtarg);
extnam_str.len = mv_st_ent->mv_st_cont.mvs_trigr.savextref.len;
if (extnam_str.len)
memcpy(extnam_str.addr, mv_st_ent->mv_st_cont.mvs_trigr.savextref.addr, extnam_str.len);
mumps_status = 0;
assert(run_time);
/* Note we do not reset the handlers for parallel triggers - set one time only when enter first level
* trigger. After that, whatever happens in trigger world, stays in trigger world.
*/
}
assert(frame_pointer->type & SFT_TRIGR);
# ifdef DEBUG
gtm_trigdsc_last = trigdsc;
gtm_trigprm_last = trigprm;
# endif
/* Set new value of trigger ISVs. Previous values already saved in trigger base frame */
dollar_ztname = &trigdsc->rtn_desc.rt_name;
dollar_ztdata = (mval *)trigprm->ztdata_new;
dollar_ztoldval = trigprm->ztoldval_new;
dollar_ztriggerop = (mval *)trigprm->ztriggerop_new;
dollar_ztupdate = trigprm->ztupdate_new;
dollar_ztvalue = trigprm->ztvalue_new;
ztvalue_changed_ptr = &trigprm->ztvalue_changed;
/* Set values associated with trigger into symbol table */
lvvalarray = trigprm->lvvalarray;
for (i = 0, mne_p = trigdsc->lvnamearray, indx_p = trigdsc->lvindexarray;
i < trigdsc->numlvsubs; ++i, ++mne_p, ++indx_p)
{ /* Once thru for each subscript we are to set */
lvvalue = lvvalarray[*indx_p]; /* Locate mval that contains value */
assert(NULL != lvvalue);
assert(MV_DEFINED(lvvalue)); /* No sense in defining the undefined */
lvval = lv_getslot(curr_symval); /* Allocate an lvval to put into symbol table */
LVVAL_INIT(lvval, curr_symval);
lvval->v = *lvvalue; /* Copy mval into lvval */
added = add_hashtab_mname_symval(&curr_symval->h_symtab, mne_p, lvval, &tabent);
assert(added);
assert(NULL != tabent);
}
/* While the routine header is available in trigdsc, we also need the <null> label address associated with
* the first (and only) line of code.
*/
lbl_offset_p = LNRTAB_ADR(trigdsc->rtn_desc.rt_adr);
transfer_addr = (uchar_ptr_t)LINE_NUMBER_ADDR(trigdsc->rtn_desc.rt_adr, lbl_offset_p);
/* Create new stack frame for invoked trigger in same fashion as gtm_init_env() creates its 2ndary frame */
# ifdef HAS_LITERAL_SECT
new_stack_frame(trigdsc->rtn_desc.rt_adr, (unsigned char *)LINKAGE_ADR(trigdsc->rtn_desc.rt_adr), transfer_addr);
# else
/* Any platform that does not follow pv-based linkage model either
* (1) uses the following calculation to determine the context pointer value, or
* (2) doesn't need a context pointer
*/
new_stack_frame(trigdsc->rtn_desc.rt_adr, PTEXT_ADR(trigdsc->rtn_desc.rt_adr), transfer_addr);
# endif
dollar_tlevel_start = dollar_tlevel;
assert(gv_target->gd_csa == cs_addrs);
gv_target->trig_local_tn = local_tn; /* Record trigger being driven for this global */
/* Invoke trigger generated code */
rc = gtm_trigger_invoke();
if (1 == rc)
{ /* Normal return code (from dm_start). Check if TP has been unwound or not */
assert(dollar_tlevel <= dollar_tlevel_start); /* Bigger would be quite the surprise */
if (dollar_tlevel < dollar_tlevel_start)
{ /* Our TP level was unwound during the trigger so throw an error */
DBGTRIGR((stderr, "gtm_trigger: $TLEVEL less than at start - throwing TRIGTLVLCHNG\n"));
gtm_trigger_fini(TRUE, FALSE); /* dump this trigger level */
rts_error(VARLSTCNT(4) ERR_TRIGTLVLCHNG, 2, trigdsc->rtn_desc.rt_name.len,
trigdsc->rtn_desc.rt_name.addr);
}
rc = 0; /* Be polite and return 0 for the (hopefully common) success case */
} else if (ERR_TPRETRY == rc)
{ /* We are restarting the entire transaction. There are two possibilities here:
* 1) This is a nested trigger level in which case we need to unwind further or
* the outer trigger level was created by M code. If either is true, just
* rethrow the TPRETRY error.
* 2) This is the outer trigger and the call to op_tstart() was done by our caller.
* In this case, we just return to our caller with a code signifying they need
* to restart the implied transaction.
*/
assert(dollar_tlevel && (tstart_trigger_depth <= gtm_trigger_depth));
if ((tstart_trigger_depth < gtm_trigger_depth) || !tp_pointer->implicit_tstart || !tp_pointer->implicit_trigger)
{ /* Unwind a trigger level to restart level or to next trigger boundary */
gtm_trigger_fini(FALSE, FALSE); /* Get rid of this trigger level - we won't be returning */
DBGTRIGR((stderr, "gtm_trigger: dm_start returned rethrow code - rethrowing ERR_TPRETRY\n"));
INVOKE_RESTART;
} else
{ /* It is possible we are restarting a transaction that never got around to creating a base
* frame yet the implicit TStart was done. So if there is no trigger base frame, do not
* run gtm_trigger_fini() but instead do the one piece of cleanup it does that we still need.
*/
assert(donot_INVOKE_MUMTSTART);
if (SFT_TRIGR & frame_pointer->type)
{ /* Normal case when TP restart unwinding back to implicit beginning */
gtm_trigger_fini(FALSE, FALSE);
DBGTRIGR((stderr, "gtm_trigger: dm_start returned rethrow code - returning to gvcst_<caller>\n"));
} else
{ /* Unusual case of trigger that died in no-mans-land before trigger base frame established.
* Remove the "do not return to me" flag only on non-error unwinds */
assert(tp_pointer->implicit_tstart);
assert(SFF_TRIGR_CALLD & frame_pointer->flags);
frame_pointer->flags &= SFF_TRIGR_CALLD_OFF;
DBGTRIGR((stderr, "gtm_trigger: turning off SFF_TRIGR_CALLD (1) in frame 0x"lvaddr"\n",
frame_pointer));
DBGTRIGR((stderr, "gtm_trigger: unwinding no-base-frame trigger for TP restart\n"));
}
}
/* Fall out and return ERR_TPRETRY to caller */
} else if (0 == rc)
/* We should never get a return code of 0. This would be out-of-design and a signal that something
* is quite broken. We cannot "rethrow" outside the trigger because it was not initially an error so
* mdb_condition_handler would have no record of it (rethrown errors must have originally occurred in
* or to be RE-thrown) and assert fail at best.
*/
GTMASSERT;
else
{ /* We have an unexpected return code due to some error during execution of the trigger that tripped
* gtm_trigger's safety handler (i.e. an error occurred in mdb_condition_handler() established by
* dm_start(). Since we are going to unwind the trigger frame and rethrow the error, we also have
* to unwind all the stack frames on top of the trigger frame. Figure out how many frames that is,
* unwind them all plus the trigger base frame before rethrowing the error.
*/
for (unwinds = 0, fp = frame_pointer; (NULL != fp) && !(SFT_TRIGR & fp->type); fp = fp->old_frame_pointer)
unwinds++;
assert((NULL != fp) && (SFT_TRIGR & fp->type));
GOFRAMES(unwinds, TRUE, FALSE);
assert((NULL != frame_pointer) && !(SFT_TRIGR & frame_pointer->type));
DBGTRIGR((stderr, "gtm_trigger: Unsupported return code (%d) - unwound %d frames and now rethrowing error\n",
rc, unwinds));
rts_error(VARLSTCNT(1) ERR_REPEATERROR);
}
return rc;
}
rhdtyp *make_mode (int mode_index)
{
rhdtyp *base_address;
lab_tabent *lbl;
lnr_tabent *lnr;
CODEBUF_TYPE *code;
dyn_modes *dmode;
int algnd_rtnhdr_size = (int)ROUND_UP2(SIZEOF(rhdtyp), SECTION_ALIGN_BOUNDARY);
int algnd_code_size = (int)ROUND_UP2(CODE_SIZE, NATIVE_WSIZE);
int algnd_lbltab_size = (int)ROUND_UP2(SIZEOF(lab_tabent), NATIVE_WSIZE);
int algnd_lnrtab_size = (int)ROUND_UP2(CODE_LINES * SIZEOF(lnr_tabent), NATIVE_WSIZE);
assert((DM_MODE == mode_index) || (CI_MODE == mode_index));
base_address = (rhdtyp *)GTM_TEXT_ALLOC(algnd_rtnhdr_size + algnd_code_size + algnd_lbltab_size + algnd_lnrtab_size);
memset(base_address, 0, algnd_rtnhdr_size + algnd_code_size + algnd_lbltab_size + algnd_lnrtab_size);
dmode = &our_modes[mode_index];
base_address->routine_name.len = dmode->rtn_name_len;
base_address->routine_name.addr = dmode->rtn_name;
base_address->ptext_adr = (unsigned char *)base_address + algnd_rtnhdr_size;
base_address->ptext_end_adr = (unsigned char *)base_address->ptext_adr + algnd_code_size;
base_address->lnrtab_adr = (lnr_tabent *)base_address->ptext_end_adr;
base_address->labtab_adr = (lab_tabent *)((unsigned char *)base_address + algnd_rtnhdr_size +
algnd_code_size + algnd_lnrtab_size);
base_address->lnrtab_len = CODE_LINES;
base_address->labtab_len = 1;
code = (CODEBUF_TYPE *)base_address->ptext_adr; /* start of executable code */
#ifdef __ia64
if (dyn_modes_type[mode_index][0] == 'C')
{
GEN_CALL_C(CODE_ADDRESS(dmode->func_ptr1)) /* line 0,1 */
} else
{
GEN_CALL_ASM(CODE_ADDRESS(dmode->func_ptr1)) /* line 0,1 */
}
#else
GEN_CALL(dmode->func_ptr1); /* line 0,1 */
#endif /* __ia64 */
#ifdef _AIX
if (CI_MODE == mode_index)
{
/* Following 2 instructions are generated to call the routine stored in GTM_REG_ACCUM.
* ci_restart would have loaded this register with the address of op_extcall/op_extexfun.
* On other platforms, ci_start usually invokes op_ext* which will return directly
* to the generated code. Since RS6000 doesn't support call instruction without altering
* return address register (LR), the workaround is to call op_ext* not from ci_restart
* but from this dummy code
*/
*code++ = RS6000_INS_MTLR | GTM_REG_ACCUM << RS6000_SHIFT_RS;
*code++ = RS6000_INS_BRL;
}
#endif
#ifdef __ia64
if (dyn_modes_type[mode_index][1] == 'C')
{
GEN_CALL_C(CODE_ADDRESS(dmode->func_ptr2))
} else
{
GEN_CALL_ASM(CODE_ADDRESS(dmode->func_ptr2))
}
#else
GEN_CALL(dmode->func_ptr2);
#endif /* __ia64 */
#if defined (__ia64)
if (DM_MODE == mode_index)
{
GEN_UNCOD_JUMP(-(2 * 5)); /* branch to dm_setup which is at the top of the direct mode frame. */
}
#elif defined(__hpux)
if (DM_MODE == mode_index)
{
*code++ = HPPA_INS_BEQ | (MAKE_COND_BRANCH_TARGET(-8) << HPPA_SHIFT_OFFSET); /* BEQ r0,r0, -8 */
*code++ = HPPA_INS_NOP;
}
#endif /* __ia64 */
#ifdef __ia64
if (dyn_modes_type[mode_index][2] == 'C')
{
GEN_CALL_C(CODE_ADDRESS(dmode->func_ptr3)); /* line 2 */
} else
{
GEN_CALL_ASM(CODE_ADDRESS(dmode->func_ptr3)); /* line 2 */
}
#else
GEN_CALL(dmode->func_ptr3); /* line 2 */
#endif /* __ia64 */
lnr = LNRTAB_ADR(base_address);
*lnr++ = 0; /* line 0 */
*lnr++ = 0; /* line 1 */
IA64_ONLY(*lnr++ = 2 * CALL_SIZE + EXTRA_INST_SIZE;) /* line 2 */