/*---------------------------------------------------------------*/
/*--- begin main_util.c ---*/
/*---------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2004-2015 OpenWorks LLP
info@open-works.net
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
The GNU General Public License is contained in the file COPYING.
Neither the names of the U.S. Department of Energy nor the
University of California nor the names of its contributors may be
used to endorse or promote products derived from this software
without prior written permission.
*/
#include "libvex_basictypes.h"
#include "libvex.h"
#include "main_globals.h"
#include "main_util.h"
/*---------------------------------------------------------*/
/*--- Storage ---*/
/*---------------------------------------------------------*/
/* Try to keep this as low as possible -- in particular, less than the
size of the smallest L2 cache we might encounter. At 50000, my VIA
Nehemiah 1 GHz (a weedy machine) can satisfy 27 million calls/
second to LibVEX_Alloc(16) -- that is, allocate memory at over 400
MByte/sec. Once the size increases enough to fall out of the cache
into memory, the rate falls by about a factor of 3.
*/
#define N_TEMPORARY_BYTES 5000000
static HChar temporary[N_TEMPORARY_BYTES] __attribute__((aligned(REQ_ALIGN)));
static HChar* temporary_first = &temporary[0];
static HChar* temporary_curr = &temporary[0];
static HChar* temporary_last = &temporary[N_TEMPORARY_BYTES-1];
static ULong temporary_bytes_allocd_TOT = 0;
#define N_PERMANENT_BYTES 10000
static HChar permanent[N_PERMANENT_BYTES] __attribute__((aligned(REQ_ALIGN)));
static HChar* permanent_first = &permanent[0];
static HChar* permanent_curr = &permanent[0];
static HChar* permanent_last = &permanent[N_PERMANENT_BYTES-1];
HChar* private_LibVEX_alloc_first = &temporary[0];
HChar* private_LibVEX_alloc_curr = &temporary[0];
HChar* private_LibVEX_alloc_last = &temporary[N_TEMPORARY_BYTES-1];
static VexAllocMode mode = VexAllocModeTEMP;
void vexAllocSanityCheck ( void )
{
vassert(temporary_first == &temporary[0]);
vassert(temporary_last == &temporary[N_TEMPORARY_BYTES-1]);
vassert(permanent_first == &permanent[0]);
vassert(permanent_last == &permanent[N_PERMANENT_BYTES-1]);
vassert(temporary_first <= temporary_curr);
vassert(temporary_curr <= temporary_last);
vassert(permanent_first <= permanent_curr);
vassert(permanent_curr <= permanent_last);
vassert(private_LibVEX_alloc_first <= private_LibVEX_alloc_curr);
vassert(private_LibVEX_alloc_curr <= private_LibVEX_alloc_last);
if (mode == VexAllocModeTEMP){
vassert(private_LibVEX_alloc_first == temporary_first);
vassert(private_LibVEX_alloc_last == temporary_last);
}
else
if (mode == VexAllocModePERM) {
vassert(private_LibVEX_alloc_first == permanent_first);
vassert(private_LibVEX_alloc_last == permanent_last);
}
else
vassert(0);
# define IS_WORD_ALIGNED(p) (0 == (((HWord)p) & (sizeof(HWord)-1)))
vassert(sizeof(HWord) == 4 || sizeof(HWord) == 8);
vassert(IS_WORD_ALIGNED(temporary_first));
vassert(IS_WORD_ALIGNED(temporary_curr));
vassert(IS_WORD_ALIGNED(temporary_last+1));
vassert(IS_WORD_ALIGNED(permanent_first));
vassert(IS_WORD_ALIGNED(permanent_curr));
vassert(IS_WORD_ALIGNED(permanent_last+1));
vassert(IS_WORD_ALIGNED(private_LibVEX_alloc_first));
vassert(IS_WORD_ALIGNED(private_LibVEX_alloc_curr));
vassert(IS_WORD_ALIGNED(private_LibVEX_alloc_last+1));
# undef IS_WORD_ALIGNED
}
/* The current allocation mode. */
void vexSetAllocMode ( VexAllocMode m )
{
vexAllocSanityCheck();
/* Save away the current allocation point .. */
if (mode == VexAllocModeTEMP){
temporary_curr = private_LibVEX_alloc_curr;
}
else
if (mode == VexAllocModePERM) {
permanent_curr = private_LibVEX_alloc_curr;
}
else
vassert(0);
/* Did that screw anything up? */
vexAllocSanityCheck();
if (m == VexAllocModeTEMP){
private_LibVEX_alloc_first = temporary_first;
private_LibVEX_alloc_curr = temporary_curr;
private_LibVEX_alloc_last = temporary_last;
}
else
if (m == VexAllocModePERM) {
private_LibVEX_alloc_first = permanent_first;
private_LibVEX_alloc_curr = permanent_curr;
private_LibVEX_alloc_last = permanent_last;
}
else
vassert(0);
mode = m;
}
VexAllocMode vexGetAllocMode ( void )
{
return mode;
}
__attribute__((noreturn))
void private_LibVEX_alloc_OOM(void)
{
const HChar* pool = "???";
if (private_LibVEX_alloc_first == &temporary[0]) pool = "TEMP";
if (private_LibVEX_alloc_first == &permanent[0]) pool = "PERM";
vex_printf("VEX temporary storage exhausted.\n");
vex_printf("Pool = %s, start %p curr %p end %p (size %lld)\n",
pool,
private_LibVEX_alloc_first,
private_LibVEX_alloc_curr,
private_LibVEX_alloc_last,
(Long)(private_LibVEX_alloc_last + 1 - private_LibVEX_alloc_first));
vpanic("VEX temporary storage exhausted.\n"
"Increase N_{TEMPORARY,PERMANENT}_BYTES and recompile.");
}
void vexSetAllocModeTEMP_and_clear ( void )
{
/* vassert(vex_initdone); */ /* causes infinite assert loops */
temporary_bytes_allocd_TOT
+= (ULong)(private_LibVEX_alloc_curr - private_LibVEX_alloc_first);
mode = VexAllocModeTEMP;
temporary_curr = &temporary[0];
private_LibVEX_alloc_curr = &temporary[0];
/* Set to (1) and change the fill byte to 0x00 or 0xFF to test for
any potential bugs due to using uninitialised memory in the main
VEX storage area. */
if (0) {
Int i;
for (i = 0; i < N_TEMPORARY_BYTES; i++)
temporary[i] = 0x00;
}
vexAllocSanityCheck();
}
/* Exported to library client. */
void LibVEX_ShowAllocStats ( void )
{
vex_printf("vex storage: T total %lld bytes allocated\n",
(Long)temporary_bytes_allocd_TOT );
vex_printf("vex storage: P total %lld bytes allocated\n",
(Long)(permanent_curr - permanent_first) );
}
void *LibVEX_Alloc ( SizeT nbytes )
{
return LibVEX_Alloc_inline(nbytes);
}
/*---------------------------------------------------------*/
/*--- Bombing out ---*/
/*---------------------------------------------------------*/
__attribute__ ((noreturn))
void vex_assert_fail ( const HChar* expr,
const HChar* file, Int line, const HChar* fn )
{
vex_printf( "\nvex: %s:%d (%s): Assertion `%s' failed.\n",
file, line, fn, expr );
(*vex_failure_exit)();
}
/* To be used in assert-like (i.e. should never ever happen) situations */
__attribute__ ((noreturn))
void vpanic ( const HChar* str )
{
vex_printf("\nvex: the `impossible' happened:\n %s\n", str);
(*vex_failure_exit)();
}
/*---------------------------------------------------------*/
/*--- vex_printf ---*/
/*---------------------------------------------------------*/
/* This should be the only <...> include in the entire VEX library.
New code for vex_util.c should go above this point. */
#include <stdarg.h>
SizeT vex_strlen ( const HChar* str )
{
SizeT i = 0;
while (str[i] != 0) i++;
return i;
}
Bool vex_streq ( const HChar* s1, const HChar* s2 )
{
while (True) {
if (*s1 == 0 && *s2 == 0)
return True;
if (*s1 != *s2)
return False;
s1++;
s2++;
}
}
void vex_bzero ( void* sV, SizeT n )
{
SizeT i;
UChar* s = (UChar*)sV;
/* No laughing, please. Just don't call this too often. Thank you
for your attention. */
for (i = 0; i < n; i++) s[i] = 0;
}
/* Convert N0 into ascii in BUF, which is assumed to be big enough (at
least 67 bytes long). Observe BASE, SYNED and HEXCAPS. */
static
void convert_int ( /*OUT*/HChar* buf, Long n0,
Int base, Bool syned, Bool hexcaps )
{
ULong u0;
HChar c;
Bool minus = False;
Int i, j, bufi = 0;
buf[bufi] = 0;
if (syned) {
if (n0 < 0) {
minus = True;
u0 = (ULong)(-n0);
} else {
u0 = (ULong)(n0);
}
} else {
u0 = (ULong)n0;
}
while (1) {
buf[bufi++] = toHChar('0' + toUInt(u0 % base));
u0 /= base;
if (u0 == 0) break;
}
if (minus)
buf[bufi++] = '-';
buf[bufi] = 0;
for (i = 0; i < bufi; i++)
if (buf[i] > '9')
buf[i] = toHChar(buf[i] + (hexcaps ? 'A' : 'a') - '9' - 1);
i = 0;
j = bufi-1;
while (i <= j) {
c = buf[i];
buf[i] = buf[j];
buf[j] = c;
i++;
j--;
}
}
/* A half-arsed and buggy, but good-enough, implementation of
printf. */
static
UInt vprintf_wrk ( void(*sink)(HChar),
const HChar* format,
va_list ap )
{
# define PUT(_ch) \
do { sink(_ch); nout++; } \
while (0)
# define PAD(_n) \
do { Int _qq = (_n); for (; _qq > 0; _qq--) PUT(padchar); } \
while (0)
# define PUTSTR(_str) \
do { const HChar* _qq = _str; for (; *_qq; _qq++) PUT(*_qq); } \
while (0)
const HChar* saved_format;
Bool longlong, ljustify, is_sizet;
HChar padchar;
Int fwidth, nout, len1, len3;
SizeT len2;
HChar intbuf[100]; /* big enough for a 64-bit # in base 2 */
nout = 0;
while (1) {
if (!format)
break;
if (*format == 0)
break;
if (*format != '%') {
PUT(*format);
format++;
continue;
}
saved_format = format;
longlong = is_sizet = False;
ljustify = False;
padchar = ' ';
fwidth = 0;
format++;
if (*format == '-') {
format++;
ljustify = True;
}
if (*format == '0') {
format++;
padchar = '0';
}
if (*format == '*') {
fwidth = va_arg(ap, Int);
vassert(fwidth >= 0);
format++;
} else {
while (*format >= '0' && *format <= '9') {
fwidth = fwidth * 10 + (*format - '0');
format++;
}
}
if (*format == 'l') {
format++;
if (*format == 'l') {
format++;
longlong = True;
}
} else if (*format == 'z') {
format++;
is_sizet = True;
}
switch (*format) {
case 's': {
const HChar* str = va_arg(ap, HChar*);
if (str == NULL)
str = "(null)";
len1 = len3 = 0;
len2 = vex_strlen(str);
if (fwidth > len2) { len1 = ljustify ? 0 : fwidth-len2;
len3 = ljustify ? fwidth-len2 : 0; }
PAD(len1); PUTSTR(str); PAD(len3);
break;
}
case 'c': {
HChar c = (HChar)va_arg(ap, int);
HChar str[2];
str[0] = c;
str[1] = 0;
len1 = len3 = 0;
len2 = vex_strlen(str);
if (fwidth > len2) { len1 = ljustify ? 0 : fwidth-len2;
len3 = ljustify ? fwidth-len2 : 0; }
PAD(len1); PUTSTR(str); PAD(len3);
break;
}
case 'd': {
Long l;
vassert(is_sizet == False); // %zd is obscure; we don't allow it
if (longlong) {
l = va_arg(ap, Long);
} else {
l = (Long)va_arg(ap, Int);
}
convert_int(intbuf, l, 10/*base*/, True/*signed*/,
False/*irrelevant*/);
len1 = len3 = 0;
len2 = vex_strlen(intbuf);
if (fwidth > len2) { len1 = ljustify ? 0 : fwidth-len2;
len3 = ljustify ? fwidth-len2 : 0; }
PAD(len1); PUTSTR(intbuf); PAD(len3);
break;
}
case 'u':
case 'x':
case 'X': {
Int base = *format == 'u' ? 10 : 16;
Bool hexcaps = True; /* *format == 'X'; */
ULong l;
if (is_sizet) {
l = (ULong)va_arg(ap, SizeT);
} else if (longlong) {
l = va_arg(ap, ULong);
} else {
l = (ULong)va_arg(ap, UInt);
}
convert_int(intbuf, l, base, False/*unsigned*/, hexcaps);
len1 = len3 = 0;
len2 = vex_strlen(intbuf);
if (fwidth > len2) { len1 = ljustify ? 0 : fwidth-len2;
len3 = ljustify ? fwidth-len2 : 0; }
PAD(len1); PUTSTR(intbuf); PAD(len3);
break;
}
case 'p':
case 'P': {
Bool hexcaps = toBool(*format == 'P');
ULong l = (Addr)va_arg(ap, void*);
convert_int(intbuf, l, 16/*base*/, False/*unsigned*/, hexcaps);
len1 = len3 = 0;
len2 = vex_strlen(intbuf)+2;
if (fwidth > len2) { len1 = ljustify ? 0 : fwidth-len2;
len3 = ljustify ? fwidth-len2 : 0; }
PAD(len1); PUT('0'); PUT('x'); PUTSTR(intbuf); PAD(len3);
break;
}
case '%': {
PUT('%');
break;
}
default:
/* no idea what it is. Print the format literally and
move on. */
while (saved_format <= format) {
PUT(*saved_format);
saved_format++;
}
break;
}
format++;
}
return nout;
# undef PUT
# undef PAD
# undef PUTSTR
}
/* A general replacement for printf(). Note that only low-level
debugging info should be sent via here. The official route is to
to use vg_message(). This interface is deprecated.
*/
static HChar myprintf_buf[1000];
static Int n_myprintf_buf;
static void add_to_myprintf_buf ( HChar c )
{
Bool emit = toBool(c == '\n' || n_myprintf_buf >= 1000-10 /*paranoia*/);
myprintf_buf[n_myprintf_buf++] = c;
myprintf_buf[n_myprintf_buf] = 0;
if (emit) {
(*vex_log_bytes)( myprintf_buf, vex_strlen(myprintf_buf) );
n_myprintf_buf = 0;
myprintf_buf[n_myprintf_buf] = 0;
}
}
static UInt vex_vprintf ( const HChar* format, va_list vargs )
{
UInt ret;
n_myprintf_buf = 0;
myprintf_buf[n_myprintf_buf] = 0;
ret = vprintf_wrk ( add_to_myprintf_buf, format, vargs );
if (n_myprintf_buf > 0) {
(*vex_log_bytes)( myprintf_buf, n_myprintf_buf );
}
return ret;
}
UInt vex_printf ( const HChar* format, ... )
{
UInt ret;
va_list vargs;
va_start(vargs, format);
ret = vex_vprintf(format, vargs);
va_end(vargs);
return ret;
}
/* Use this function to communicate to users that a (legitimate) situation
occured that we cannot handle (yet). */
__attribute__ ((noreturn))
void vfatal ( const HChar* format, ... )
{
va_list vargs;
va_start(vargs, format);
vex_vprintf( format, vargs );
va_end(vargs);
vex_printf("Cannot continue. Good-bye\n\n");
(*vex_failure_exit)();
}
/* A general replacement for sprintf(). */
static HChar *vg_sprintf_ptr;
static void add_to_vg_sprintf_buf ( HChar c )
{
*vg_sprintf_ptr++ = c;
}
UInt vex_sprintf ( HChar* buf, const HChar *format, ... )
{
Int ret;
va_list vargs;
vg_sprintf_ptr = buf;
va_start(vargs,format);
ret = vprintf_wrk ( add_to_vg_sprintf_buf, format, vargs );
add_to_vg_sprintf_buf(0);
va_end(vargs);
vassert(vex_strlen(buf) == ret);
return ret;
}
/*---------------------------------------------------------*/
/*--- Misaligned memory access support ---*/
/*---------------------------------------------------------*/
UInt read_misaligned_UInt_LE ( void* addr )
{
UChar* p = (UChar*)addr;
UInt w = 0;
w = (w << 8) | p[3];
w = (w << 8) | p[2];
w = (w << 8) | p[1];
w = (w << 8) | p[0];
return w;
}
ULong read_misaligned_ULong_LE ( void* addr )
{
UChar* p = (UChar*)addr;
ULong w = 0;
w = (w << 8) | p[7];
w = (w << 8) | p[6];
w = (w << 8) | p[5];
w = (w << 8) | p[4];
w = (w << 8) | p[3];
w = (w << 8) | p[2];
w = (w << 8) | p[1];
w = (w << 8) | p[0];
return w;
}
void write_misaligned_UInt_LE ( void* addr, UInt w )
{
UChar* p = (UChar*)addr;
p[0] = (w & 0xFF); w >>= 8;
p[1] = (w & 0xFF); w >>= 8;
p[2] = (w & 0xFF); w >>= 8;
p[3] = (w & 0xFF); w >>= 8;
}
void write_misaligned_ULong_LE ( void* addr, ULong w )
{
UChar* p = (UChar*)addr;
p[0] = (w & 0xFF); w >>= 8;
p[1] = (w & 0xFF); w >>= 8;
p[2] = (w & 0xFF); w >>= 8;
p[3] = (w & 0xFF); w >>= 8;
p[4] = (w & 0xFF); w >>= 8;
p[5] = (w & 0xFF); w >>= 8;
p[6] = (w & 0xFF); w >>= 8;
p[7] = (w & 0xFF); w >>= 8;
}
/*---------------------------------------------------------------*/
/*--- end main_util.c ---*/
/*---------------------------------------------------------------*/