Home | History | Annotate | Download | only in priv 
      1 
      2 /*---------------------------------------------------------------*/
      3 /*--- begin                                       main_util.c ---*/
      4 /*---------------------------------------------------------------*/
      5 
      6 /*
      7    This file is part of Valgrind, a dynamic binary instrumentation
      8    framework.
      9 
     10    Copyright (C) 2004-2015 OpenWorks LLP
     11       info (at) open-works.net
     12 
     13    This program is free software; you can redistribute it and/or
     14    modify it under the terms of the GNU General Public License as
     15    published by the Free Software Foundation; either version 2 of the
     16    License, or (at your option) any later version.
     17 
     18    This program is distributed in the hope that it will be useful, but
     19    WITHOUT ANY WARRANTY; without even the implied warranty of
     20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     21    General Public License for more details.
     22 
     23    You should have received a copy of the GNU General Public License
     24    along with this program; if not, write to the Free Software
     25    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     26    02110-1301, USA.
     27 
     28    The GNU General Public License is contained in the file COPYING.
     29 
     30    Neither the names of the U.S. Department of Energy nor the
     31    University of California nor the names of its contributors may be
     32    used to endorse or promote products derived from this software
     33    without prior written permission.
     34 */
     35 
     36 #include "libvex_basictypes.h"
     37 #include "libvex.h"
     38 
     39 #include "main_globals.h"
     40 #include "main_util.h"
     41 
     42 
     43 /*---------------------------------------------------------*/
     44 /*--- Storage                                           ---*/
     45 /*---------------------------------------------------------*/
     46 
     47 /* Try to keep this as low as possible -- in particular, less than the
     48    size of the smallest L2 cache we might encounter.  At 50000, my VIA
     49    Nehemiah 1 GHz (a weedy machine) can satisfy 27 million calls/
     50    second to LibVEX_Alloc(16) -- that is, allocate memory at over 400
     51    MByte/sec.  Once the size increases enough to fall out of the cache
     52    into memory, the rate falls by about a factor of 3.
     53 */
     54 
     55 #define N_TEMPORARY_BYTES 5000000
     56 
     57 static HChar  temporary[N_TEMPORARY_BYTES] __attribute__((aligned(REQ_ALIGN)));
     58 static HChar* temporary_first = &temporary[0];
     59 static HChar* temporary_curr  = &temporary[0];
     60 static HChar* temporary_last  = &temporary[N_TEMPORARY_BYTES-1];
     61 
     62 static ULong  temporary_bytes_allocd_TOT = 0;
     63 
     64 #define N_PERMANENT_BYTES 10000
     65 
     66 static HChar  permanent[N_PERMANENT_BYTES] __attribute__((aligned(REQ_ALIGN)));
     67 static HChar* permanent_first = &permanent[0];
     68 static HChar* permanent_curr  = &permanent[0];
     69 static HChar* permanent_last  = &permanent[N_PERMANENT_BYTES-1];
     70 
     71 HChar* private_LibVEX_alloc_first = &temporary[0];
     72 HChar* private_LibVEX_alloc_curr  = &temporary[0];
     73 HChar* private_LibVEX_alloc_last  = &temporary[N_TEMPORARY_BYTES-1];
     74 
     75 
     76 static VexAllocMode mode = VexAllocModeTEMP;
     77 
     78 void vexAllocSanityCheck ( void )
     79 {
     80    vassert(temporary_first == &temporary[0]);
     81    vassert(temporary_last  == &temporary[N_TEMPORARY_BYTES-1]);
     82    vassert(permanent_first == &permanent[0]);
     83    vassert(permanent_last  == &permanent[N_PERMANENT_BYTES-1]);
     84    vassert(temporary_first <= temporary_curr);
     85    vassert(temporary_curr  <= temporary_last);
     86    vassert(permanent_first <= permanent_curr);
     87    vassert(permanent_curr  <= permanent_last);
     88    vassert(private_LibVEX_alloc_first <= private_LibVEX_alloc_curr);
     89    vassert(private_LibVEX_alloc_curr  <= private_LibVEX_alloc_last);
     90    if (mode == VexAllocModeTEMP){
     91       vassert(private_LibVEX_alloc_first == temporary_first);
     92       vassert(private_LibVEX_alloc_last  == temporary_last);
     93    }
     94    else
     95    if (mode == VexAllocModePERM) {
     96       vassert(private_LibVEX_alloc_first == permanent_first);
     97       vassert(private_LibVEX_alloc_last  == permanent_last);
     98    }
     99    else
    100       vassert(0);
    101 
    102 #  define IS_WORD_ALIGNED(p)   (0 == (((HWord)p) & (sizeof(HWord)-1)))
    103    vassert(sizeof(HWord) == 4 || sizeof(HWord) == 8);
    104    vassert(IS_WORD_ALIGNED(temporary_first));
    105    vassert(IS_WORD_ALIGNED(temporary_curr));
    106    vassert(IS_WORD_ALIGNED(temporary_last+1));
    107    vassert(IS_WORD_ALIGNED(permanent_first));
    108    vassert(IS_WORD_ALIGNED(permanent_curr));
    109    vassert(IS_WORD_ALIGNED(permanent_last+1));
    110    vassert(IS_WORD_ALIGNED(private_LibVEX_alloc_first));
    111    vassert(IS_WORD_ALIGNED(private_LibVEX_alloc_curr));
    112    vassert(IS_WORD_ALIGNED(private_LibVEX_alloc_last+1));
    113 #  undef IS_WORD_ALIGNED
    114 }
    115 
    116 /* The current allocation mode. */
    117 
    118 void vexSetAllocMode ( VexAllocMode m )
    119 {
    120    vexAllocSanityCheck();
    121 
    122    /* Save away the current allocation point .. */
    123    if (mode == VexAllocModeTEMP){
    124       temporary_curr = private_LibVEX_alloc_curr;
    125    }
    126    else
    127    if (mode == VexAllocModePERM) {
    128       permanent_curr = private_LibVEX_alloc_curr;
    129    }
    130    else
    131       vassert(0);
    132 
    133    /* Did that screw anything up? */
    134    vexAllocSanityCheck();
    135 
    136    if (m == VexAllocModeTEMP){
    137       private_LibVEX_alloc_first = temporary_first;
    138       private_LibVEX_alloc_curr  = temporary_curr;
    139       private_LibVEX_alloc_last  = temporary_last;
    140    }
    141    else
    142    if (m == VexAllocModePERM) {
    143       private_LibVEX_alloc_first = permanent_first;
    144       private_LibVEX_alloc_curr  = permanent_curr;
    145       private_LibVEX_alloc_last  = permanent_last;
    146    }
    147    else
    148       vassert(0);
    149 
    150    mode = m;
    151 }
    152 
    153 VexAllocMode vexGetAllocMode ( void )
    154 {
    155    return mode;
    156 }
    157 
    158 __attribute__((noreturn))
    159 void private_LibVEX_alloc_OOM(void)
    160 {
    161    const HChar* pool = "???";
    162    if (private_LibVEX_alloc_first == &temporary[0]) pool = "TEMP";
    163    if (private_LibVEX_alloc_first == &permanent[0]) pool = "PERM";
    164    vex_printf("VEX temporary storage exhausted.\n");
    165    vex_printf("Pool = %s,  start %p curr %p end %p (size %lld)\n",
    166               pool,
    167               private_LibVEX_alloc_first,
    168               private_LibVEX_alloc_curr,
    169               private_LibVEX_alloc_last,
    170               (Long)(private_LibVEX_alloc_last + 1 - private_LibVEX_alloc_first));
    171    vpanic("VEX temporary storage exhausted.\n"
    172           "Increase N_{TEMPORARY,PERMANENT}_BYTES and recompile.");
    173 }
    174 
    175 void vexSetAllocModeTEMP_and_clear ( void )
    176 {
    177    /* vassert(vex_initdone); */ /* causes infinite assert loops */
    178    temporary_bytes_allocd_TOT
    179       += (ULong)(private_LibVEX_alloc_curr - private_LibVEX_alloc_first);
    180 
    181    mode = VexAllocModeTEMP;
    182    temporary_curr            = &temporary[0];
    183    private_LibVEX_alloc_curr = &temporary[0];
    184 
    185    /* Set to (1) and change the fill byte to 0x00 or 0xFF to test for
    186       any potential bugs due to using uninitialised memory in the main
    187       VEX storage area. */
    188    if (0) {
    189       Int i;
    190       for (i = 0; i < N_TEMPORARY_BYTES; i++)
    191          temporary[i] = 0x00;
    192    }
    193 
    194    vexAllocSanityCheck();
    195 }
    196 
    197 
    198 /* Exported to library client. */
    199 
    200 void LibVEX_ShowAllocStats ( void )
    201 {
    202    vex_printf("vex storage: T total %lld bytes allocated\n",
    203               (Long)temporary_bytes_allocd_TOT );
    204    vex_printf("vex storage: P total %lld bytes allocated\n",
    205               (Long)(permanent_curr - permanent_first) );
    206 }
    207 
    208 void *LibVEX_Alloc ( SizeT nbytes )
    209 {
    210    return LibVEX_Alloc_inline(nbytes);
    211 }
    212 
    213 /*---------------------------------------------------------*/
    214 /*--- Bombing out                                       ---*/
    215 /*---------------------------------------------------------*/
    216 
    217 __attribute__ ((noreturn))
    218 void vex_assert_fail ( const HChar* expr,
    219                        const HChar* file, Int line, const HChar* fn )
    220 {
    221    vex_printf( "\nvex: %s:%d (%s): Assertion `%s' failed.\n",
    222                file, line, fn, expr );
    223    (*vex_failure_exit)();
    224 }
    225 
    226 /* To be used in assert-like (i.e. should never ever happen) situations */
    227 __attribute__ ((noreturn))
    228 void vpanic ( const HChar* str )
    229 {
    230    vex_printf("\nvex: the `impossible' happened:\n   %s\n", str);
    231    (*vex_failure_exit)();
    232 }
    233 
    234 
    235 /*---------------------------------------------------------*/
    236 /*--- vex_printf                                        ---*/
    237 /*---------------------------------------------------------*/
    238 
    239 /* This should be the only <...> include in the entire VEX library.
    240    New code for vex_util.c should go above this point. */
    241 #include <stdarg.h>
    242 
    243 SizeT vex_strlen ( const HChar* str )
    244 {
    245    SizeT i = 0;
    246    while (str[i] != 0) i++;
    247    return i;
    248 }
    249 
    250 Bool vex_streq ( const HChar* s1, const HChar* s2 )
    251 {
    252    while (True) {
    253       if (*s1 == 0 && *s2 == 0)
    254          return True;
    255       if (*s1 != *s2)
    256          return False;
    257       s1++;
    258       s2++;
    259    }
    260 }
    261 
    262 void vex_bzero ( void* sV, SizeT n )
    263 {
    264    SizeT i;
    265    UChar* s = (UChar*)sV;
    266    /* No laughing, please.  Just don't call this too often.  Thank you
    267       for your attention. */
    268    for (i = 0; i < n; i++) s[i] = 0;
    269 }
    270 
    271 
    272 /* Convert N0 into ascii in BUF, which is assumed to be big enough (at
    273    least 67 bytes long).  Observe BASE, SYNED and HEXCAPS. */
    274 static
    275 void convert_int ( /*OUT*/HChar* buf, Long n0,
    276                    Int base, Bool syned, Bool hexcaps )
    277 {
    278    ULong u0;
    279    HChar c;
    280    Bool minus = False;
    281    Int i, j, bufi = 0;
    282    buf[bufi] = 0;
    283 
    284    if (syned) {
    285       if (n0 < 0) {
    286          minus = True;
    287          u0 = (ULong)(-n0);
    288       } else {
    289          u0 = (ULong)(n0);
    290       }
    291    } else {
    292       u0 = (ULong)n0;
    293    }
    294 
    295    while (1) {
    296      buf[bufi++] = toHChar('0' + toUInt(u0 % base));
    297      u0 /= base;
    298      if (u0 == 0) break;
    299    }
    300    if (minus)
    301       buf[bufi++] = '-';
    302 
    303    buf[bufi] = 0;
    304    for (i = 0; i < bufi; i++)
    305       if (buf[i] > '9')
    306          buf[i] = toHChar(buf[i] + (hexcaps ? 'A' : 'a') - '9' - 1);
    307 
    308    i = 0;
    309    j = bufi-1;
    310    while (i <= j) {
    311       c = buf[i];
    312       buf[i] = buf[j];
    313       buf[j] = c;
    314       i++;
    315       j--;
    316    }
    317 }
    318 
    319 
    320 /* A half-arsed and buggy, but good-enough, implementation of
    321    printf. */
    322 static
    323 UInt vprintf_wrk ( void(*sink)(HChar),
    324                    const HChar* format,
    325                    va_list ap )
    326 {
    327 #  define PUT(_ch)  \
    328       do { sink(_ch); nout++; } \
    329       while (0)
    330 
    331 #  define PAD(_n) \
    332       do { Int _qq = (_n); for (; _qq > 0; _qq--) PUT(padchar); } \
    333       while (0)
    334 
    335 #  define PUTSTR(_str) \
    336       do { const HChar* _qq = _str; for (; *_qq; _qq++) PUT(*_qq); } \
    337       while (0)
    338 
    339    const HChar* saved_format;
    340    Bool   longlong, ljustify, is_sizet;
    341    HChar  padchar;
    342    Int    fwidth, nout, len1, len3;
    343    SizeT  len2;
    344    HChar  intbuf[100];  /* big enough for a 64-bit # in base 2 */
    345 
    346    nout = 0;
    347    while (1) {
    348 
    349       if (!format)
    350          break;
    351       if (*format == 0)
    352          break;
    353 
    354       if (*format != '%') {
    355          PUT(*format);
    356          format++;
    357          continue;
    358       }
    359 
    360       saved_format = format;
    361       longlong = is_sizet = False;
    362       ljustify = False;
    363       padchar = ' ';
    364       fwidth = 0;
    365       format++;
    366 
    367       if (*format == '-') {
    368          format++;
    369          ljustify = True;
    370       }
    371       if (*format == '0') {
    372          format++;
    373          padchar = '0';
    374       }
    375       if (*format == '*') {
    376          fwidth = va_arg(ap, Int);
    377          vassert(fwidth >= 0);
    378          format++;
    379       } else {
    380          while (*format >= '0' && *format <= '9') {
    381             fwidth = fwidth * 10 + (*format - '0');
    382             format++;
    383          }
    384       }
    385       if (*format == 'l') {
    386          format++;
    387          if (*format == 'l') {
    388             format++;
    389             longlong = True;
    390          }
    391       } else if (*format == 'z') {
    392          format++;
    393          is_sizet = True;
    394       }
    395 
    396       switch (*format) {
    397          case 's': {
    398             const HChar* str = va_arg(ap, HChar*);
    399             if (str == NULL)
    400                str = "(null)";
    401             len1 = len3 = 0;
    402             len2 = vex_strlen(str);
    403             if (fwidth > len2) { len1 = ljustify ? 0 : fwidth-len2;
    404                                  len3 = ljustify ? fwidth-len2 : 0; }
    405             PAD(len1); PUTSTR(str); PAD(len3);
    406             break;
    407          }
    408          case 'c': {
    409             HChar c = (HChar)va_arg(ap, int);
    410             HChar str[2];
    411             str[0] = c;
    412             str[1] = 0;
    413             len1 = len3 = 0;
    414             len2 = vex_strlen(str);
    415             if (fwidth > len2) { len1 = ljustify ? 0 : fwidth-len2;
    416                                  len3 = ljustify ? fwidth-len2 : 0; }
    417             PAD(len1); PUTSTR(str); PAD(len3);
    418             break;
    419          }
    420          case 'd': {
    421             Long l;
    422             vassert(is_sizet == False); // %zd is obscure; we don't allow it
    423             if (longlong) {
    424                l = va_arg(ap, Long);
    425             } else {
    426                l = (Long)va_arg(ap, Int);
    427             }
    428             convert_int(intbuf, l, 10/*base*/, True/*signed*/,
    429                                 False/*irrelevant*/);
    430             len1 = len3 = 0;
    431             len2 = vex_strlen(intbuf);
    432             if (fwidth > len2) { len1 = ljustify ? 0 : fwidth-len2;
    433                                  len3 = ljustify ? fwidth-len2 : 0; }
    434             PAD(len1); PUTSTR(intbuf); PAD(len3);
    435             break;
    436          }
    437          case 'u':
    438          case 'x':
    439          case 'X': {
    440             Int   base = *format == 'u' ? 10 : 16;
    441             Bool  hexcaps = True; /* *format == 'X'; */
    442             ULong l;
    443             if (is_sizet) {
    444                l = (ULong)va_arg(ap, SizeT);
    445             } else if (longlong) {
    446                l = va_arg(ap, ULong);
    447             } else {
    448                l = (ULong)va_arg(ap, UInt);
    449             }
    450             convert_int(intbuf, l, base, False/*unsigned*/, hexcaps);
    451             len1 = len3 = 0;
    452             len2 = vex_strlen(intbuf);
    453             if (fwidth > len2) { len1 = ljustify ? 0 : fwidth-len2;
    454                                  len3 = ljustify ? fwidth-len2 : 0; }
    455             PAD(len1); PUTSTR(intbuf); PAD(len3);
    456             break;
    457          }
    458          case 'p':
    459          case 'P': {
    460             Bool hexcaps = toBool(*format == 'P');
    461             ULong l = (Addr)va_arg(ap, void*);
    462             convert_int(intbuf, l, 16/*base*/, False/*unsigned*/, hexcaps);
    463             len1 = len3 = 0;
    464             len2 = vex_strlen(intbuf)+2;
    465             if (fwidth > len2) { len1 = ljustify ? 0 : fwidth-len2;
    466                                  len3 = ljustify ? fwidth-len2 : 0; }
    467             PAD(len1); PUT('0'); PUT('x'); PUTSTR(intbuf); PAD(len3);
    468             break;
    469          }
    470          case '%': {
    471             PUT('%');
    472             break;
    473          }
    474          default:
    475             /* no idea what it is.  Print the format literally and
    476                move on. */
    477             while (saved_format <= format) {
    478                PUT(*saved_format);
    479                saved_format++;
    480             }
    481             break;
    482       }
    483 
    484       format++;
    485 
    486    }
    487 
    488    return nout;
    489 
    490 #  undef PUT
    491 #  undef PAD
    492 #  undef PUTSTR
    493 }
    494 
    495 
    496 /* A general replacement for printf().  Note that only low-level
    497    debugging info should be sent via here.  The official route is to
    498    to use vg_message().  This interface is deprecated.
    499 */
    500 static HChar myprintf_buf[1000];
    501 static Int   n_myprintf_buf;
    502 
    503 static void add_to_myprintf_buf ( HChar c )
    504 {
    505    Bool emit = toBool(c == '\n' || n_myprintf_buf >= 1000-10 /*paranoia*/);
    506    myprintf_buf[n_myprintf_buf++] = c;
    507    myprintf_buf[n_myprintf_buf] = 0;
    508    if (emit) {
    509       (*vex_log_bytes)( myprintf_buf, vex_strlen(myprintf_buf) );
    510       n_myprintf_buf = 0;
    511       myprintf_buf[n_myprintf_buf] = 0;
    512    }
    513 }
    514 
    515 static UInt vex_vprintf ( const HChar* format, va_list vargs )
    516 {
    517    UInt ret;
    518 
    519    n_myprintf_buf = 0;
    520    myprintf_buf[n_myprintf_buf] = 0;
    521    ret = vprintf_wrk ( add_to_myprintf_buf, format, vargs );
    522 
    523    if (n_myprintf_buf > 0) {
    524       (*vex_log_bytes)( myprintf_buf, n_myprintf_buf );
    525    }
    526 
    527    return ret;
    528 }
    529 
    530 UInt vex_printf ( const HChar* format, ... )
    531 {
    532    UInt ret;
    533    va_list vargs;
    534    va_start(vargs, format);
    535    ret = vex_vprintf(format, vargs);
    536    va_end(vargs);
    537 
    538    return ret;
    539 }
    540 
    541 /* Use this function to communicate to users that a (legitimate) situation
    542    occured that we cannot handle (yet). */
    543 __attribute__ ((noreturn))
    544 void vfatal ( const HChar* format, ... )
    545 {
    546    va_list vargs;
    547    va_start(vargs, format);
    548    vex_vprintf( format, vargs );
    549    va_end(vargs);
    550    vex_printf("Cannot continue. Good-bye\n\n");
    551 
    552    (*vex_failure_exit)();
    553 }
    554 
    555 /* A general replacement for sprintf(). */
    556 
    557 static HChar *vg_sprintf_ptr;
    558 
    559 static void add_to_vg_sprintf_buf ( HChar c )
    560 {
    561    *vg_sprintf_ptr++ = c;
    562 }
    563 
    564 UInt vex_sprintf ( HChar* buf, const HChar *format, ... )
    565 {
    566    Int ret;
    567    va_list vargs;
    568 
    569    vg_sprintf_ptr = buf;
    570 
    571    va_start(vargs,format);
    572 
    573    ret = vprintf_wrk ( add_to_vg_sprintf_buf, format, vargs );
    574    add_to_vg_sprintf_buf(0);
    575 
    576    va_end(vargs);
    577 
    578    vassert(vex_strlen(buf) == ret);
    579    return ret;
    580 }
    581 
    582 
    583 /*---------------------------------------------------------*/
    584 /*--- Misaligned memory access support                  ---*/
    585 /*---------------------------------------------------------*/
    586 
    587 UInt read_misaligned_UInt_LE ( void* addr )
    588 {
    589    UChar* p = (UChar*)addr;
    590    UInt   w = 0;
    591    w = (w << 8) | p[3];
    592    w = (w << 8) | p[2];
    593    w = (w << 8) | p[1];
    594    w = (w << 8) | p[0];
    595    return w;
    596 }
    597 
    598 ULong read_misaligned_ULong_LE ( void* addr )
    599 {
    600    UChar* p = (UChar*)addr;
    601    ULong  w = 0;
    602    w = (w << 8) | p[7];
    603    w = (w << 8) | p[6];
    604    w = (w << 8) | p[5];
    605    w = (w << 8) | p[4];
    606    w = (w << 8) | p[3];
    607    w = (w << 8) | p[2];
    608    w = (w << 8) | p[1];
    609    w = (w << 8) | p[0];
    610    return w;
    611 }
    612 
    613 void write_misaligned_UInt_LE ( void* addr, UInt w )
    614 {
    615    UChar* p = (UChar*)addr;
    616    p[0] = (w & 0xFF); w >>= 8;
    617    p[1] = (w & 0xFF); w >>= 8;
    618    p[2] = (w & 0xFF); w >>= 8;
    619    p[3] = (w & 0xFF); w >>= 8;
    620 }
    621 
    622 void write_misaligned_ULong_LE ( void* addr, ULong w )
    623 {
    624    UChar* p = (UChar*)addr;
    625    p[0] = (w & 0xFF); w >>= 8;
    626    p[1] = (w & 0xFF); w >>= 8;
    627    p[2] = (w & 0xFF); w >>= 8;
    628    p[3] = (w & 0xFF); w >>= 8;
    629    p[4] = (w & 0xFF); w >>= 8;
    630    p[5] = (w & 0xFF); w >>= 8;
    631    p[6] = (w & 0xFF); w >>= 8;
    632    p[7] = (w & 0xFF); w >>= 8;
    633 }
    634 
    635 
    636 /*---------------------------------------------------------------*/
    637 /*--- end                                         main_util.c ---*/
    638 /*---------------------------------------------------------------*/
    639