void dailyCheck(void) {
//calculate sunrise/sunset for the day
if ((0 < Sunrise_Compute(GetM(), GetDOM(), READ_SUNRISE)) && (0 < Sunrise_Compute(GetM(), GetDOM(), READ_SUNSET))){
// _DBG("[INFO]-dailyCheck()");_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
uint32_t unix_day = RTC_time_FindUnixtime(GetY(), GetM(), GetDOM(), 0, 0, 0);
if(dst_correction_needed()){
time2.sunrise_unix = unix_day + (60 * Sunrise_Compute(GetM(), GetDOM(), READ_SUNRISE)) + DST_CORRECTION_VALUE_SEC;
time2.sunset_unix = unix_day + (60 * Sunrise_Compute(GetM(), GetDOM(), READ_SUNSET)) + DST_CORRECTION_VALUE_SEC;
time2.noon_unix = unix_day + (60 * Sunrise_Compute(GetM(), GetDOM(), READ_NOON)) + DST_CORRECTION_VALUE_SEC;
}else{
time2.sunrise_unix = unix_day + (60 * Sunrise_Compute(GetM(), GetDOM(), READ_SUNRISE));
time2.sunset_unix = unix_day + (60 * Sunrise_Compute(GetM(), GetDOM(), READ_SUNSET));
time2.noon_unix = unix_day + (60 * Sunrise_Compute(GetM(), GetDOM(), READ_NOON));
}
} else {
//TODO but not important - Calculation for if the is no sunrise/set/both
/* if ((0 > Sunrise_Compute(time2.month, time2.dom, READ_SUNRISE)) && (0 > Sunrise_Compute(time2.month, time2.dom, READ_SUNSET))){
} else {
if (0 > Sunrise_Compute(time2.month, time2.dom, READ_SUNRISE)){
time2.sunrise_unix = time2.unix + (60 * Sunrise_Compute(time2.month, time2.dom, READ_SUNRISE));
time2.sunset_unix = time2.unix + (24 * 60 * 60);
time2.no_set_rise = RISE_ONLY;
}
if (0 > Sunrise_Compute(time2.month, time2.dom, READ_SUNSET)){
time2.sunset_unix = time2.unix + (60 * Sunrise_Compute(time2.month, time2.dom, READ_SUNSET));
time2.sunrise_unix = time2.unix + (24 * 60 * 60);
time2.no_set_rise = SET_ONLY;
}
}*/
}
}
virtual ST Y(FT x) const
{
const size_t i = this->GetIndex(x);
const FT t = this->GetSubRange(i, x);
const ST y1 = this->GetY(i);
const ST y2 = this->GetY(i+1);
const ST m1 = GetM(i);
const ST m2 = GetM(i+1);
return Function::Hermite<ST, FT>(m1, y1, y2, m2, t);
}
u32 MatchDiv32(u32 pc , Sh4RegType ®1,Sh4RegType ®2 , Sh4RegType ®3)
{
u32 v_pc=pc;
u32 match=1;
for (int i=0;i<32;i++)
{
u16 opcode=ReadMem16(v_pc);
v_pc+=2;
if ((opcode&MASK_N)==ROTCL_KEY)
{
if (reg1==NoReg)
reg1=(Sh4RegType)GetN(opcode);
else if (reg1!=(Sh4RegType)GetN(opcode))
break;
match++;
}
else
{
//printf("DIV MATCH BROKEN BY: %s\n",OpDesc[opcode]->diss);
break;
}
opcode=ReadMem16(v_pc);
v_pc+=2;
if ((opcode&MASK_N_M)==DIV1_KEY)
{
if (reg2==NoReg)
reg2=(Sh4RegType)GetM(opcode);
else if (reg2!=(Sh4RegType)GetM(opcode))
break;
if (reg2==reg1)
break;
if (reg3==NoReg)
reg3=(Sh4RegType)GetN(opcode);
else if (reg3!=(Sh4RegType)GetN(opcode))
break;
if (reg3==reg1)
break;
match++;
}
else
break;
}
return match;
}
u32 MatchDiv32(u32 pc , Sh4RegType ®1,Sh4RegType ®2 , Sh4RegType ®3)
{
if (settings.dynarec.Safe)
return 0;
u32 v_pc=pc;
u32 match=1;
for (int i=0;i<32;i++)
{
u16 opcode=ReadMem16(v_pc);
v_pc+=2;
if ((opcode&MASK_N)==ROTCL_KEY)
{
if (reg1==NoReg)
reg1=(Sh4RegType)GetN(opcode);
else if (reg1!=(Sh4RegType)GetN(opcode))
break;
match++;
}
else
break;
opcode=ReadMem16(v_pc);
v_pc+=2;
if ((opcode&MASK_N_M)==DIV1_KEY)
{
if (reg2==NoReg)
reg2=(Sh4RegType)GetM(opcode);
else if (reg2!=(Sh4RegType)GetM(opcode))
break;
if (reg2==reg1)
break;
if (reg3==NoReg)
reg3=(Sh4RegType)GetN(opcode);
else if (reg3!=(Sh4RegType)GetN(opcode))
break;
if (reg3==reg1)
break;
match++;
}
else
break;
}
return match;
}
strArray GetCellCharItems(pMatrix ppm, int element, int len)
{
int m, n, i;
rMatrix pm = ppm[element];
pMatrix pa0, **pa;
if (!mxIsCell(pm))
ErrMsgTxt("Expecting a cell argument.");
m = GetM(pm);
n = GetN(pm);
if (!(((m == 1) && (n == len)) || ((n == 1) && (m == len))))
ErrMsgTxt("invalid vector.");
pa = pa0 = (pMatrix) matCalloc(len, sizeof(*pa));
for (i = 0; i < len; i++) {
*pa = mxGetCell(pm, i);
if (!mxIsChar(*pa))
break;
pa++;
}
if (i < len) {
matFree(pa0);
ErrMsgTxt("Expecting a character cell element.");
}
return(pa0);
}
bool MatchDiv32s(u32 op,u32 pc)
{
u32 n = GetN(op);
u32 m = GetM(op);
div_som_reg1=NoReg;
div_som_reg2=(Sh4RegType)m;
div_som_reg3=(Sh4RegType)n;
u32 match=MatchDiv32(pc+2,div_som_reg1,div_som_reg2,div_som_reg3);
printf("DIV32S matched %d%% @ 0x%X\n",match*100/65,pc);
if (match==65)
{
//DIV32S was perfectly matched :)
printf("div32s %d/%d/%d\n",div_som_reg1,div_som_reg2,div_som_reg3);
return true;
}
else //no match ...
{
/*
printf("%04X\n",ReadMem16(pc-2));
printf("%04X\n",ReadMem16(pc-0));
printf("%04X\n",ReadMem16(pc+2));
printf("%04X\n",ReadMem16(pc+4));
printf("%04X\n",ReadMem16(pc+6));*/
return false;
}
}
int GetN(structlpsolvecaller *lpsolvecaller, zval arg)
{
int n, n1;
HashTable *arr_hash;
zval *data;
zend_string *key;
long i;
switch (Z_TYPE(arg)) {
case IS_LONG:
case IS_DOUBLE:
n = 1;
break;
case IS_ARRAY:
//n = 1; /* only 1-dim arrays supported at this time */
arr_hash = Z_ARRVAL(arg);
n = 0;
ZEND_HASH_FOREACH_KEY_VAL(arr_hash, i, key, data) {
if (key || (i < 0)) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
n1 = GetM(lpsolvecaller, *data);
if (n1 >= n)
n = n1;
} ZEND_HASH_FOREACH_END();
break;
default:
n = 0;
break;
}
return(n);
}
Double GetRealScalar(pMatrix ppm, int element)
{
rMatrix pm = ppm[element];
if ((GetM(pm) == 1) && (GetN(pm) == 1)
&& (IsNumeric(pm)) && (!IsComplex(pm)) ) {
return(mxGetScalar(pm));
} else {
ErrMsgTxt("Expecting a scalar argument.");
}
return(0.0);
}
void update_time(void){
#if 0
time2.year = RTC_GetTime(LPC_RTC, RTC_TIMETYPE_YEAR);
time2.month = RTC_GetTime(LPC_RTC, RTC_TIMETYPE_MONTH);
time2.dom = RTC_GetTime(LPC_RTC, RTC_TIMETYPE_DAYOFMONTH);
time2.dow = RTC_GetTime(LPC_RTC, RTC_TIMETYPE_DAYOFWEEK);
time2.doy = RTC_GetTime(LPC_RTC, RTC_TIMETYPE_DAYOFYEAR);
time2.hh = RTC_GetTime(LPC_RTC, RTC_TIMETYPE_HOUR);
time2.mm = RTC_GetTime(LPC_RTC, RTC_TIMETYPE_MINUTE);
time2.ss = RTC_GetTime(LPC_RTC, RTC_TIMETYPE_SECOND);
#endif
time2.unix = RTC_time_FindUnixtime(GetY(), GetM(), GetDOM(), GetHH(), GetMM(), GetSS());
UNIX = time2.unix;
// _DBG("[INFO]-time2.unix = ");_DBD32(time2.unix);_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
}
extern "C" void RTC_IRQHandler(void){
// RTC_ClearIntPending(LPC_RTC, RTC_INT_COUNTER_INCREASE);
// secondlyCheck();
// return;
uint32_t secval;
// This is increment counter interrupt
if (RTC_GetIntPending(LPC_RTC, RTC_INT_COUNTER_INCREASE)){
// Clear pending interrupt
RTC_ClearIntPending(LPC_RTC, RTC_INT_COUNTER_INCREASE);
_60th_SEC_COUNT=0;
time2.second_inc=1;
//run checks at xx:xx:00
if(!GetSS()){
//run checks at xx:00:00
if(!GetMM()){
//run daily checks at 00:00:00
if(!GetHH()){
//run weekly checks at Mon 00:00:00
if(1 == GetDOW()){
//run weekly checks at 1st Mon 00:00:00
if(1 == GetDOM()){
//run weekly checks at Jan 1st Mon 00:00:00
if(1 == GetM()){
yearlyCheck();
}
monthlyCheck();
}
weeklyCheck();
}
dailyCheck();
}
hourlyCheck();
}
minutelyCheck();
}
secondlyCheck();
}
// Continue to check the Alarm match
if (RTC_GetIntPending(LPC_RTC, RTC_INT_ALARM)){
// Clear pending interrupt
RTC_ClearIntPending(LPC_RTC, RTC_INT_ALARM);
set_next_alarm();
sort_alarms();
/* Send debug information */
// _DBG_ ("ALARM 10s matched!");
}
}
void DST_check_and_correct(void) {
// time2.unix = RTC_time_FindUnixtime(time2.year, time2.month, time2.dom, time2.hh, time2.mm, time2.ss);
// _DBG("[INFO]-time2.hh=");_DBD(time2.hh);_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
// Only update time once for DST when it ticks over
// _DBG("[INFO]-dst_correction_needed() = ");_DBD32(dst_correction_needed());_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
if(dst_correction_needed()!=getDSTstatus()){
if(dst_correction_needed()){
time2.unix = time2.unix + DST_CORRECTION_VALUE_SEC;
setDSTstatus(1);
}
else{
time2.unix = time2.unix - DST_CORRECTION_VALUE_SEC;
setDSTstatus(0);
}
unix_to_hh_mm_ss(time2.unix, &time2.hh, &time2.mm, &time2.ss);
RTC_time_SetTime(GetY(), GetM(), GetDOM(), time2.hh, time2.mm, time2.ss, 00);
}
#if 0 //old
if(dst_correction_needed()) {
// _DBG("dst_correction_needed");_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
if(time2.DST_begin_calculated == time2.unix){
time2.unix_dst_last_update = time2.unix;
time2.unix += DST_CORRECTION_VALUE_SEC;
unix_to_hh_mm_ss(time2.unix, &time2.hh, &time2.mm, &time2.ss);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_SECOND, time2.ss);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_MINUTE, time2.mm);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_HOUR, time2.hh);
}
if(time2.DST_end_calculated == time2.unix){
if(time2.unix_dst_last_update != time2.DST_end_calculated){
time2.unix_dst_last_update = time2.unix;
time2.unix -= DST_CORRECTION_VALUE_SEC;
unix_to_hh_mm_ss(time2.unix, &time2.hh, &time2.mm, &time2.ss);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_SECOND, time2.ss);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_MINUTE, time2.mm);
RTC_SetTime (LPC_RTC, RTC_TIMETYPE_HOUR, time2.hh);
}
}
time2.unix_utc = time2.unix - DST_CORRECTION_VALUE_SEC;
// _DBD(time2.hh_utc);_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
}else{
time2.unix_utc = time2.unix;
}
#endif
}
bool __fastcall MatchDiv32s(u32 op,u32 pc)
{
u32 n = GetN(op);
u32 m = GetM(op);
div_som_reg1=NoReg;
div_som_reg2=(Sh4RegType)m;
div_som_reg3=(Sh4RegType)n;
u32 match=MatchDiv32(pc+2,div_som_reg1,div_som_reg2,div_som_reg3);
log("DIV32S matched %d%% @ 0x%X\n",match*100/65,pc);
if (match==65)
{
//DIV32S was perfectly matched :)
return true;
}
else //no match ...
return false;
}
void RTC_print_time(void){
char buffer[100];
time_t rawtime;
struct tm * timeinfo;
// xprintf(INFO "%d/%d/%d %d:%d:%d" " (%s:%d)\n",GetDOM(),GetM(),GetY(),GetHH(),GetMM(),GetSS(),_F_,_L_);
time( &rawtime );
timeinfo = localtime ( &rawtime );
strftime(buffer,90,"%d/%m/%Y %I:%M:%S%p WOY:%U DOY:%j",timeinfo);
xprintf(INFO "%s" " (%s:%d)\n", buffer,_F_,_L_);
// xprintf(INFO "%d/%d/%d %d:%d:%d" " (%s:%d)\n",_F_,_L_);
// xprintf(INFO "Unix: %d" " (%s:%d)\n",time2.unix,_F_,_L_);
// xprintf(INFO "Sunrise: %d" " (%s:%d)\n",time2.sunrise_unix,_F_,_L_);
timeinfo = localtime ( &time2.sunrise_unix );
strftime(buffer,80,"Sunrise: %I:%M:%S%p.",timeinfo);
xprintf(INFO "%s" " (%s:%d)\n", buffer,_F_,_L_);
// xprintf(INFO "Sunset: %d" " (%s:%d)\n",time2.sunset_unix,_F_,_L_);
timeinfo = localtime ( &time2.sunset_unix );
strftime(buffer,80,"Sunset: %I:%M:%S%p.",timeinfo);
xprintf(INFO "%s" " (%s:%d)\n", buffer,_F_,_L_);
// xprintf(INFO "Noon: %d" " (%s:%d)\n",time2.noon_unix,_F_,_L_);
timeinfo = localtime ( &time2.noon_unix );
strftime(buffer,80,"Noon: %I:%M:%S%p.",timeinfo);
xprintf(INFO "%s" " (%s:%d)\n", buffer,_F_,_L_);
xprintf(INFO "It's %s" " (%s:%d)\n",time2.day_night ? "Night time" : "Day time" ,_F_,_L_);
// xprintf(INFO "Day/Night: %d" " (%s:%d)\n",time2.day_night,_F_,_L_);
xprintf(INFO "DST begin: %d end: %d" " (%s:%d)\n",time2.DST_begin_calculated,time2.DST_end_calculated,_F_,_L_);
#if 0
_DBG("[INFO]-Date=");
_DBD(GetDOM());
_DBG("/");
_DBD(GetM());
_DBG("/");
_DBD16(GetY());
_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
_DBG("[INFO]-Time=");
_DBD(GetHH());
_DBG(":");
_DBD(GetMM());
_DBG(":");
_DBD(GetSS());
_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
_DBG("[INFO]-Unix: ");
_DBD32(time2.unix);
_DBG(" Sunrise: ");
_DBD32(time2.sunrise_unix);
_DBG(" Sunset: ");
_DBD32(time2.sunset_unix);
_DBG(" Noon: ");
_DBD32(time2.noon_unix);
_DBG(" Day/Night: ");
_DBD(time2.day_night);
_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
_DBG("[INFO]-DST begin: ");
_DBD32(time2.DST_begin_calculated);
_DBG(" end: ");
_DBD32(time2.DST_end_calculated);
_DBG(" (");_DBG(__FILE__);_DBG(":");_DBD16(__LINE__);_DBG(")\r\n");
#endif
}
int GetRealSparseVector(structlpsolvecaller *lpsolvecaller, int element, Double *vec, int *index, int start, int len, int col)
{
int m, n, count = 0;
zval pm = GetpMatrix(lpsolvecaller, element);
zval *data;
HashTable *arr_hash;
Double a;
zend_string *key;
ulong i;
if ((Z_ISUNDEF(pm)) || (Z_TYPE(pm) != IS_ARRAY)) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
#if 1
m = GetM(lpsolvecaller, pm);
n = GetN(lpsolvecaller, pm);
#else
m = zend_hash_num_elements(Z_ARRVAL_P(pm));
n = 1;
#endif
if ( ((col == 0) && (((m != 1) && (n != 1)) || ((m == 1) && (n > len)) || ((n == 1) && (m > len)))) ||
((col != 0) && ((m > len) || (col > n))) /* ||
!IsNumeric(pm) ||
IsComplex(pm) */ ) {
/* Printf("1: m=%d, n=%d, col=%d, len=%d, IsNumeric=%d, IsComplex=%d\n", m,n,col,len,IsNumeric(pm),IsComplex(pm)); */
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
if ((((n == 1) || (col != 0)) && (m > len)) || ((col == 0) && (m == 1) && (n > len))) {
/* Printf("2: m=%d, n=%d, col=%d, len=%d\n", m,n,col,len); */
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
arr_hash = Z_ARRVAL(pm);
ZEND_HASH_FOREACH_KEY_VAL(arr_hash, i, key, data) {
if (key) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
} else {
zval pm = *data;
a = 0;
if (Z_TYPE(pm) == IS_ARRAY) {
zval *data;
HashTable *arr_hash;
zend_string *key;
ulong i;
arr_hash = Z_ARRVAL(pm);
ZEND_HASH_FOREACH_KEY_VAL(arr_hash, i, key, data) {
if (key) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
} else if (i + 1 == col) {
a = GetRealArg(lpsolvecaller, *data);
break;
}
} ZEND_HASH_FOREACH_END();
} else {
a = GetRealArg(lpsolvecaller, pm);
}
if (a) {
*(vec++) = a;
*(index++) = start + i;
count++;
}
}
//
// process thread
//
unsigned __stdcall MatchThreadForFull(void *pParam)
{
int FLEN;
int n = 0, n1, i;
dbQuery sql;
ControlFlowGraph *target_cfg;
db.attach();
dbCursor<LibM> cursor1;
int thread_id = (int)pParam;
instruction_count[thread_id] = 0;
fn[thread_id] = 0;
while ((i = GetM()) != -1)
{
int startEA = f_info[i].startEA;
FLEN = f_info[i].len;
// disasm
byte *bin = (byte *)RvaToPtr(pImageNtH, stMapFile.ImageBase, startEA - pOH->ImageBase);
if (bin == NULL)
{
continue;
}
target_cfg = (ControlFlowGraph *)disasm(bin, FLEN, false, NULL);
if (target_cfg == NULL || target_cfg->instructions.size() < MIN_INS_LENGTH)
{
clean(target_cfg);
continue;
}
fn[thread_id]++;
instruction_count[thread_id] += target_cfg->instructions.size();
target_cfg->build();
{
sql = "MOV_COUNT=", target_cfg->MOV_COUNT, " and CTI_COUNT=", target_cfg->CTI_COUNT, " and ARITHMETIC_COUNT=", target_cfg->ARITHMETIC_COUNT, " and LOGI_COUNT=", target_cfg->LOGI_COUNT, " and STRING_COUNT=", target_cfg->STRING_COUNT, " and ETC_COUNT=", target_cfg->ETC_COUNT, " and instruction_size=", target_cfg->instructions.size(), "and block_size=", target_cfg->bb_len, "order by instruction_size desc";
}
n1 = cursor1.select(sql);
if (n1 == 0)
{
clean(target_cfg);
continue;
}
CBitSet lib_info(target_cfg->instructions.size());
do
{
ControlFlowGraph *library_cfg = (ControlFlowGraph *)(cursor1->cfg);
// BBLR
bitset<10240> t = target_cfg->bblen_set;
t.flip();
t &= library_cfg->bblen_set;
if (t.any())
{
continue;
}
target_cfg->buildDepGraph(false);
library_cfg->buildDepGraph(true);
//if (bSerialize)
{
// rule5: BBSR
if (!matchBBSF(target_cfg, library_cfg))
{
//r5[thread_id]++;
continue;
}
}
library_cfg->serialize();
library_cfg->buildVLibGraph();
target_cfg->serialize();
target_cfg->buildVLibGraph();
//r0[thread_id]++;
Graph _g(&target_cfg->vlibARGEdit);
Graph _m(&library_cfg->vlibARGEdit);
_m.SetNodeComparator(new InstructionComparator3);
VF2SubState s0(&_m, &_g);
Match m(&s0, my_visitor1, &lib_info);
m.match_par();
if (m.foundFlg)
{
printf("%d\t1\t%X\t%s\n", thread_id, startEA, cursor1->lib_name);
}
}
while (cursor1.next());
clean(target_cfg);
}
db.detach();
printf("#%d done.\n", thread_id);
return 0;
}
void dec_param(DecParam p,shil_param& r1,shil_param& r2, u32 op)
{
switch(p)
{
//constants
case PRM_PC_D8_x2:
r1=mk_imm((state.cpu.rpc+4)+(GetImm8(op)<<1));
break;
case PRM_PC_D8_x4:
r1=mk_imm(((state.cpu.rpc+4)&0xFFFFFFFC)+(GetImm8(op)<<2));
break;
case PRM_ZERO:
r1= mk_imm(0);
break;
case PRM_ONE:
r1= mk_imm(1);
break;
case PRM_TWO:
r1= mk_imm(2);
break;
case PRM_TWO_INV:
r1= mk_imm(~2);
break;
case PRM_ONE_F32:
r1= mk_imm(0x3f800000);
break;
//imms
case PRM_SIMM8:
r1=mk_imm(GetSImm8(op));
break;
case PRM_UIMM8:
r1=mk_imm(GetImm8(op));
break;
//direct registers
case PRM_R0:
r1=mk_reg(reg_r0);
break;
case PRM_RN:
r1=mk_regi(reg_r0+GetN(op));
break;
case PRM_RM:
r1=mk_regi(reg_r0+GetM(op));
break;
case PRM_FRN_SZ:
if (state.cpu.FSZ64)
{
int rx=GetN(op)/2;
if (GetN(op)&1)
rx+=regv_xd_0;
else
rx+=regv_dr_0;
r1=mk_regi(rx);
break;
}
case PRM_FRN:
r1=mk_regi(reg_fr_0+GetN(op));
break;
case PRM_FRM_SZ:
if (state.cpu.FSZ64)
{
int rx=GetM(op)/2;
if (GetM(op)&1)
rx+=regv_xd_0;
else
rx+=regv_dr_0;
r1=mk_regi(rx);
break;
}
case PRM_FRM:
r1=mk_regi(reg_fr_0+GetM(op));
break;
case PRM_FPUL:
r1=mk_regi(reg_fpul);
break;
case PRM_FPN: //float pair, 3 bits
r1=mk_regi(regv_dr_0+GetN(op)/2);
break;
case PRM_FVN: //float quad, 2 bits
r1=mk_regi(regv_fv_0+GetN(op)/4);
break;
case PRM_FVM: //float quad, 2 bits
r1=mk_regi(regv_fv_0+(GetN(op)&0x3));
break;
case PRM_XMTRX: //float matrix, 0 bits
r1=mk_regi(regv_xmtrx);
break;
case PRM_FRM_FR0:
r1=mk_regi(reg_fr_0+GetM(op));
r2=mk_regi(reg_fr_0);
break;
case PRM_SR_T:
r1=mk_regi(reg_sr_T);
break;
case PRM_SR_STATUS:
r1=mk_regi(reg_sr_status);
break;
case PRM_SREG: //FPUL/FPSCR/MACH/MACL/PR/DBR/SGR
r1=mk_regi(SREGS[GetM(op)]);
break;
case PRM_CREG: //SR/GBR/VBR/SSR/SPC/<RM_BANK>
r1=mk_regi(CREGS[GetM(op)]);
break;
//reg/imm reg/reg
case PRM_RN_D4_x1:
case PRM_RN_D4_x2:
case PRM_RN_D4_x4:
{
u32 shft=p-PRM_RN_D4_x1;
r1=mk_regi(reg_r0+GetN(op));
r2=mk_imm(GetImm4(op)<<shft);
}
break;
case PRM_RN_R0:
r1=mk_regi(reg_r0+GetN(op));
r2=mk_regi(reg_r0);
break;
case PRM_RM_D4_x1:
case PRM_RM_D4_x2:
case PRM_RM_D4_x4:
{
u32 shft=p-PRM_RM_D4_x1;
r1=mk_regi(reg_r0+GetM(op));
r2=mk_imm(GetImm4(op)<<shft);
}
break;
case PRM_RM_R0:
r1=mk_regi(reg_r0+GetM(op));
r2=mk_regi(reg_r0);
break;
case PRM_GBR_D8_x1:
case PRM_GBR_D8_x2:
case PRM_GBR_D8_x4:
{
u32 shft=p-PRM_GBR_D8_x1;
r1=mk_regi(reg_gbr);
r2=mk_imm(GetImm8(op)<<shft);
}
break;
default:
die("Non-supported parameter used");
}
}
void SimplexLP::ToStandard( VerbLevel Verbosity )
{
//--------------------------------------------------------------------------
// Resize all the vectors to match the constraint matrix dimensions.
//
SlackU.Resize( m ); SlackU.Fill( +INFINITY, m );
SlackVT.Resize( m ); SlackVT.Fill( VT_NORM, m );
Slack.Resize( m );
SlackRow.Resize( m );
SlackPosByRows.Resize( m ); SlackPosByRows.Fill( -1, m );
Lambda.Resize( m ); Lambda.Fill( 1.0, m );
LambdaVT.Resize( m ); LambdaVT.Fill( VT_FIXED | VT_ARTIF, m );
LambdaRow.Resize( m );
Int_T i;
for( i = 0; i < m; i++ ) LambdaRow[i] = i;
ComputePenalty();
ShiftLowerBoundsToZero();
//--------------------------------------------------------------------------
// Add slacks to non-equality rows.
//
for( i = 0; i < m; i++ )
{
//----------------------------------------------------------------------
// Row with a range => upper bound on a slack variable has to be
// imposed.
//
if( RowType[i] & RT_RNG )
{
switch( RowType[i] & RT_TYPE )
{
case RT_LE: Slack[ SlackLen ] = 1.0e0; break;
case RT_GE: Slack[ SlackLen ] = -1.0e0; break;
case RT_EQ: Slack[ SlackLen ] = r[i] > 0.0 ? -1.0 : 1.0; break;
#ifndef NDEBUG
default: abort();
#endif
}
SlackU[ SlackLen ] = fabs( r[i] );
SlackVT[ SlackLen ] = VT_BOUNDED;
SlackRow[ SlackLen ] = i;
SlackPosByRows[ i ] = SlackLen++;
}
else
//----------------------------------------------------------------------
// Row without a range. Slack declared PL or MI depending on row type.
//
{
Slack[ SlackLen ] = 1.0e0;
switch( RowType[i] & RT_TYPE )
{
case RT_LE:
SlackVT[ SlackLen ] = VT_NORM;
break;
case RT_GE:
SlackVT[ SlackLen ] = VT_MI;
SlackU[ SlackLen ] = 0.0;
break;
case RT_EQ: break;
#ifndef NDEBUG
default: abort();
#endif
}
if( !(RowType[i] & RT_EQ) )
{
SlackRow[ SlackLen ] = i;
SlackPosByRows[ i ] = SlackLen++;
}
}
}
//--------------------------------------------------------------------------
// Report on current problem statistics.
//
if( Verbosity >= V_HIGH )
Print(
/* Stream output FORMAT (two lines at the top, then - a table). */
"\nConversion to standard form completed.\n"
"Constraint matrix data:\n"
"\t%-18s%10d\n"
"\t%-18s%10d\n"
"\t%-18s%10ld\n"
"\t%-18s%10d\n"
"\t%-18s%10.4f %%\n"
"\t%-18s%10.4f %%\n",
/* DATA. */
"No. of rows:", (int) GetM(),
"No. of vars:", (int) GetN(),
"No. of non-zeros:", (long int) GetNZ(),
"No. of slacks:", (int) SlackLen,
"Density (orig.):", (double)( 100 * nz )
/ (double) ( m * n ),
"Density (total):", double( 100 * GetNZ() )
/ (double) ( GetM() * GetN() )
);
Standard = True;
}
unsigned __stdcall MatchThread(void *pParam)
{
int FLEN;
int n = 0, n1, i;
dbQuery sql;
ControlFlowGraph *target_cfg;
db.attach();
dbCursor<LibM> cursor1;
int thread_id = (int)pParam;
instruction_count[thread_id] = 0;
fn[thread_id] = 0;
while ((i = GetM()) != -1)
{
int startEA = f_info[i].startEA;
FLEN = f_info[i].len;
// disasm
byte *bin = (byte *)RvaToPtr(pImageNtH, stMapFile.ImageBase, startEA - pOH->ImageBase);
if (bin == NULL)
{
continue;
}
target_cfg = (ControlFlowGraph *)disasm(bin, FLEN, false, NULL);
if (target_cfg == NULL || target_cfg->instructions.size() < MIN_INS_LENGTH)
{
clean(target_cfg);
continue;
}
fn[thread_id]++;
instruction_count[thread_id] += target_cfg->instructions.size();
target_cfg->build();
{
sql = "MOV_COUNT<=", target_cfg->MOV_COUNT, " and CTI_COUNT<=", target_cfg->CTI_COUNT, " and ARITHMETIC_COUNT<=", target_cfg->ARITHMETIC_COUNT, " and LOGI_COUNT<=", target_cfg->LOGI_COUNT, " and STRING_COUNT<=", target_cfg->STRING_COUNT, " and ETC_COUNT<=", target_cfg->ETC_COUNT, " and instruction_size<=", target_cfg->instructions.size(), "and block_size<=", target_cfg->bb_len, "order by instruction_size desc";
}
n1 = cursor1.select(sql);
if (n1 == 0)
{
clean(target_cfg);
continue;
}
CBitSet lib_info(target_cfg->instructions.size());
do
{
ControlFlowGraph *library_cfg = (ControlFlowGraph *)(cursor1->cfg);
target_cfg->buildDepGraph(false);
library_cfg->buildDepGraph(true);
library_cfg->serialize();
library_cfg->buildVLibGraph();
target_cfg->serialize();
target_cfg->buildVLibGraph();
//r0[thread_id]++;
Graph _g(&target_cfg->vlibARGEdit);
Graph _m(&library_cfg->vlibARGEdit);
_m.SetNodeComparator(new InstructionComparator3);
VF2SubState s0(&_m, &_g);
int d[4];
d[0] = (int)target_cfg;
d[1] = startEA;
d[2] = (int)cursor1->lib_name;
d[3] = (int)&lib_info;
Match m(&s0, my_visitor2, &d);
m.match_serial();
}
while (cursor1.next());
clean(target_cfg);
}
db.detach();
printf("#%d done.\n", thread_id);
return 0;
}
int GetRealSparseVector(pMatrix ppm, int element, Double *vec, int *index, int start, int len, int col)
{
int j, k, k1, m, n, start1, count = 0;
int *ir, *jc;
double *pr, *pr0;
rMatrix pm = ppm[element];
m = GetM(pm);
n = GetN(pm);
if ( ((col == 0) && (((m != 1) && (n != 1)) || ((m == 1) && (n > len)) || ((n == 1) && (m > len)))) ||
((col != 0) && ((m > len) || (col > n))) ||
!IsNumeric(pm) ||
IsComplex(pm) ) {
ErrMsgTxt("invalid vector.");
}
pr = GetPr(pm);
if (!IsSparse(pm)) {
if ((((n == 1) || (col != 0)) && (m != len)) || ((col == 0) && (m == 1) && (n != len)))
ErrMsgTxt("invalid vector.");
if (col)
pr += (col - 1) * m;
for (k = 0; k < len; k++, pr++) {
if (*pr) {
*(vec++) = *pr;
*(index++) = start + k;
count++;
}
}
} else if (IsSparse(pm)) {
int j1, j2;
jc = mxGetJc(pm);
ir = mxGetIr(pm);
pr0 = pr;
if (col == 0) {
j1 = 0;
j2 = n;
}
else {
j1 = col - 1;
j2 = col;
}
for (j = j1; j < j2; j++) {
k = jc[j];
k1 = jc[j + 1];
pr = pr0 + k;
start1 = start;
if (col == 0)
start1 += j * m;
for (; k < k1; k++, pr++, vec++, index++) {
*vec = *pr;
*index = start1 + ir[k];
count++;
}
}
} else {
ErrMsgTxt("Can't figure out this matrix.");
}
return(count);
}
