* them.
*/
-static __inline__ void cpuid(Int n, Int *a, Int *b, Int *c, Int *d)
+static __inline__ void cpuid(Int n, UInt *a, UInt *b, UInt *c, UInt *d)
{
__asm__ __volatile__ (
"cpuid"
static
Int AMD_cache_info(cache_t* I1c, cache_t* D1c, cache_t* L2c)
{
- Int dummy, model, ext_level;
+ UInt ext_level;
+ Int dummy, model;
Int I1i, D1i, L2i;
cpuid(0x80000000, &ext_level, &dummy, &dummy, &dummy);
len = strlen (*mangled);
- for (i = 0; i < ARRAY_SIZE (optable); ++i)
+ for (i = 0; i < (size_t)ARRAY_SIZE (optable); ++i)
{
size_t l = strlen (optable[i].in);
if (declp->p - declp->b >= 10 /* op$assign_ */
&& memcmp (declp->b + 3, "assign_", 7) == 0)
{
- for (i = 0; i < ARRAY_SIZE (optable); i++)
+ for (i = 0; i < (size_t)ARRAY_SIZE (optable); i++)
{
int len = declp->p - declp->b - 10;
if ((int) strlen (optable[i].in) == len
}
else
{
- for (i = 0; i < ARRAY_SIZE (optable); i++)
+ for (i = 0; i < (size_t)ARRAY_SIZE (optable); i++)
{
int len = declp->p - declp->b - 3;
if ((int) strlen (optable[i].in) == len
if (declp->b[4] == '\0')
{
/* Operator. */
- for (i = 0; i < ARRAY_SIZE (optable); i++)
+ for (i = 0; i < (size_t)ARRAY_SIZE (optable); i++)
{
if (strlen (optable[i].in) == 2
&& memcmp (optable[i].in, declp->b + 2, 2) == 0)
if (declp->b[2] == 'a' && declp->b[5] == '\0')
{
/* Assignment. */
- for (i = 0; i < ARRAY_SIZE (optable); i++)
+ for (i = 0; i < (size_t)ARRAY_SIZE (optable); i++)
{
if (strlen (optable[i].in) == 3
&& memcmp (optable[i].in, declp->b + 2, 3) == 0)
void VG_(gen_suppression)(Error* err)
{
- UInt i;
+ Int i;
UChar buf[M_VG_ERRTXT];
ExeContext* ec = VG_(get_error_where)(err);
Int stop_at = VG_(clo_backtrace_size);
histogram[i].counts, count_pc,
avg_size, size_pc);
- for (j = 0; j < size_pc; j++) VG_(printf)("O");
+ for (j = 0; j < (Int)size_pc; j++) VG_(printf)("O");
VG_(printf)("\n");
} else {
* Searches through compacts first, then non-compacts. */
Int VG_(helper_offset)(Addr a)
{
- Int i;
+ UInt i;
Char buf[100];
for (i = 0; i < VG_(n_compact_helpers); i++)
int VGR_(poll) (struct pollfd *__fds, nfds_t __nfds, int __timeout)
{
- unsigned int ms_now, ms_end;
- int res, i;
+ unsigned int ms_now, ms_end, i;
+ int res;
struct vki_timespec nanosleep_interval;
__my_pthread_testcancel();
}
/* Allocate offsets in baseBlock for the skin helpers */
-static void assign_helpers_in_baseBlock(UInt n, Int offsets[], Addr addrs[])
+static
+void assign_helpers_in_baseBlock(UInt n, Int offsets[], Addr addrs[])
{
- Int i;
- for (i = 0; i < n; i++) offsets[i] = alloc_BaB_1_set( addrs[i] );
+ UInt i;
+ for (i = 0; i < n; i++)
+ offsets[i] = alloc_BaB_1_set( addrs[i] );
}
Bool VG_(need_to_handle_esp_assignment)(void)
static void process_cmd_line_options ( void )
{
Char* argv[M_VG_CMDLINE_OPTS];
- UInt argc;
+ Int argc;
Char* p;
Char* str;
Int i, eventually_logfile_fd, ctr;
envc & envp. It is not fool-proof, but these structures should
change less often than the libc ones. */
{
- UInt* sp;
+ Int* sp;
/* Look for the stack segment by parsing /proc/self/maps and
looking for a section bracketing VG_(esp_at_startup) which
static
void splitChunk ( Arena* a, UInt* b, Int b_listno, UInt req_bszW )
{
- Int b_bszW, frag_bszW;
- b_bszW = mk_plain_bszW(get_bszW_lo(b));
+ UInt b_bszW;
+ Int frag_bszW;
+ b_bszW = (UInt)mk_plain_bszW(get_bszW_lo(b));
vg_assert(req_bszW < b_bszW);
frag_bszW = b_bszW - req_bszW;
vg_assert(frag_bszW >= overhead_szW(a));
Int i;
vg_assert(set != NULL);
for (i = 0; i < VKI_KNSIG_WORDS; i++)
- if (set->ws[i] != ~0x0) return False;
+ if (set->ws[i] != (UInt)(~0x0)) return False;
return True;
}
/* A general replacement for sprintf(). */
UInt VG_(sprintf) ( Char* buf, Char *format, ... )
{
- UInt ret;
+ Int ret;
va_list vargs;
Char *ptr = buf;
static void add_to_vg_sprintf_buf ( Char c )
vg_assert(base >= 2 && base <= 36);
if (*str == '-') { str++; neg = True; };
while (True) {
- if (*str >= '0' && *str <=('9' - (10 - base))) {
+ if (*str >= '0'
+ && *str <= (Char)('9' - (10 - base))) {
n = base*n + (Long)(*str - '0');
}
else
- if (base > 10 && *str >= 'A' && *str <= ('Z' - (36 - base))) {
+ if (base > 10 && *str >= 'A'
+ && *str <= (Char)('Z' - (36 - base))) {
n = base*n + (Long)((*str - 'A') + 10);
}
else
- if (base > 10 && *str >= 'a' && *str <= ('z' - (36 - base))) {
+ if (base > 10 && *str >= 'a'
+ && *str <= (Char)('z' - (36 - base))) {
n = base*n + (Long)((*str - 'a') + 10);
}
else {
struct mallinfo mallinfo ( void )
{
/* Should really try to return something a bit more meaningful */
- Int i;
+ UInt i;
struct mallinfo mi;
UChar* pmi = (UChar*)(&mi);
for (i = 0; i < sizeof(mi); i++)
/* File descriptor waited for. -1 means this slot is not in use */
Int fd;
/* The syscall number the fd is used in. */
- Int syscall_no;
+ UInt syscall_no;
/* False => still waiting for select to tell us the fd is ready
to go. True => the fd is ready, but the results have not yet
static
void complete_blocked_syscalls ( void )
{
- Int fd, i, res, syscall_no;
+ Int fd, i, res;
+ UInt syscall_no;
void* pre_res;
ThreadId tid;
Char msg_buf[100];
static
void check_for_pthread_cond_timedwait ( void )
{
- Int i, now;
+ Int i;
+ UInt now;
for (i = 1; i < VG_N_THREADS; i++) {
if (VG_(threads)[i].status != VgTs_WaitCV)
continue;
/* 1 */ vg_assert(mx != NULL);
/* 2 */ vg_assert(mx->__m_count > 0);
/* 3 */ vg_assert(VG_(is_valid_tid)((ThreadId)mx->__m_owner));
- /* 4 */ vg_assert(i != (ThreadId)mx->__m_owner);
+ /* 4 */ vg_assert((UInt)i != (ThreadId)mx->__m_owner);
} else
if (VG_(threads)[i].status == VgTs_WaitCV) {
vg_assert(cv != NULL);
static SegInfo* curr_si = NULL;
Char* new_tab;
- Int new_sz, i, space_needed;
+ Int space_needed, i;
+ UInt new_sz, u;
/* Avoid gratuitous duplication: if we saw `str' within the last NN,
* within this segment, return that index. Saves about 200KB in glibc,
if (new_sz == 0) new_sz = 5000;
new_tab = VG_(arena_malloc)(VG_AR_SYMTAB, new_sz);
if (si->strtab != NULL) {
- for (i = 0; i < si->strtab_used; i++)
- new_tab[i] = si->strtab[i];
+ for (u = 0; u < si->strtab_used; u++)
+ new_tab[u] = si->strtab[u];
VG_(arena_free)(VG_AR_SYMTAB, si->strtab);
}
si->strtab = new_tab;
static __inline__
void addSym ( SegInfo* si, RiSym* sym )
{
- Int new_sz, i;
+ UInt new_sz, i;
RiSym* new_tab;
/* Ignore zero-sized syms. */
static __inline__
void addLoc ( SegInfo* si, RiLoc* loc )
{
- Int new_sz, i;
+ UInt new_sz, i;
RiLoc* new_tab;
/* Zero-sized locs should have been ignored earlier */
/* Detect and "fix" overlapping address ranges. */
n_truncated = 0;
- for (i = 0; i < si->symtab_used-1; i++) {
+ for (i = 0; i < ((Int)si->symtab_used) -1; i++) {
vg_assert(si->symtab[i].addr <= si->symtab[i+1].addr);
/* It may be that the i+1 entry now needs to be moved further
along to maintain the address order requirement. */
j = i+1;
- while (j < si->symtab_used-1
+ while (j < ((Int)si->symtab_used)-1
&& si->symtab[j].addr > si->symtab[j+1].addr) {
SWAP(RiSym,si->symtab[j],si->symtab[j+1]);
j++;
if (n_truncated > 0) goto cleanup_more;
/* Ensure relevant postconditions hold. */
- for (i = 0; i < si->symtab_used-1; i++) {
+ for (i = 0; i < ((Int)si->symtab_used)-1; i++) {
/* No zero-sized symbols. */
vg_assert(si->symtab[i].size > 0);
/* In order. */
}
/* If two adjacent entries overlap, truncate the first. */
- for (i = 0; i < si->loctab_used-1; i++) {
+ for (i = 0; i < ((Int)si->loctab_used)-1; i++) {
vg_assert(si->loctab[i].size < 10000);
if (si->loctab[i].addr + si->loctab[i].size > si->loctab[i+1].addr) {
/* Do this in signed int32 because the actual .size fields
/* Zap any zero-sized entries resulting from the truncation
process. */
j = 0;
- for (i = 0; i < si->loctab_used; i++) {
+ for (i = 0; i < (Int)si->loctab_used; i++) {
if (si->loctab[i].size > 0) {
si->loctab[j] = si->loctab[i];
j++;
si->loctab_used = j;
/* Ensure relevant postconditions hold. */
- for (i = 0; i < si->loctab_used-1; i++) {
+ for (i = 0; i < ((Int)si->loctab_used)-1; i++) {
/*
VG_(printf)("%d (%d) %d 0x%x\n",
i, si->loctab[i+1].confident,
break;
}
- if (info.li_length + sizeof (external->li_length) > dwarf2_sz)
+ if (info.li_length + sizeof (external->li_length) > (UInt)dwarf2_sz)
{
vg_symerr("DWARF line info appears to be corrupt "
"- the section is too small");
Int i;
Bool ok;
Addr oimage;
- Int n_oimage;
+ UInt n_oimage;
struct vki_stat stat_buf;
oimage = (Addr)NULL;
/* Perhaps should start at i = 1; ELF docs suggest that entry
0 always denotes `unknown symbol'. */
- for (i = 1; i < o_symtab_sz/sizeof(Elf32_Sym); i++){
+ for (i = 1; i < (Int)(o_symtab_sz/sizeof(Elf32_Sym)); i++){
# if 1
if (VG_(clo_trace_symtab)) {
VG_(printf)("raw symbol [%d]: ", i);
len = VG_(sprintf)(buf2, "%c%d",
offset < 0 ? '-' : '+',
offset < 0 ? -offset : offset);
- vg_assert(len < sizeof(buf2));
+ vg_assert(len < (Int)sizeof(buf2));
if (len < (end - symend)) {
Char *cp = buf2;
VG_(message)(Vg_UserMsg, "%s", buf);
i++;
- } while (i < stop_at && ec->eips[i] != 0);
+ } while (i < (UInt)stop_at && ec->eips[i] != 0);
}
#undef APPEND
MAYBE_PRINTF("close ( %d )\n",arg1);
/* Detect and negate attempts by the client to close Valgrind's
logfile fd ... */
- if (arg1 == VG_(clo_logfile_fd)) {
+ if (arg1 == (UInt)VG_(clo_logfile_fd)) {
VG_(message)(Vg_UserMsg,
"Warning: client attempted to close "
"Valgrind's logfile fd (%d).",
arg1, arg2 * sizeof(struct pollfd) );
KERNEL_DO_SYSCALL(tid,res);
if (!VG_(is_kerror)(res) && res > 0) {
- Int i;
+ UInt i;
struct pollfd * arr = (struct pollfd *)arg1;
for (i = 0; i < arg2; i++)
VG_TRACK( post_mem_write, (Addr)(&arr[i].revents),
UInstr* u;
Int delta = 0;
UInt t_ESP = INVALID_TEMPREG;
- UInt i;
+ Int i;
cb = VG_(setup_UCodeBlock)(cb_in);
/* make sure no other blocks chain to the one we just discarded */
for(j = 0; j < VG_TC_N_SECTORS; j++) {
if (vg_tc[j] != NULL)
- unchain_sector(j, tce->payload, tce->trans_size);
+ unchain_sector(j, (Addr)tce->payload, tce->trans_size);
}
}
struct _HG_Chunk {
struct _HG_Chunk* next;
Addr data; /* ptr to actual block */
- UInt size; /* size requested */
+ Int size; /* size requested */
ExeContext* where; /* where it was allocated */
ThreadId tid; /* allocating thread */
}
}
struct _LockSet {
- UInt setsize; /* number of members */
+ Int setsize; /* number of members */
UInt hash; /* hash code */
LockSet *next; /* next in hash chain */
const Mutex *mutex[0]; /* locks */
static
void pp_LockSet(const LockSet* p)
{
- int i;
-
+ Int i;
VG_(printf)("{ ");
for(i = 0; i < p->setsize; i++) {
const Mutex *mx = p->mutex[i];
const Mutex *with,
const Mutex *without)
{
- UInt i;
+ Int i;
UInt hash = ls->setsize + (with != NULL) - (without != NULL);
sk_assert(with == NULL || with != without);
badness = "mismatched hash";
goto bad;
}
- if (ls->hash != i) {
+ if (ls->hash != (UInt)i) {
badness = "wrong bucket";
goto bad;
}
{
HG_Chunk *hc;
HG_Chunk **prev_chunks_next_ptr;
- UInt i;
+ Int i;
/* First try and find the block. */
hc = (HG_Chunk*)VG_(HT_get_node) ( hg_malloc_list, (UInt)p,
Bool SK_(error_matches_suppression)(Error* err, Supp* su)
{
- UInt su_size;
+ Int su_size;
MAC_Error* err_extra = VG_(get_error_extra)(err);
ErrorKind ekind = VG_(get_error_kind )(err);
static
Int vg_alloc_client_block ( void )
{
- Int i, sz_new;
+ UInt i, sz_new;
CGenBlock* cgbs_new;
vg_cgb_allocs++;
Bool MC_(client_perm_maybe_describe)( Addr a, AddrInfo* ai )
{
- Int i;
+ UInt i;
/* VG_(printf)("try to identify %d\n", a); */
/* Perhaps it's a general block ? */
if (diff < 0)
diff = -diff;
-
- return (diff < len);
+ /* Now we have diff >= 0, so a cast to UInt is harmless. */
+ return ( ((UInt)diff) < len);
}
static __inline__
projects / thirdparty / valgrind.git / commitdiff
