/* A function which spots AIX 'glink' functions. A 'glink' function
is a stub function which has something to do with AIX-style dynamic
linking, and jumps to the real target (with which it typically
shares the same name). See also comment where this function is
used (above). */
static Bool is_aix5_glink_idiom ( Addr sym_addr )
{
# if defined(VGP_ppc32_aix5)
UInt* w = (UInt*)sym_addr;
if (VG_IS_4_ALIGNED(w)
&& is_plausible_guest_addr((Addr)(w+0))
&& is_plausible_guest_addr((Addr)(w+6))
&& (w[0] & 0xFFFF0000) == 0x81820000 /* lwz r12,func@toc(r2) */
&& w[1] == 0x90410014 /* stw r2,20(r1) */
&& w[2] == 0x800c0000 /* lwz r0,0(r12) */
&& w[3] == 0x804c0004 /* lwz r2,4(r12) */
&& w[4] == 0x7c0903a6 /* mtctr r0 */
&& w[5] == 0x4e800420 /* bctr */
&& w[6] == 0x00000000 /* illegal */)
return True;
# elif defined(VGP_ppc64_aix5)
UInt* w = (UInt*)sym_addr;
if (VG_IS_4_ALIGNED(w)
&& is_plausible_guest_addr((Addr)(w+0))
&& is_plausible_guest_addr((Addr)(w+6))
&& (w[0] & 0xFFFF0000) == 0xE9820000 /* ld r12,func@toc(r2) */
&& w[1] == 0xF8410028 /* std r2,40(r1) */
&& w[2] == 0xE80C0000 /* ld r0,0(r12) */
&& w[3] == 0xE84C0008 /* ld r2,8(r12) */
&& w[4] == 0x7c0903a6 /* mtctr r0 */
&& w[5] == 0x4e800420 /* bctr */
&& w[6] == 0x00000000 /* illegal */)
return True;
# endif
return False;
}
void* VG_(memset) ( void *destV, Int c, SizeT sz )
{
Int c4;
HChar* d = (HChar*)destV;
while ((!VG_IS_4_ALIGNED(d)) && sz >= 1) {
d[0] = c;
d++;
sz--;
}
if (sz == 0)
return destV;
c4 = c & 0xFF;
c4 |= (c4 << 8);
c4 |= (c4 << 16);
while (sz >= 16) {
((Int*)d)[0] = c4;
((Int*)d)[1] = c4;
((Int*)d)[2] = c4;
((Int*)d)[3] = c4;
d += 16;
sz -= 16;
}
while (sz >= 4) {
((Int*)d)[0] = c4;
d += 4;
sz -= 4;
}
while (sz >= 1) {
d[0] = c;
d++;
sz--;
}
return destV;
}
void* VG_(memcpy) ( void *dest, const void *src, SizeT sz )
{
const UChar* s = (const UChar*)src;
UChar* d = (UChar*)dest;
const UInt* sI = (const UInt*)src;
UInt* dI = (UInt*)dest;
if (VG_IS_4_ALIGNED(dI) && VG_IS_4_ALIGNED(sI)) {
while (sz >= 16) {
dI[0] = sI[0];
dI[1] = sI[1];
dI[2] = sI[2];
dI[3] = sI[3];
sz -= 16;
dI += 4;
sI += 4;
}
if (sz == 0)
return dest;
while (sz >= 4) {
dI[0] = sI[0];
sz -= 4;
dI += 1;
sI += 1;
}
if (sz == 0)
return dest;
s = (const UChar*)sI;
d = (UChar*)dI;
}
while (sz--)
*d++ = *s++;
return dest;
}
void test_VG_IS_XYZ_ALIGNED(void)
{
CHECK( VG_IS_2_ALIGNED(0x0) );
CHECK( ! VG_IS_2_ALIGNED(0x1) );
CHECK( VG_IS_2_ALIGNED(0x2) );
CHECK( ! VG_IS_2_ALIGNED(0x3) );
CHECK( VG_IS_2_ALIGNED(0x4) );
CHECK( ! VG_IS_2_ALIGNED(0x5) );
CHECK( VG_IS_2_ALIGNED(0x6) );
CHECK( ! VG_IS_2_ALIGNED(0x7) );
CHECK( VG_IS_2_ALIGNED(0x8) );
CHECK( ! VG_IS_2_ALIGNED(0x9) );
CHECK( VG_IS_2_ALIGNED(0xa) );
CHECK( ! VG_IS_2_ALIGNED(0xb) );
CHECK( VG_IS_2_ALIGNED(0xc) );
CHECK( ! VG_IS_2_ALIGNED(0xd) );
CHECK( VG_IS_2_ALIGNED(0xe) );
CHECK( ! VG_IS_2_ALIGNED(0xf) );
CHECK( VG_IS_4_ALIGNED(0x0) );
CHECK( ! VG_IS_4_ALIGNED(0x1) );
CHECK( ! VG_IS_4_ALIGNED(0x2) );
CHECK( ! VG_IS_4_ALIGNED(0x3) );
CHECK( VG_IS_4_ALIGNED(0x4) );
CHECK( ! VG_IS_4_ALIGNED(0x5) );
CHECK( ! VG_IS_4_ALIGNED(0x6) );
CHECK( ! VG_IS_4_ALIGNED(0x7) );
CHECK( VG_IS_4_ALIGNED(0x8) );
CHECK( ! VG_IS_4_ALIGNED(0x9) );
CHECK( ! VG_IS_4_ALIGNED(0xa) );
CHECK( ! VG_IS_4_ALIGNED(0xb) );
CHECK( VG_IS_4_ALIGNED(0xc) );
CHECK( ! VG_IS_4_ALIGNED(0xd) );
CHECK( ! VG_IS_4_ALIGNED(0xe) );
CHECK( ! VG_IS_4_ALIGNED(0xf) );
CHECK( VG_IS_8_ALIGNED(0x0) );
CHECK( ! VG_IS_8_ALIGNED(0x1) );
CHECK( ! VG_IS_8_ALIGNED(0x2) );
CHECK( ! VG_IS_8_ALIGNED(0x3) );
CHECK( ! VG_IS_8_ALIGNED(0x4) );
CHECK( ! VG_IS_8_ALIGNED(0x5) );
CHECK( ! VG_IS_8_ALIGNED(0x6) );
CHECK( ! VG_IS_8_ALIGNED(0x7) );
CHECK( VG_IS_8_ALIGNED(0x8) );
CHECK( ! VG_IS_8_ALIGNED(0x9) );
CHECK( ! VG_IS_8_ALIGNED(0xa) );
CHECK( ! VG_IS_8_ALIGNED(0xb) );
CHECK( ! VG_IS_8_ALIGNED(0xc) );
CHECK( ! VG_IS_8_ALIGNED(0xd) );
CHECK( ! VG_IS_8_ALIGNED(0xe) );
CHECK( ! VG_IS_8_ALIGNED(0xf) );
CHECK( VG_IS_16_ALIGNED(0x0) );
CHECK( ! VG_IS_16_ALIGNED(0x1) );
CHECK( ! VG_IS_16_ALIGNED(0x2) );
CHECK( ! VG_IS_16_ALIGNED(0x3) );
CHECK( ! VG_IS_16_ALIGNED(0x4) );
CHECK( ! VG_IS_16_ALIGNED(0x5) );
CHECK( ! VG_IS_16_ALIGNED(0x6) );
CHECK( ! VG_IS_16_ALIGNED(0x7) );
CHECK( ! VG_IS_16_ALIGNED(0x8) );
CHECK( ! VG_IS_16_ALIGNED(0x9) );
CHECK( ! VG_IS_16_ALIGNED(0xa) );
CHECK( ! VG_IS_16_ALIGNED(0xb) );
CHECK( ! VG_IS_16_ALIGNED(0xc) );
CHECK( ! VG_IS_16_ALIGNED(0xd) );
CHECK( ! VG_IS_16_ALIGNED(0xe) );
CHECK( ! VG_IS_16_ALIGNED(0xf) );
CHECK( VG_IS_WORD_ALIGNED(0x0) );
CHECK( ! VG_IS_WORD_ALIGNED(0x1) );
CHECK( ! VG_IS_WORD_ALIGNED(0x2) );
CHECK( ! VG_IS_WORD_ALIGNED(0x3) );
// 0x4 case below
CHECK( ! VG_IS_WORD_ALIGNED(0x5) );
CHECK( ! VG_IS_WORD_ALIGNED(0x6) );
CHECK( ! VG_IS_WORD_ALIGNED(0x7) );
CHECK( VG_IS_WORD_ALIGNED(0x8) );
CHECK( ! VG_IS_WORD_ALIGNED(0x9) );
CHECK( ! VG_IS_WORD_ALIGNED(0xa) );
CHECK( ! VG_IS_WORD_ALIGNED(0xb) );
// 0xc case below
CHECK( ! VG_IS_WORD_ALIGNED(0xd) );
CHECK( ! VG_IS_WORD_ALIGNED(0xe) );
CHECK( ! VG_IS_WORD_ALIGNED(0xf) );
if (4 == sizeof(void*)) {
CHECK( VG_IS_WORD_ALIGNED(0x4) );
CHECK( VG_IS_WORD_ALIGNED(0xc) );
} else if (8 == sizeof(void*)) {
CHECK( ! VG_IS_WORD_ALIGNED(0x4) );
CHECK( ! VG_IS_WORD_ALIGNED(0xc) );
} else {
assert(0);
}
CHECK( VG_IS_PAGE_ALIGNED(0x0) );
CHECK( ! VG_IS_PAGE_ALIGNED(0x1) );
CHECK( ! VG_IS_PAGE_ALIGNED(0x2) );
CHECK( ! VG_IS_PAGE_ALIGNED(0x3) );
CHECK( ! VG_IS_PAGE_ALIGNED(0x4) );
CHECK( ! VG_IS_PAGE_ALIGNED(VKI_PAGE_SIZE-1) );
CHECK( VG_IS_PAGE_ALIGNED(VKI_PAGE_SIZE ) );
CHECK( ! VG_IS_PAGE_ALIGNED(VKI_PAGE_SIZE+1) );
}
