/* memory operand */
static void memory(int r, int b, int d) {
/* Most of the time (with no indexing), we need a (mode, reg,
r/m) triple, where mode determines the size of displacement (0
= none, 1 = byte, 2 = word), and r/m is the base register.
But there are special cases involving the registers ESP = 4
and EBP = 5:
mode = 0:
Indirect addressing [reg(r/m)]. For [EBP], use (1, r, EBP)
with d = byte(0).
mode = 1 or 2:
Based addressing [d+reg(r/m)]. For [d+ESP] use
(mode, r, 4) followed by SIB = (0, 4, ESP).
mode = 0 and r/m = 5:
Absolute addressing [d].
r/m = 4:
The triple is followed by another byte containing three
values (s, i, b) to encode the address [reg(b)+d+reg(i)*2^s].
But we must not have i = ESP, and there are further special
cases:
mode = 0, r/m = 4, b = 5:
Baseless addressing [d+reg(i)*2^s]
mode = 0, r/m = 4, i = 4, b != 5:
Based addressing [d+reg(b)]. */
if (b == NOREG)
// Absolute [d]
addr(0, r, 5), word(d);
else if (b == ESP) {
// Special case to use ESP as base [ESP+d]
if (d == 0)
addr(0, r, 4), sib(0, 4, ESP);
else if (signed8(d))
addr(1, r, 4), sib(0, 4, ESP), byte(d);
else
addr(2, r, 4), sib(0, 4, ESP), word(d);
}
else {
// Base + Displacement [b+d]
if (d == 0 && b != EBP)
addr(0, r, b);
else if (signed8(d))
addr(1, r, b), byte(d);
else
addr(2, r, b), word(d);
}
}
int modrm1()
{
int r, b, x, y, y1, y2;
b=PeekOneByte();
switch(modTable[b])
{
case 1: r=op(); if(!r) return 0; x=result;
i_mod=x;
break;
case 2: r=op(); if(!r) return 0; x=result;
r=op(); if(!r) return 0; y=result;
i_mod=x; i_sib=y;
if (sibTable[y]==1)
{
r=dword(); if(!r) return 0; y1=result;
m_dword=y1;
}
break;
case 3: r=op(); if(!r) return 0; x=result;
r=dword(); if(!r) return 0; y=result;
i_mod=x; m_dword=y;
break;
case 4: r=op(); if(!r) return 0; x=result;
r=byte(); if(!r) return 0; y=result;
i_mod=x; m_byte=y;
break;
case 5: r=op(); if(!r) return 0; x=result;
r=sib(); if(!r) return 0; y1=result;
r=byte(); if(!r) return 0; y2=result;
i_mod=x; i_sib=y1; m_byte=y2;
break;
case 6: r=op(); if(!r) return 0; x=result;
r=dword(); if(!r) return 0; y=result;
i_mod=x; m_dword=y;
break;
case 7: r=op(); if(!r) return 0; x=result;
r=sib(); if(!r) return 0; y1=result;
r=dword(); if(!r) return 0; y2=result;
i_mod=x; i_sib=y1; m_dword=y2;
break;
case 8: r=op(); if(!r) return 0; x=result;
i_mod=x;
break;
default: return 0;
}
return 1;
}
void do_sib(int m)
{
int s, i, b;
s = ss(sib());
i = indx(sib());
b = base(sib());
switch (b)
{
case 0: expand_out("%p:[EAX"); break;
case 1: expand_out("%p:[ECX"); break;
case 2: expand_out("%p:[EDX"); break;
case 3: expand_out("%p:[EBX"); break;
case 4: expand_out("%p:[ESP"); break;
case 5:
if (m == 0)
{
expand_out("%p:[");
ohex('d', 4, 0, addrsize);
}
else
expand_out("%p:[EBP");
break;
case 6: expand_out("%p:[ESI"); break;
case 7: expand_out("%p:[EDI"); break;
}
switch (i)
{
case 0: fprintf(out_fh,"+EAX"); break;
case 1: fprintf(out_fh,"+ECX"); break;
case 2: fprintf(out_fh,"+EDX"); break;
case 3: fprintf(out_fh,"+EBX"); break;
case 4: break;
case 5: fprintf(out_fh,"+EBP"); break;
case 6: fprintf(out_fh,"+ESI"); break;
case 7: fprintf(out_fh,"+EDI"); break;
}
if (i != 4)
switch (s)
{
case 0: break;
case 1: fprintf(out_fh,"*2"); break;
case 2: fprintf(out_fh,"*4"); break;
case 3: fprintf(out_fh,"*8"); break;
}
}
/*------------------------------------------------------------------------*/
static void do_sib(int m)
{
int s, i, b;
s = SCALE(sib());
i = INDEX(sib());
b = BASE(sib());
switch (b) { /* pick base */
case 0: ua_str("%p:[eax"); break;
case 1: ua_str("%p:[ecx"); break;
case 2: ua_str("%p:[edx"); break;
case 3: ua_str("%p:[ebx"); break;
case 4: ua_str("%p:[esp"); break;
case 5: if (m == 0) {
ua_str("%p:[");
//Flags already set
outhex('d', 4, 0, addrsize, 0);
} else {
ua_str("%p:[ebp");
}
break;
case 6: ua_str("%p:[esi"); break;
case 7: ua_str("%p:[edi"); break;
}
switch (i) { /* and index */
case 0: uprintf("+eax"); break;
case 1: uprintf("+ecx"); break;
case 2: uprintf("+edx"); break;
case 3: uprintf("+ebx"); break;
case 4: break;
case 5: uprintf("+ebp"); break;
case 6: uprintf("+esi"); break;
case 7: uprintf("+edi"); break;
}
if (i != 4)
switch (s) { /* and scale */
case 0: uprintf(""); break;
case 1: uprintf("*2"); break;
case 2: uprintf("*4"); break;
case 3: uprintf("*8"); break;
}
}
void do_sib(int m)
{
int s, i, b;
s = ss(sib());
i = indx(sib());
b = base(sib());
switch (b)
{
case 0: ua_str("%p:[eax"); break;
case 1: ua_str("%p:[ecx"); break;
case 2: ua_str("%p:[edx"); break;
case 3: ua_str("%p:[ebx"); break;
case 4: ua_str("%p:[esp"); break;
case 5:
if (m == 0)
{
ua_str("%p:[");
ohex('d', 4, 0, addrsize);
}
else
ua_str("%p:[ebp");
break;
case 6: ua_str("%p:[esi"); break;
case 7: ua_str("%p:[edi"); break;
}
switch (i)
{
case 0: uprintf("+eax"); break;
case 1: uprintf("+ecx"); break;
case 2: uprintf("+edx"); break;
case 3: uprintf("+ebx"); break;
case 4: break;
case 5: uprintf("+ebp"); break;
case 6: uprintf("+esi"); break;
case 7: uprintf("+edi"); break;
}
if (i != 4)
switch (s)
{
case 0: uprintf(""); break;
case 1: uprintf("*2"); break;
case 2: uprintf("*4"); break;
case 3: uprintf("*8"); break;
}
}
static void do_sib(int m)
{ int s, i, b;
s = SCALE(sib());
i = INDEX(sib());
b = BASE(sib());
switch(b) { /* Pick base */
case 0: ua_str("%p:[EAX"); break;
case 1: ua_str("%p:[ECX"); break;
case 2: ua_str("%p:[EDX"); break;
case 3: ua_str("%p:[EBX"); break;
case 4: ua_str("%p:[ESP"); break;
case 5:
if(m == 0) {
ua_str("%p:[");
outhex('d', 4, 0, addrsize, 0);
} else {
ua_str("%p:[EBP");
}
break;
case 6: ua_str("%p:[ESI"); break;
case 7: ua_str("%p:[EDI"); break;
}
switch(i) { /* and index */
case 0: uprintf("+EAX"); break;
case 1: uprintf("+ECX"); break;
case 2: uprintf("+EDX"); break;
case 3: uprintf("+EBX"); break;
case 4: break;
case 5: uprintf("+EBP"); break;
case 6: uprintf("+ESI"); break;
case 7: uprintf("+EDI"); break;
}
if(i != 4) {
switch(s) { /* and scale */
case 0: uprintf(""); break;
case 1: uprintf("*2"); break;
case 2: uprintf("*4"); break;
case 3: uprintf("*8"); break;
}
}
}
double HPMatcher::hpm(const vector<feat>& feat1,
const vector<size_t>& lab1,
const vector<feat>& feat2, // features [x y scale rotation]
const vector<size_t>& lab2, // labels (visual words)
const vector<vector<size_t> >& cor, // tentative correspondences
vector<double>& strengths, // correspondence strengths
vector<bool>& erased, // erased correspondences
vector<bool>& out_of_bounds) // out of bound transformations
{
// align features based on tentative correspondences
vector<feat> af1, af2;
corr::align(feat1, feat2, cor, af1, af2);
// at least two correspondences needed to match the images
if(!af1.size()) return 0.0;
// align correspondence labels (visual words)
vector<size_t> lab;
corr::align(lab1, lab2, cor, lab, lab);
// relative transformations
vector<feat> tran = feat::rel_tran(af1, af2);
// quantized transformations within bounds
vector<size_t> kept;
vector<unsigned int> qtran = feat::quant(tran, kept, rt, rs, rr, z);
// number of correspondence transformations kept
size_t C = qtran.size();
vector<vector<size_t> > g(C); // group count of each correspondence at each level
vector<float> s(C, 0.0); // correspondence strengths
vector<bool> X(C, false); // erased correspondences
vector<vector<vector<size_t> > > sib(L); // sibling groups at each level
// initialize groups
for(size_t i=0; i<g.size(); i++) g[i].resize(L, 0);
// recursive HPM call
vector<size_t> rng;
for(size_t i=0;i<C;i++)
rng.push_back(i);
if(C) hpm_rec(0, qtran, lab, rng, g, s, X, sib);
// update group count of correspondences in same bin with erased ones
// "undoing" contribution of correspondences that are eventually erased
for(size_t l=0; l<L; l++)
for(size_t i=0, x; x = 0, i<sib[l].size(); i++)
{
const vector<size_t>& si = sib[l][i];
for(size_t j=0; j<si.size(); j++) if(X[si[j]]) x++;
for(size_t j=0; j<si.size(); j++) if(!X[si[j]]) g[si[j]][l] -= x;
}
// correspondence strengths; erased ones have zero strength
strengths.resize(af1.size(), 0.0);
for(size_t i=0; i<C; i++) if(!X[i])
for(size_t l=0; l<L && g[i][l] > 0; l++)
strengths[kept[i]] += g[i][l] << (l ? (l-1) : 0);
// weigh strengths by idf
if(idf.size())
for(size_t i=0;i<kept.size();i++)
strengths[kept[i]] *= idf[lab[kept[i]]];
// positions of erased correspondences
erased.resize(tran.size(), false);
for(size_t i=0;i<X.size();i++)
if(X[i])
erased[kept[i]] = true;
// positions of correspondences out of bounds
out_of_bounds.resize(tran.size(), true);
for(size_t i=0;i<kept.size();i++)
out_of_bounds[kept[i]] = false;
double sm = 0.0;
for(size_t i=0;i<strengths.size();i++) sm+= strengths[i];
// similarity score
return sm;
}
