cfuncprt.cpp

将exe等可执行文件转化成c程序的反编译程序,先到汇编再到c

		case JMP_jz:	str = " == ";	break;
		case JMP_jnz:	str = " != ";	break;

		case JMP_jna:	str = " <= ";	break;	//unsigned
		case JMP_jnb:	str = " >= ";	break;	//unsigned
		case JMP_ja:	str = " > ";	break;	//unsigned
		case JMP_jb:	str = " < ";	break;	//unsigned

		case JMP_jng:	str = " <= ";	break;	//signed
		case JMP_jnl:	str = " >= ";	break;	//signed
		case JMP_jg:	str = " > ";	break;	//signed
		case JMP_jl:	str = " < ";	break;	//signed
		}
		out->prtt(str);
        this->prt_va(pjxx->va_r2, out);
	}
	else
		out->prtt(" ?? >< ?? ");
}

void	CFunc_Prt::prt_compare(PINSTR phead, CXmlOutPro* out)
// 打印while()括号中的东西。
//	特点：不换行，最后不分号
{
	// 暂时先这样
	prt_one_statement(phead, out);
}


void	CFunc_Prt::prt_one_statement_mainbody(PINSTR phead, CXmlOutPro* out)
{	//	不包括{和},用于case
	if (phead == NULL)
    	return;
	INSTR_LIST* list = this->m_instr_list;
	POSITION pos = list->Find(phead);
	
	PINSTR begin = list->GetNext(pos);
	if (begin->type != i_Begin)
	{
		alert_prtf("func %x, type = %s != i_Begin",this->m_head_off,hlcode_name(begin->type));
		out->prtl("error statement");
		return;
	}
	assert(begin->type == i_Begin);
	
	POSITION endpos = list->Find(begin->begin.m_end);

	while ( pos != endpos)
	{
		assert(pos != NULL);
		PINSTR p = list->GetNext(pos);
		prt_instr(p,pos,out);
	}
}

CString	CFunc_Prt::prt_the_instr(PINSTR p)
{
    CXmlPrt theprt;

    CXmlOutPro out(&theprt);
    out.m_f_prt_in_1line = true;
    out.m_f_prt_in_comma = true;

    prt_the_instr_1(p, &out);

    CString retn = theprt.GetString();

    return retn;
}
void	CFunc_Prt::prt_the_instr_1(PINSTR p, CXmlOutPro* out)
{
    switch (p->type)
    {
	case i_Cmp:
		out->prtt("cmp ");
        this->prt_va(p->va_r1, out);
		out->prtt(" , ");
        this->prt_va(p->va_r2, out);
		break;

	case i_Unknown:
        out->prtt("unknown");
		break;
	case i_Return:	
        out->XMLbegin(XT_Keyword, NULL);
        out->prtt("return");
        out->XMLend(XT_Keyword);
		break;
    case i_Imul:	prt_add(p, "*" , out); return; 
    case i_Add:	prt_add(p, "+" , out); return; 
	case i_Sub:	prt_sub(p, "-" , out); return; 
	case i_And:	prt_add(p, "&" , out); return;
	case i_Sar:	prt_sub(p, ">>", out); return; 
	case i_Shl:	prt_sub(p, "<<", out); return; 
    case i_Shr:	prt_sub(p, ">>", out); return; 
	case i_Xor:	
		if (VAR::IsSame(&p->var_r1, &p->var_r2))
		{
            this->prt_var(&p->var_w, out);
            out->prtt(" = 0");	// xor eax,eax means eax = 0
            return;
		}
		prt_add(p,"^",out);
        return;
	case i_SignExpand:
	case i_NosignExpand:
    case i_Assign:
        {
            if (!IfTemVar(&p->var_w))
            {
                out->XMLbegin(XT_Symbol, p->var_w.thevar);
                out->prtt(BareVarName(&p->var_w));
                out->XMLend(XT_Symbol);
                out->prtt("= ");
            }
            this->prt_va(p->va_r1, out);
            
            return;
        }
    case i_Readpointto:
        {
            if (!IfTemVar(&p->var_w))
            {
                out->XMLbegin(XT_Symbol, p->var_w.thevar);
                out->prtt(BareVarName(&p->var_w));
                out->XMLend(XT_Symbol);
                out->prtt("= ");
            }
            out->prtt("*");
            this->prt_va(p->va_r1, out);
            
            return;
        }
    case i_Address:
        {
            if (!IfTemVar(&p->var_w))
            {
                this->prt_var(&p->var_w, out);
                out->prtt(" = ");
                this->prt_iAddress_out(p, out);
            }
            else
            {
                out->prtt("(");
                this->prt_iAddress_out(p, out);
                out->prtt(")");
            }
            
            return;
        }
	case i_GetAddr:
        {
            if (!IfTemVar(&p->var_w))
            {
                out->XMLbegin(XT_Symbol, p->var_w.thevar);
                out->prtt(BareVarName(&p->var_w));
                out->XMLend(XT_Symbol);
                out->prtt("= ");
            }
            out->prtt("&");
            this->prt_va(p->va_r1, out);
            return;
        }
    case i_Writepointto:
        this->out_PointTo(p->va_r1.pao, &p->var_r1, out);
		//out->prtt("*");
        //this->prt_va(p->va_r1);
		out->prtt(" = ");
        this->prt_va(p->va_r2, out);
		break;
    case i_EspReport:   //nothing
        break;
    default:
        {
            out->prtf("--XX-- %x", p->type);
            return;
        }
    }
}
void	CFunc_Prt::prt_sub(PINSTR p, PCSTR s, CXmlOutPro* out)
{
    if (IfTemVar(&p->var_w))
    {
        out->prtt("(");
        this->prt_va(p->va_r1, out);
        out->prtspace();
        out->prtt(s);
        out->prtspace();
        this->prt_va(p->va_r2, out);
        out->prtt(")");
        return;
    }
    this->prt_var(&p->var_w, out);

	if (VAR::IsSame(&p->var_w, &p->var_r1))
	{
        out->prtspace();
        out->prtt(s);
        out->prtt("= ");
        this->prt_va(p->va_r2, out);
	}
	else
	{
        out->prtt(" = ");
        this->prt_va(p->va_r1, out);
        out->prtt(s);
        this->prt_va(p->va_r2, out);
	}
}
PCSTR CallConvToName(enum_CallC ec);
void	CFunc_Prt::prt_func_head(CXmlOutPro* out)
{
    CFuncType* pfctype = this->Q->m_functype;
    if (pfctype != NULL)
    {
        if (pfctype->m_class != NULL && pfctype->m_class->is_GouZX(pfctype))
        {
            //构造与析构函数是不需要写返回值的
        }
        else
        {
            VarTypeID id = pfctype->m_retdatatype_id;
            out->XMLbegin(XT_DataType, (PVOID)id);
            out->prtt(GG_VarType_ID2Name(id));
            out->XMLend(XT_DataType);

            enum_CallC em = pfctype->m_callc;
            out->XMLbegin(XT_Keyword, NULL);
            out->prtt(CallConvToName(em));
            out->XMLend(XT_Keyword);
        }
    }
    else
    {
        out->XMLbegin(XT_DataType, NULL);
        out->prtt("DWORD");
        out->XMLend(XT_DataType);
    }
    
    if (pfctype != NULL && pfctype->m_class != NULL)
    {
        out->XMLbegin(XT_DataType, pfctype->m_class);
        out->prtt(pfctype->m_class->getname());
        out->XMLend(XT_DataType);
        out->prtt("::");
    }
    out->XMLbegin(XT_FuncName, this->Q);
    out->prtt(this->m_funcname);
    out->XMLend(XT_FuncName);

    out->prtt("(");
	this->m_exprs->prt_parameters(out);
	out->prtl(")");
}


void	CFunc_Prt::prtout_cpp(CXmlOutPro* out)
{
	INSTR_LIST* list = this->m_instr_list;
	if (list == NULL || list->IsEmpty())
    {//还没为E2C作好准备
        CFuncLL the(this->ll.m_asmlist);
        the.prtout_asm(this->Q, &this->m_varll, out);
        
        return;
    }

    out->XMLbegin(XT_Function, this->Q);

	this->prt_func_head(out);
	
	PINSTR phead = list->GetHead();

	this->m_flag_prt_var_delare = true;
	prt_one_statement(phead, out);
    out->XMLend(XT_Function);
}


void	CFunc_Prt::prt_iAddress_out(PINSTR p, CXmlOutPro* out)
{
    int n=0;
    if (p->var_r1.type)
	{
        this->prt_va(p->va_r1, out);
        n++;
	}
	if (p->var_r2.type)
	{
		if (n)
			out->prtt(" + ");
        this->prt_va(p->va_r2, out);
		if (p->i1 != 1)
			out->prtf(" * %d", p->i1);
	}
	if (p->i2)
	{
		if (n)
			out->prtspace();
        int addoff = (int)p->i2;
        if (addoff < 0)
        {
			out->prtt("-");
            out->prtt(prt_DWORD(-addoff));
        }
        else
        {
			out->prtt("+");
            out->prtt(prt_DWORD(p->i2));
        }
	}
}
PCSTR CFunc_Prt::prt_iAddress(PINSTR p)
{
	static char s[80];
	int n=0;
	s[0] = '\0';
	if (p->var_r1.type)
	{
		n += sprintf(s,"%s",VarName(&p->var_r1));
	}
	if (p->var_r2.type)
	{
		if (n)
			n += sprintf(s+n," + ");
		n += sprintf(s+n,"%s",VarName(&p->var_r2));
		if (p->i1 != 1)
			n += sprintf(s+n, " * %d", p->i1);
	}
	if (p->i2)
	{
		if (n)
			n += sprintf(s+n," + ");
		n += sprintf(s+n, "%s", prt_DWORD(p->i2));
		n;
	}
	return s;
}

void CFunc_Prt::prt_instr_callthis(POSITION nextpos, CXmlOutPro* out)
{
    POSITION pos = nextpos;
    for (;;)
    {
        PINSTR p1 = this->m_instr_list->GetNext(pos);
        if (p1->type == i_CallPara)
            continue;
        if (p1->type == i_CallRet)
            continue;
        if (p1->type == i_CallThis)
        {
            if (p1->va_r1.pao == 0)
            {
                this->prt_var(&p1->var_r1, out);
                out->prtt("->");
            }
            else if (p1->va_r1.pao->type == IA_GetAddress)
            {
                this->prt_var(&p1->var_r1, out);
                out->prtt(".");
            }
            else
            {
                assert(0);
            }
        }
        break;
    }
}
bool CFunc_Prt::prt_instr_callret(POSITION nextpos, CXmlOutPro* out)
{
    POSITION pos = nextpos;
    for (;;)
    {
        PINSTR p1 = this->m_instr_list->GetNext(pos);
        if (p1->type == i_CallThis)
            continue;
        if (p1->type == i_CallPara)
            continue;
        if (p1->type == i_CallRet)
        {
            if (p1->var_w.thevar != NULL && p1->var_w.thevar->type == MTT_tem)
                return true;
            
            out->ident();
            this->prt_var(&p1->var_w, out);

            out->prtt(" = ");
            return false;
        }
        break;
    }
    out->ident();
    return false;
}
void CFunc_Prt::prt_para_1(M_t* thevar, CXmlOutPro* out)
{
    //this is for __stdcall and __cdecl
    int n = 0;
    POSITION pos = this->m_instr_list->GetTailPosition();
    while (pos)
    {
        PINSTR p = this->m_instr_list->GetPrev(pos);
        if (p->var_w.thevar == thevar)
        {
            if (n != 0)
            {
                out->nospace();
                out->prtt(",");
            }
            
			if (p->type == i_GetAddr)
				out->prtt("&");
            this->prt_va(p->va_r1, out);
            n++;
        }
    }
    //这函数有点问题,次序简单处理了,还有。。
}
void CFunc_Prt::prt_parameter(PINSTR ppara, CXmlOutPro* out)
{
    if (ppara->va_r1.pao != NULL
        || ppara->var_r1.thevar == NULL)        
    {
        this->prt_va(ppara->va_r1, out);
        return;
    }
	if (ppara->var_r1.thevar->m_DataTypeID != 0
		&& GG_VarType_ID2Size(ppara->var_r1.thevar->m_DataTypeID) <= 4)
	{
        this->prt_va(ppara->va_r1, out);