inline void delete_node(void** seg, void** tail, void *bp)
{
#ifdef __DEBUG__
printf("Delete node / *seg : %u, tail : %u, bp : %u\n", *seg, *tail, bp);
#endif
if(isHead(bp) && isTail(bp)) //make list empty
{
*seg = NULL;
*tail = NULL;
return;
}
else if(isHead(bp)) //move head
{
*seg = getNextNode(*seg);
setPrevNode(*seg, *seg);
return;
}
else if(isTail(bp)) //move tail
{
*tail = getPrevNode(bp);
setNextNode(*tail, *tail);
return;
}
void *prev_bp, *next_bp; //link change
prev_bp = getPrevNode(bp);
next_bp = getNextNode(bp);
setNextNode(prev_bp, next_bp);
setPrevNode(next_bp, prev_bp);
}
bool ArrayList::toNext() {
if (isTail()) {
return false;
}
current++;
return !isTail();
}
static int GetTypeOf(ea_t ea)
{
flags_t flags = getFlags(ea);
if (isTail(flags)) {
// check if it's a struct ptr
ea_t head = get_item_head(ea);
if (head == ea) return T_UNK;
flags = getFlags(head);
if (!isData(flags) || !isStruct(flags)) return T_UNK;
return GetTypeOfStructInstance(ea, head, flags);
}
if (!isData(flags)) return T_UNK;
if (isStruct(flags)) return GetTypeOfStructInstance(ea, ea, flags);
if (isByte(flags)) {
char s;
if (has_cmt(flags) && (get_cmt(ea, false, &s, 1) != -1) && s == 'S') return T_I8;
return T_U8;
}
if (isWord(flags)) {
char s;
if (has_cmt(flags) && (get_cmt(ea, false, &s, 1) != -1) && s == 'S') return T_I16;
return T_U16;
}
if (isDwrd(flags)) return T_I32;
return T_UNK;
}
static void* find_fit(size_t size) //find best place
{
#ifdef __DEBUG__
fprintf(stderr, "find fitting place - size : %d\n", size);
#endif
void* bp;
void* s;
size_t sizeIndex = size;
for(s = getSegBySize(size); ; s = getSegBySize(sizeIndex)) //increase seg size
{
sizeIndex = getNextSize(sizeIndex);
for(bp = s; ; bp = getNextNode(bp)) //iterate list
{
if(bp==NULL) break;
#ifdef __DEBUG__
fprintf(stderr, "searching : %u / allocated? : %u / size? : %u\n", getBlockHeader(bp), isAllocated(getBlockHeader(bp)), getSize(getBlockHeader(bp)));
#endif
if(!isAllocated(getBlockHeader(bp)) && size <= getSize(getBlockHeader(bp)))
{
return bp;
}
if(isTail(bp)) break;
}
if(s==seg_inf) break;
}
return NULL;
}
void setView(struct imageInfo *image, char *flakyClone, char *flakyStage,
char *flakyView)
/* Set image->view from view name if it looks good. */
{
if (startsWith("2_", flakyView))
flakyView += 2;
if (isAllish(flakyView))
image->view = "mixed";
else if (isAnimal(flakyView))
image->view = "animal";
else if (isAnterior(flakyView))
image->view = "anterior";
else if (isBody(flakyView))
image->view = "whole";
else if (isDorsal(flakyView))
image->view = "dorsal";
else if (isTail(flakyView))
image->view = "tail";
else if (isLateral(flakyView))
image->view = "lateral";
else if (isPosterior(flakyView))
image->view = "posterior";
else if (isSection(flakyView))
image->view = "section";
else if (isVentral(flakyView))
image->view = "ventral";
else if (isVegetal(flakyView))
image->view = "vegetal";
else if (isHead(flakyView))
image->view = "head";
}
Entity * ArrayList::extractCurrentEntity_impl() {
if (isTail()) return NULL;
Entity * entity = array[current];
closeGap();
return entity;
}
bool LinkedList::deleteCurrent_impl() {
if (isTail()) return false;
Node *doomedNode = current;
current = doomedNode->next;
delete doomedNode;
return true;
}
bool ArrayList::deleteCurrent_impl() {
if (isTail()) return false;
Entity * entity = array[current];
closeGap();
delete entity;
return true;
}
Entity * LinkedList::extractCurrentEntity_impl() {
if (isTail()) return NULL;
Node *doomedNode = current;
current = doomedNode->next;
Entity * entity = doomedNode->extractEntity();
delete doomedNode;
return entity;
}
// check and create a flat 32 bit jump table -- the most common case
static void check_and_create_flat32(
jump_table_type_t /*jtt*/,
switch_info_ex_t &si)
{
// check the table contents
ea_t table = si.jumps;
segment_t *s = getseg(table);
if ( s == NULL )
return;
size_t maxsize = size_t(s->endEA - table);
int size = si.ncases;
if ( size > maxsize )
size = (int)maxsize;
int i;
insn_t saved = cmd;
for ( i=0; i < size; i++ )
{
ea_t ea = table + 4*i;
flags_t F = getFlags(ea);
if ( !hasValue(F) )
break;
if ( i && (has_any_name(F) || hasRef(F)) )
break;
ea_t target = segm_adjust_ea(getseg(table), si.elbase + get_long(ea));
if ( !isLoaded(target) )
break;
flags_t F2 = get_flags_novalue(target);
if ( isTail(F2) || isData(F2) )
break;
if ( !isCode(F2) && !decode_insn(target) )
break;
}
cmd = saved;
size = i;
// create the table
for ( i=0; i < size; i++ )
{
ea_t ea = table + 4*i;
doDwrd(ea, 4);
op_offset(ea, 0, REF_OFF32, BADADDR, si.elbase);
ea_t target = si.elbase + segm_adjust_diff(getseg(table), get_long(ea));
ua_add_cref(0, target, fl_JN);
}
si.flags |= SWI_J32;
if ( si.defjump != BADADDR )
si.flags |= SWI_DEFAULT;
si.ncases = (uint16)size;
si.startea = cmd.ea;
set_switch_info_ex(cmd.ea, &si);
}
//----------------------------------------------------------------------
static void destroy_if_unnamed_array(ea_t ea)
{
flags_t F = get_flags_novalue(ea);
if ( isTail(F) && segtype(ea) == SEG_IMEM )
{
ea_t head = prev_not_tail(ea);
if ( !has_user_name(get_flags_novalue(head)) )
{
do_unknown(head, DOUNK_SIMPLE);
doByte(head, ea-head);
ea_t end = nextthat(ea, inf.maxEA, f_isHead, NULL);
if ( end == BADADDR ) end = getseg(ea)->endEA;
doByte(ea+1, end-ea-1);
}
}
}
void ArrayList::closeGap(int index) {
if (isTail()) {
return;
}
if (current > index) {
current--;
}
const int lastElementIndex = getCount() - 1;
for (int i = index; i < lastElementIndex; i++) {
array[i] = array[i + 1];
}
array[lastElementIndex] = NULL;
}
int
process_switchB(ea_t curr, ea_t start, ea_t func_end)
{
ea_t diff = start - curr,
min = func_end,
ptr;
unsigned long i;
if ( diff && diff < 4 )
{
do_unknown_range(curr, diff, true);
}
#ifdef PIC_DEBUG
RP_TRACE2("start %X, to %X\n", start, func_end);
#endif
ptr = get_next_code(start);
if ( NULL == ptr )
do_unknown(start,false);
else
{
if ( isTail(getFlags(start)) )
{
do_unknown(prev_not_tail(start),false);
}
else
do_unknown_range(start, ptr-start, true);
}
for ( i = 0; start+i < min; i += 4 )
{
ptr = got_addr - get_long(start + i);
#ifdef PIC_DEBUG
RP_TRACE3("min is %X, ptr %X, i %d\n", min, ptr, i);
#endif
if ( ptr < func_end )
{
if ( ptr < min )
min = ptr;
#ifdef PIC_DEBUG
RP_TRACE2("one_switch_entry %X, ptr %X\n", start+i, ptr );
#endif
one_switch_entry(start+i, ptr);
} else
break; /* end ? */
}
return (i>>2);
}
void
process_switchA(ea_t curr, ea_t start, unsigned int N)
{
ea_t diff = start - curr;
unsigned long i;
if ( diff && diff < 4 )
{
do_unknown_range(curr, diff, true);
}
if ( isTail(getFlags(start)) )
do_unknown(prev_not_tail(start),false);
else
do_unknown_range(start, N << 2, true);
for ( i = 0; i <= N; i++ )
{
diff = start + (i<<2);
one_switch_entry(diff, got_addr - get_long(diff));
}
}
void Lanes::afterFork() {
for (unsigned int i = 0; i < typeVec.size(); ++i) {
int& t = typeVec[i];
if (t == CROSS)
t = NOT_ACTIVE;
else if (isTail(t) || t == CROSS_EMPTY)
t = EMPTY;
if (!boundary && IS_NODE(t))
t = ACTIVE; // boundary will be reset by changeActiveLane()
}
while (typeVec.back() == EMPTY) {
typeVec.pop_back();
nextShaVec.pop_back();
}
}
//---------------------------------------------------------------------------
// Validate table attributes
static bool check_table(ea_t table, uval_t elsize, uval_t tsize)
{
flags_t F;
if ( getseg(table) == NULL || isCode((F=get_flags_novalue(table))) || isTail(F) )
{
warning("AUTOHIDE NONE\nIncorrect table address %a", table);
return false;
}
if ( elsize != 1 && elsize != 2 && elsize != 4 && elsize != 8 )
{
warning("AUTOHIDE NONE\nIncorrect table element size %d", elsize);
return false;
}
flags_t DF = get_flags_by_size((size_t)elsize);
if ( !can_define_item(table, elsize*tsize, DF) )
{
warning("AUTOHIDE NONE\nCan not create table at %a size %d", table, tsize);
return false;
}
return true;
}
ostream & ArrayList::renderState(ostream& os) const {
this->List::renderState(os);
os << " capacity(" << capacity << ")";
if (isTail()) {
os << " TAIL<--CURSOR";
}
os << " contents{";
int first = BASE_INDEX;
for (int i = first; i < getCount(); i++) {
if (i > first) {
os << ", ";
}
os << std::endl << " [" << i << ']' << array[i];
if (i == current) {
os << " <--CURSOR";
}
}
return os << "}";
}
ostream & LinkedList::renderState(ostream& os) const {
this->List::renderState(os);
if (isTail()) {
os << " TAIL<--CURSOR";
}
os << " contents{";
const struct LinkedList::Node* node = head->next;
for (int i = 0; node != tail; i++) {
if (i > 0) {
os << ", ";
}
const Entity* entity = node->entity;
os << std::endl << " [" << i << ']' << entity;
if (node == current) {
os << " <--CURSOR";
}
node = node->next;
}
return os << "}";
}
void ShadowChicken::Packet::dump(PrintStream& out) const
{
if (!*this) {
out.print("empty");
return;
}
if (isPrologue()) {
out.print(
"{callee = ", RawPointer(callee), ", frame = ", RawPointer(frame), ", callerFrame = ",
RawPointer(callerFrame), "}");
return;
}
if (isTail()) {
out.print("tail:{frame = ", RawPointer(frame), "}");
return;
}
ASSERT(isThrow());
out.print("throw");
}
//--------------------------------------------------------------------------
// find all dwords equal to 'ea' and remember their translations
// search in the current module
static bool calc_thunk_target(uint32 ea32, uint32 imp32)
{
bool matched = false;
for ( ea_t pos = curmod.startEA;
pos <= curmod.endEA
&& (pos = bin_search(pos, curmod.endEA, (uchar *)&ea32, NULL,
4, BIN_SEARCH_FORWARD,
BIN_SEARCH_NOBREAK|BIN_SEARCH_CASE)) != BADADDR;
pos += sizeof(DWORD) )
{
if ( pos & 3 )
continue;
flags_t F = getFlags(pos);
if( isTail(F) )
continue;
matched = true;
thunks[pos] = imp32;
}
return matched;
}
bool isIsolated() const {
return isHead() && isTail();
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isload)
{
ea_t ea;
switch ( x.type )
{
case o_phrase: // 2 registers or indirect addressing
if ( cmd.itype != TMS_mar && cmd.itype != TMS2_mar
&& find_ar(&ea) ) goto set_dref;
case o_reg:
case o_bit:
case o_cond:
break;
case o_imm:
if ( ! isload ) goto badTouch;
doImmdValue();
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, is_mpy() ? OOF_SIGNED : 0);
break;
case o_mem:
ea = toEA(dataSeg_op(x.n),x.addr);
set_dref:
ua_dodata2(x.offb, ea, x.dtyp);
if ( ! isload )
doVar(ea);
ua_add_dref(x.offb,ea,isload ? dr_R : dr_W);
if ( x.type == o_mem )
if ( cmd.itype == TMS_dmov ||
cmd.itype == TMS_ltd ||
cmd.itype == TMS_macd ||
cmd.itype == TMS_madd ||
cmd.itype == TMS2_dmov ||
cmd.itype == TMS2_macd ) ua_add_dref(x.offb,ea+1,dr_W);
break;
case o_near:
{
ea_t segbase = codeSeg(x.addr, x.n);
ea = toEA(segbase, x.addr);
if ( cmd.itype == TMS_blpd ||
cmd.itype == TMS_mac ||
cmd.itype == TMS_macd ||
cmd.itype == TMS2_blkp ||
cmd.itype == TMS2_mac ||
cmd.itype == TMS2_macd
) goto set_dref;
uval_t thisseg = cmd.cs;
int iscall = InstrIsSet(cmd.itype,CF_CALL);
if ( cmd.itype == TMS_rptb && isTail(get_flags_novalue(ea)) )
{
// small hack to display end_loop-1 instead of before_end_loop+1
ea++;
}
ua_add_cref(x.offb,
ea,
iscall ? ((segbase == thisseg) ? fl_CN : fl_CF)
: ((segbase == thisseg) ? fl_JN : fl_JF));
if ( iscall )
{
if ( !func_does_return(ea) )
flow = false;
}
}
break;
default:
badTouch:
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
static bool check_for_table_jump(void)
{
ea_t base = BADADDR, table = BADADDR, defea = BADADDR;
int size = 0, elsize = 0;
int i;
bool ok = false;
insn_t saved = cmd;
for ( i=0; !ok && i < qnumber(patterns); i++ )
{
ok = patterns[i](&base, &table, &defea, &size, &elsize);
cmd = saved;
}
if ( !ok ) return false;
if ( table != BADADDR ) table = toEA(cmd.cs, table);
if ( base != BADADDR ) base = toEA(cmd.cs, base);
if ( defea != BADADDR ) defea = toEA(cmd.cs, defea);
// check the table contents
int oldsize = size;
segment_t *s = getseg(table);
if ( s == NULL ) return false;
int maxsize = int(s->endEA - table);
if ( size > maxsize ) size = maxsize;
for ( i=0; i < size; i++ )
{
ea_t ea = table+i*elsize;
flags_t F = getFlags(ea);
if ( !hasValue(F)
|| (i && (has_any_name(F) || hasRef(F))) ) break;
int el = elsize == 1 ? get_byte(ea) : get_word(ea);
flags_t F2 = get_flags_novalue(base+el);
if ( isTail(F2)
|| isData(F2)
|| (!isCode(F2) && !decode_insn(base+el)) ) break;
}
cmd = saved;
size = i;
if ( size != oldsize )
msg("Warning: jpt_%04a calculated size of %d forced to %d!\n",
cmd.ip, oldsize, size);
// create the table
if ( size == 0 ) return false;
for ( i=0; i < size; i++ )
{
ea_t ea = table + i*elsize;
(elsize == 1 ? doByte : doWord)(ea, elsize);
op_offset(ea, 0, elsize == 1 ? REF_OFF8 : REF_OFF16, BADADDR, base);
ua_add_cref(0, base + (elsize==1?get_byte(ea):get_word(ea)), fl_JN);
}
char buf[MAXSTR];
qsnprintf(buf, sizeof(buf), "def_%a", cmd.ip);
// set_name(defea, buf, SN_NOWARN|SN_LOCAL); // temporary kernel bug workaround
set_name(defea, buf, SN_NOWARN);
qsnprintf(buf, sizeof(buf), "jpt_%a", cmd.ip);
set_name(table, buf, SN_NOWARN);
return true;
}
Entity * ArrayList::currentEntity() {
if (isTail()) return (NULL);
return (array[current]);
}
Entity * LinkedList::currentEntity() {
if (isTail()) return (NULL);
return (current->entity);
}
//operator==
bool Piano::operator== (const Instruments& i) const {
Instruments& instr = const_cast<Instruments&>(i);
Piano* p = dynamic_cast<Piano*>(&instr);
return (Instruments::operator==(i) && isTail()==p->isTail() && getWood()==p->getWood());
}
