unsigned char *get_symb_line (unsigned char *out, unsigned char **b_line, unsigned char **ctxt)
{
bool line_reset;
stack_frame *fp;
unsigned char *addr, *out_addr;
unsigned char *fpmpc, *fpctxt;
line_reset = FALSE;
for (fp = frame_pointer; fp; fp = fp->old_frame_pointer)
{
fpmpc = ((fp != error_frame) || (fp->mpc != dollar_ecode.error_rtn_addr))
? fp->mpc : dollar_ecode.error_frame_mpc;
fpctxt = ((fp != error_frame) || (fp->ctxt != dollar_ecode.error_rtn_ctxt))
? fp->ctxt : dollar_ecode.error_frame_ctxt;
if (ADDR_IN_CODE(fpmpc, fp->rvector))
{
if (ctxt != 0)
*ctxt = fpctxt;
if (line_reset)
addr = fpmpc + 1;
else
addr = fpmpc;
out_addr = symb_line (addr, out, b_line, fp->rvector);
assert (out < out_addr);
return out_addr;
} else
{
if (fp->type & SFT_ZTRAP || fp->type & SFT_DEV_ACT)
line_reset = TRUE;
}
}
GTMASSERT;
}
void zr_remove(rhdtyp *rtn)
{ /* remove all breaks in rtn */
zbrk_struct *zb_ptr;
for (zb_ptr = zbrk_recs.free - 1; NULL != zbrk_recs.beg && zb_ptr >= zbrk_recs.beg; zb_ptr--)
{ /* go in the reverse order to reduce memory movement in zr_put_free() */
if ((NULL == rtn) || (ADDR_IN_CODE(((unsigned char *)zb_ptr->mpc), rtn)))
zr_put_free(&zbrk_recs, zb_ptr);
}
return;
}
unsigned char *find_line_start(unsigned char *in_addr, rhdtyp *routine)
{
unsigned char *result;
lab_tabent *max_label, *label_table, *last_label;
lnr_tabent *line_table, *last_line;
int4 in_addr_offset;
result = (unsigned char *)0;
if (!ADDR_IN_CODE(in_addr, routine))
return result;
routine = CURRENT_RHEAD_ADR(routine);
USHBIN_ONLY(
assert(routine->labtab_adr);
assert(routine->lnrtab_adr);
);
unsigned char *get_symb_line(unsigned char *out, unsigned char **b_line, unsigned char **ctxt)
{
boolean_t line_reset;
stack_frame *fp;
unsigned char *addr, *out_addr;
unsigned char *fpmpc, *fpctxt;
line_reset = FALSE;
for (fp = frame_pointer; fp; fp = fp->old_frame_pointer)
{
# ifdef GTM_TRIGGER
if (NULL == fp->old_frame_pointer && (fp->type & SFT_TRIGR))
/* Have a trigger baseframe, pick up stack continuation frame_pointer stored by base_frame() */
fp = *(stack_frame **)(fp + 1);
# endif
fpmpc = fp->mpc;
fpctxt = fp->ctxt;
if (ADDR_IN_CODE(fpmpc, fp->rvector))
{
if (ctxt != 0)
*ctxt = fpctxt;
if (line_reset)
addr = fpmpc + 1;
else
addr = fpmpc;
out_addr = symb_line(addr, out, b_line, fp->rvector);
assert (out < out_addr);
return out_addr;
} else
{
if (fp->type & SFT_ZTRAP || fp->type & SFT_DEV_ACT)
line_reset = TRUE;
}
}
GTMASSERT;
return NULL;
}
void zshow_stack(zshow_out *output)
{
boolean_t line_reset;
unsigned char *addr;
unsigned short nocount_frames[MAX_INDR_PER_COUNTED], *nfp;
stack_frame *fp;
mstr v;
unsigned char buff[MAX_ENTRYREF_LEN + SIZEOF(INDR_OVERFLOW)];
v.addr = (char *)&buff[0];
flush_pio();
nfp = &nocount_frames[0];
line_reset = FALSE;
for (fp = frame_pointer; ; fp = fp->old_frame_pointer)
{
if (NULL == fp->old_frame_pointer)
{ /* This frame is a base frame - endpoint or jump it? */
# ifdef GTM_TRIGGER
if (fp->type & SFT_TRIGR)
/* Have a trigger baseframe, pick up stack continuation frame_pointer stored by base_frame() */
fp = *(stack_frame **)(fp + 1);
else
# endif
break; /* Endpoint.. */
}
if (!(fp->type & SFT_COUNT) || (fp->type & SFT_ZINTR))
{
if (nfp < &nocount_frames[MAX_INDR_PER_COUNTED])
/* If room in array, save indirect frame type */
*nfp++ = fp->type;
else
nocount_frames[MAX_INDR_PER_COUNTED - 1] = 0xffff; /* Indicate array overflow */
if (fp->type & SFT_ZTRAP || fp->type & SFT_DEV_ACT || HAS_TRANS_CODE_ERR(fp))
line_reset = TRUE;
} else
{
if (HAS_TRANS_CODE_ERR(fp))
{
*nfp++ = (fp->flags & SFF_ZTRAP_ERR) ? SFT_ZTRAP : SFT_DEV_ACT;
line_reset = TRUE;
}
if (line_reset && ADDR_IN_CODE(fp->mpc, fp->rvector))
{
addr = fp->mpc + 1;
line_reset = FALSE;
} else
addr = fp->mpc;
v.len = INTCAST(symb_line(addr, &buff[0], 0, fp->rvector) - &buff[0]);
if (v.len == 0)
{
MEMCPY_LIT(&buff[0], UNK_LOC_MESS);
v.len = SIZEOF(UNK_LOC_MESS) - 1;
}
if (nfp != &nocount_frames[0])
{
for (--nfp; nfp >= &nocount_frames[0]; nfp--)
{
switch(*nfp)
{
case SFT_ZBRK_ACT:
MEMCPY_LIT(&buff[v.len], ZBRK_FRAME);
v.len += SIZEOF(ZBRK_FRAME) - 1;
break;
case SFT_DEV_ACT:
MEMCPY_LIT(&buff[v.len], DEVERR_FRAME);
v.len += SIZEOF(DEVERR_FRAME) - 1;
break;
case SFT_ZTRAP:
MEMCPY_LIT(&buff[v.len], ZTRAP_FRAME);
v.len += SIZEOF(ZTRAP_FRAME) - 1;
break;
case SFT_DM:
MEMCPY_LIT(&buff[v.len], DIR_MODE_MESS);
v.len += SIZEOF(DIR_MODE_MESS) - 1;
break;
case (SFT_COUNT | SFT_ZINTR):
MEMCPY_LIT(&buff[v.len], ZINTR_FRAME);
v.len += SIZEOF(DIR_MODE_MESS) - 1;
break;
case 0xffff:
MEMCPY_LIT(&buff[v.len], INDR_OVERFLOW);
v.len += SIZEOF(INDR_OVERFLOW) - 1;
break;
default:
break;
}
output->flush = TRUE;
zshow_output(output, &v);
v.len = 0;
}
nfp = &nocount_frames[0];
} else
{
output->flush = TRUE;
zshow_output(output, &v);
}
}
}
return;
}
void get_frame_place_mcode(int level, stack_mode_t mode, int cur_zlevel, mval *result)
{
int count;
stack_frame *fp;
unsigned char pos_str[MAX_ENTRYREF_LEN];
mval label;
mval routine;
int ips;
int offset;
int s1, s2;
boolean_t indirect_frame;
ihdtyp *irtnhdr;
cache_entry *indce;
INTPTR_T *vp;
unsigned char *fpmpc;
assert(DOLLAR_STACK_PLACE == mode || DOLLAR_STACK_MCODE == mode);
assert(0 <= level);
assert(level < cur_zlevel);
count = cur_zlevel;
for (fp = frame_pointer; ; fp = fp->old_frame_pointer)
{
if (NULL == fp->old_frame_pointer)
{
if (fp->type & SFT_TRIGR)
/* Have a trigger baseframe, pick up stack continuation frame_pointer stored by base_frame() */
fp = *(stack_frame **)(fp + 1);
else
{ /* Something wrong, just return null or assert if debug mode */
assert(FALSE);
result->str.len = 0;
return;
}
}
assert(NULL != fp);
if (!(fp->type & SFT_COUNT))
continue;
count--;
if (count == level)
break;
}
fpmpc = fp->mpc;
if (ADDR_IN_CODE(fpmpc, fp->rvector))
{
result->str.addr = (char *)&pos_str[0];
result->str.len = INTCAST(symb_line(fpmpc, &pos_str[0], 0, fp->rvector) - &pos_str[0]);
indirect_frame = FALSE;
} else
{
indirect_frame = TRUE;
pos_str[0] = '@';
result->str.addr = (char *)&pos_str[0];
result->str.len = 1;
}
if (DOLLAR_STACK_PLACE == mode)
{
if (result->str.len)
{
s2pool(&result->str);
assert(((unsigned char *)result->str.addr + result->str.len) == stringpool.free);
}
}
if (DOLLAR_STACK_MCODE == mode)
{
if (!indirect_frame)
{
if (IS_GTM_IMAGE || (0 < level))
{
label.mvtype = MV_STR;
routine.mvtype = MV_STR;
result->mvtype = MV_STR;
label.str.len = result->str.len;
label.str.addr = (char *)&pos_str[0];
routine.str.len = 0;
for (ips = 0, s1 = s2 = -1; ips < result->str.len; ips++)
{
if ('+' == pos_str[ips])
{
assert((-1 == s1) && (-1 == s2));
s1 = ips;
}
if ('^' == pos_str[ips])
{
s2 = ips;
break;
}
}
if (s2 >= 0)
{
routine.str.addr = (char *)&pos_str[s2 + 1];
routine.str.len = result->str.len - s2 - 1;
label.str.len = s2;
}
offset = 0;
if (s1 >= 0)
{
label.str.len = s1;
if (s2 < 0)
s2 = result->str.len;
for (ips = s1 + 1; ips < s2; ips++)
offset = offset * 10 + pos_str[ips] - '0';
}
op_fntext(&label, offset, &routine, result);
} else
{ /* Utility base frame does not have source code */
result->str.addr = UTIL_BASE_FRAME_CODE;
result->str.len = STRLEN(UTIL_BASE_FRAME_CODE);
}
} else
{ /* code picked up from cache_cleanup(). any changes here might need to be reflected there */
vp = (INTPTR_T *)fp->ctxt;
assert(NULL != vp);
vp--;
if ((GTM_OMAGIC << 16) + OBJ_LABEL != *vp) /* Validate backward linkage */
GTMASSERT;
vp--;
irtnhdr = (ihdtyp *)((char *)vp + *vp);
indce = irtnhdr->indce;
assert(NULL != indce);
assert(0 < indce->refcnt); /* currently used in the M stack better have a non-zero refcnt */
result->str = indce->src.str;
s2pool(&result->str);
assert(((unsigned char *)result->str.addr + result->str.len) == stringpool.free);
}
}
return;
}
