Avoid variable name "new", use more concrete name instead

Also confusing for syntax highlighter/indexer of some editors/IDEs

git-svn-id: svn://svn.valgrind.org/valgrind/trunk@10320 a5019735-40e9-0310-863c-91ae7b9d1cf9

8 files changed, 170 insertions, 170 deletions

diff --git a/callgrind/bb.c b/callgrind/bb.c
index a14b11e9..3b8d1e80 100644
--- a/callgrind/bb.c
+++ b/callgrind/bb.c
@@ -121,8 +121,8 @@ void resize_bb_table(void)
 static BB* new_bb(obj_node* obj, PtrdiffT offset,
 		  UInt instr_count, UInt cjmp_count, Bool cjmp_inverted)
 {
-   BB* new;
-   UInt new_idx, size;
+   BB* bb;
+   UInt idx, size;
 
    /* check fill degree of bb hash table and resize if needed (>80%) */
    bbs.entries++;
@@ -131,29 +131,29 @@ static BB* new_bb(obj_node* obj, PtrdiffT offset,
 
    size = sizeof(BB) + instr_count * sizeof(InstrInfo)
                      + (cjmp_count+1) * sizeof(CJmpInfo);
-   new = (BB*) CLG_MALLOC("cl.bb.nb.1", size);
-   VG_(memset)(new, 0, size);
+   bb = (BB*) CLG_MALLOC("cl.bb.nb.1", size);
+   VG_(memset)(bb, 0, size);
 
-   new->obj        = obj;
-   new->offset     = offset;
+   bb->obj        = obj;
+   bb->offset     = offset;
    
-   new->instr_count = instr_count;
-   new->cjmp_count  = cjmp_count;
-   new->cjmp_inverted = cjmp_inverted;
-   new->jmp         = (CJmpInfo*) &(new->instr[instr_count]);
-   new->instr_len   = 0;
-   new->cost_count  = 0;
-   new->sect_kind   = VG_(seginfo_sect_kind)(NULL, 0, offset + obj->offset);
-   new->fn          = 0;
-   new->line        = 0;
-   new->is_entry    = 0;
-   new->bbcc_list   = 0;
-   new->last_bbcc   = 0;
+   bb->instr_count = instr_count;
+   bb->cjmp_count  = cjmp_count;
+   bb->cjmp_inverted = cjmp_inverted;
+   bb->jmp         = (CJmpInfo*) &(bb->instr[instr_count]);
+   bb->instr_len   = 0;
+   bb->cost_count  = 0;
+   bb->sect_kind   = VG_(seginfo_sect_kind)(NULL, 0, offset + obj->offset);
+   bb->fn          = 0;
+   bb->line        = 0;
+   bb->is_entry    = 0;
+   bb->bbcc_list   = 0;
+   bb->last_bbcc   = 0;
 
    /* insert into BB hash table */
-   new_idx = bb_hash_idx(obj, offset, bbs.size);
-   new->next = bbs.table[new_idx];
-   bbs.table[new_idx] = new;
+   idx = bb_hash_idx(obj, offset, bbs.size);
+   bb->next = bbs.table[idx];
+   bbs.table[idx] = bb;
 
    CLG_(stat).distinct_bbs++;
 
@@ -163,14 +163,14 @@ static BB* new_bb(obj_node* obj, PtrdiffT offset,
 		 instr_count, cjmp_count,
 		 cjmp_inverted ? "yes":"no",
 		 CLG_(stat).distinct_bbs);
-      CLG_(print_bb)(0, new);
+      CLG_(print_bb)(0, bb);
       VG_(printf)("\n");
    }
 #endif
 
-   CLG_(get_fn_node)(new);
+   CLG_(get_fn_node)(bb);
 
-   return new;
+   return bb;
 }
 
 
diff --git a/callgrind/bbcc.c b/callgrind/bbcc.c
index c1eaab38..dfe737b2 100644
--- a/callgrind/bbcc.c
+++ b/callgrind/bbcc.c
@@ -247,13 +247,13 @@ BBCC** new_recursion(int size)
 {
     BBCC** bbccs;
     int i;
-    
+
     bbccs = (BBCC**) CLG_MALLOC("cl.bbcc.nr.1", sizeof(BBCC*) * size);
     for(i=0;i<size;i++)
 	bbccs[i] = 0;
 
     CLG_DEBUG(3,"  new_recursion(size %d): %p\n", size, bbccs);
-    
+
     return bbccs;
 }
   
@@ -267,40 +267,40 @@ BBCC** new_recursion(int size)
 static __inline__ 
 BBCC* new_bbcc(BB* bb)
 {
-   BBCC* new;
+   BBCC* bbcc;
    Int i;
 
    /* We need cjmp_count+1 JmpData structs:
     * the last is for the unconditional jump/call/ret at end of BB
     */
-   new = (BBCC*)CLG_MALLOC("cl.bbcc.nb.1",
-                           sizeof(BBCC) +
-			   (bb->cjmp_count+1) * sizeof(JmpData));
-   new->bb  = bb;
-   new->tid = CLG_(current_tid);
-
-   new->ret_counter = 0;
-   new->skipped = 0;
-   new->cost = CLG_(get_costarray)(bb->cost_count);
+   bbcc = (BBCC*)CLG_MALLOC("cl.bbcc.nb.1",
+			    sizeof(BBCC) +
+			    (bb->cjmp_count+1) * sizeof(JmpData));
+   bbcc->bb  = bb;
+   bbcc->tid = CLG_(current_tid);
+
+   bbcc->ret_counter = 0;
+   bbcc->skipped = 0;
+   bbcc->cost = CLG_(get_costarray)(bb->cost_count);
    for(i=0;i<bb->cost_count;i++)
-     new->cost[i] = 0;
+     bbcc->cost[i] = 0;
    for(i=0; i<=bb->cjmp_count; i++) {
-       new->jmp[i].ecounter = 0;
-       new->jmp[i].jcc_list = 0;
+       bbcc->jmp[i].ecounter = 0;
+       bbcc->jmp[i].jcc_list = 0;
    }
-   new->ecounter_sum = 0;
+   bbcc->ecounter_sum = 0;
 
    /* Init pointer caches (LRU) */
-   new->lru_next_bbcc = 0;
-   new->lru_from_jcc  = 0;
-   new->lru_to_jcc  = 0;
+   bbcc->lru_next_bbcc = 0;
+   bbcc->lru_from_jcc  = 0;
+   bbcc->lru_to_jcc  = 0;
    
    CLG_(stat).distinct_bbccs++;
 
    CLG_DEBUG(3, "  new_bbcc(BB %#lx): %p (now %d)\n",
-	    bb_addr(bb), new, CLG_(stat).distinct_bbccs);
+	    bb_addr(bb), bbcc, CLG_(stat).distinct_bbccs);
 
-   return new;
+   return bbcc;
 }
 
 
@@ -369,12 +369,12 @@ static Char* mangled_cxt(Context* cxt, int rec_index)
  */
 static BBCC* clone_bbcc(BBCC* orig, Context* cxt, Int rec_index)
 {
-    BBCC*      new;
+    BBCC* bbcc;
 
     CLG_DEBUG(3,"+ clone_bbcc(BB %#lx, rec %d, fn %s)\n",
 	     bb_addr(orig->bb), rec_index, cxt->fn[0]->name);
 
-    new  = new_bbcc(orig->bb);
+    bbcc = new_bbcc(orig->bb);
 
     if (rec_index == 0) {
 
@@ -382,12 +382,12 @@ static BBCC* clone_bbcc(BBCC* orig, Context* cxt, Int rec_index)
       CLG_ASSERT((orig->tid != CLG_(current_tid)) ||
 		(orig->cxt != cxt));
 
-      new->rec_index = 0;
-      new->cxt = cxt;
-      new->rec_array = new_recursion(cxt->fn[0]->separate_recursions);
-      new->rec_array[0] = new;
+      bbcc->rec_index = 0;
+      bbcc->cxt = cxt;
+      bbcc->rec_array = new_recursion(cxt->fn[0]->separate_recursions);
+      bbcc->rec_array[0] = bbcc;
 
-      insert_bbcc_into_hash(new);
+      insert_bbcc_into_hash(bbcc);
     }
     else {
       if (CLG_(clo).separate_threads)
@@ -399,30 +399,30 @@ static BBCC* clone_bbcc(BBCC* orig, Context* cxt, Int rec_index)
       CLG_ASSERT(orig->rec_array[rec_index] ==0);
 
       /* new BBCC will only have differing recursion level */
-      new->rec_index = rec_index;
-      new->cxt = cxt;
-      new->rec_array = orig->rec_array;
-      new->rec_array[rec_index] = new;
+      bbcc->rec_index = rec_index;
+      bbcc->cxt = cxt;
+      bbcc->rec_array = orig->rec_array;
+      bbcc->rec_array[rec_index] = bbcc;
     }
 
     /* update list of BBCCs for same BB */
-    new->next_bbcc = orig->bb->bbcc_list;
-    orig->bb->bbcc_list = new;
+    bbcc->next_bbcc = orig->bb->bbcc_list;
+    orig->bb->bbcc_list = bbcc;
 
 
     CLG_DEBUGIF(3)
-      CLG_(print_bbcc)(-2, new);
+      CLG_(print_bbcc)(-2, bbcc);
 
     CLG_DEBUG(2,"- clone_BBCC(%p, %d) for BB %#lx\n"
 		"   orig %s\n"
 		"   new  %s\n",
 	     orig, rec_index, bb_addr(orig->bb),
 	     mangled_cxt(orig->cxt, orig->rec_index),
-	     mangled_cxt(new->cxt, new->rec_index));
+	     mangled_cxt(bbcc->cxt, bbcc->rec_index));
 
     CLG_(stat).bbcc_clones++;
  
-    return new;
+    return bbcc;
 };
 
 
diff --git a/callgrind/clo.c b/callgrind/clo.c
index b5324833..881f3ea1 100644
--- a/callgrind/clo.c
+++ b/callgrind/clo.c
@@ -98,24 +98,24 @@ static config_node* fn_configs = 0;
 static __inline__ 
 fn_config* new_fnc(void)
 {
-   fn_config* new = (fn_config*) CLG_MALLOC("cl.clo.nf.1",
+   fn_config* fnc = (fn_config*) CLG_MALLOC("cl.clo.nf.1",
                                             sizeof(fn_config));
 
-   new->dump_before  = CONFIG_DEFAULT;
-   new->dump_after   = CONFIG_DEFAULT;
-   new->zero_before  = CONFIG_DEFAULT;
-   new->toggle_collect = CONFIG_DEFAULT;
-   new->skip         = CONFIG_DEFAULT;
-   new->pop_on_jump  = CONFIG_DEFAULT;
-   new->group        = CONFIG_DEFAULT;
-   new->separate_callers    = CONFIG_DEFAULT;
-   new->separate_recursions = CONFIG_DEFAULT;
+   fnc->dump_before  = CONFIG_DEFAULT;
+   fnc->dump_after   = CONFIG_DEFAULT;
+   fnc->zero_before  = CONFIG_DEFAULT;
+   fnc->toggle_collect = CONFIG_DEFAULT;
+   fnc->skip         = CONFIG_DEFAULT;
+   fnc->pop_on_jump  = CONFIG_DEFAULT;
+   fnc->group        = CONFIG_DEFAULT;
+   fnc->separate_callers    = CONFIG_DEFAULT;
+   fnc->separate_recursions = CONFIG_DEFAULT;
 
 #if CLG_ENABLE_DEBUG
-   new->verbosity    = CONFIG_DEFAULT;
+   fnc->verbosity    = CONFIG_DEFAULT;
 #endif
 
-   return new;
+   return fnc;
 }
 
 
diff --git a/callgrind/context.c b/callgrind/context.c
index 3e326cb5..9abe6d15 100644
--- a/callgrind/context.c
+++ b/callgrind/context.c
@@ -174,7 +174,7 @@ static Bool is_cxt(UWord hash, fn_node** fn, Context* cxt)
  */
 static Context* new_cxt(fn_node** fn)
 {
-    Context* new;
+    Context* cxt;
     UInt idx, offset;
     UWord hash;
     int size, recs;
@@ -193,7 +193,7 @@ static Context* new_cxt(fn_node** fn)
     if (10 * cxts.entries / cxts.size > 8)
         resize_cxt_table();
 
-    new = (Context*) CLG_MALLOC("cl.context.nc.1",
+    cxt = (Context*) CLG_MALLOC("cl.context.nc.1",
                                 sizeof(Context)+sizeof(fn_node*)*size);
 
     // hash value calculation similar to cxt_hash_val(), but additionally
@@ -202,33 +202,33 @@ static Context* new_cxt(fn_node** fn)
     offset = 0;
     while(*fn != 0) {
         hash = (hash<<7) + (hash>>25) + (UWord)(*fn);
-        new->fn[offset] = *fn;
+	cxt->fn[offset] = *fn;
         offset++;
         fn--;
         if (offset >= size) break;
     }
     if (offset < size) size = offset;
 
-    new->size        = size;
-    new->base_number = CLG_(stat).context_counter;
-    new->hash        = hash;
+    cxt->size        = size;
+    cxt->base_number = CLG_(stat).context_counter;
+    cxt->hash        = hash;
 
     CLG_(stat).context_counter += recs;
     CLG_(stat).distinct_contexts++;
 
     /* insert into Context hash table */
     idx = (UInt) (hash % cxts.size);
-    new->next = cxts.table[idx];
-    cxts.table[idx] = new;
+    cxt->next = cxts.table[idx];
+    cxts.table[idx] = cxt;
 
 #if CLG_ENABLE_DEBUG
     CLG_DEBUGIF(3) {
-      VG_(printf)("  new_cxt ox%p: ", new);
-      CLG_(print_cxt)(12, new, 0);
+      VG_(printf)("  new_cxt ox%p: ", cxt);
+      CLG_(print_cxt)(12, cxt, 0);
     }
 #endif
 
-    return new;
+    return cxt;
 }
 
 /* get the Context structure for current context */
@@ -302,14 +302,14 @@ void CLG_(push_cxt)(fn_node* fn)
   fn_entries = CLG_(current_fn_stack).top - CLG_(current_fn_stack).bottom;
   if (fn_entries == CLG_(current_fn_stack).size-1) {
     int new_size = CLG_(current_fn_stack).size *2;
-    fn_node** new = (fn_node**) CLG_MALLOC("cl.context.pc.1",
-                                           new_size * sizeof(fn_node*));
+    fn_node** new_array = (fn_node**) CLG_MALLOC("cl.context.pc.1",
+						 new_size * sizeof(fn_node*));
     int i;
     for(i=0;i<CLG_(current_fn_stack).size;i++)
-      new[i] = CLG_(current_fn_stack).bottom[i];
+      new_array[i] = CLG_(current_fn_stack).bottom[i];
     VG_(free)(CLG_(current_fn_stack).bottom);
-    CLG_(current_fn_stack).top = new + fn_entries;
-    CLG_(current_fn_stack).bottom = new;
+    CLG_(current_fn_stack).top = new_array + fn_entries;
+    CLG_(current_fn_stack).bottom = new_array;
 
     CLG_DEBUG(0, "Resize Context Stack: %d => %d (pushing '%s')\n", 
 	     CLG_(current_fn_stack).size, new_size,
diff --git a/callgrind/events.c b/callgrind/events.c
index ccf21a88..e0595c2b 100644
--- a/callgrind/events.c
+++ b/callgrind/events.c
@@ -401,16 +401,16 @@ Bool CLG_(add_and_zero_cost_lz)(EventSet* es, ULong** pdst, ULong* src)
 
 /* Adds difference of new and old to dst, and set old to new.
  * Returns false if nothing changed */
-Bool CLG_(add_diff_cost)(EventSet* es, ULong* dst, ULong* old, ULong* new)
+Bool CLG_(add_diff_cost)(EventSet* es, ULong* dst, ULong* old, ULong* new_cost)
 {
   Int i = 0, j = 0;
 
   while(i<es->size) {
-    if (new[i] == old[i])
+    if (new_cost[i] == old[i])
       i = es->e[i].nextTop;
     else {
-      dst[i] += new[i] - old[i];
-      old[i] = new[i];
+      dst[i] += new_cost[i] - old[i];
+      old[i] = new_cost[i];
       i++;
       j++;
     }
@@ -422,18 +422,18 @@ Bool CLG_(add_diff_cost)(EventSet* es, ULong* dst, ULong* old, ULong* new)
 /* Adds difference of new and old to dst, and set old to new.
  * Returns false if nothing changed */
 Bool CLG_(add_diff_cost_lz)(EventSet* es, ULong** pdst, 
-			    ULong* old, ULong* new)
+			    ULong* old, ULong* new_cost)
 {
   Int i;
   ULong* dst;
 
-  if (!old && !new) return False;  
-  CLG_ASSERT(old && new);
+  if (!old && !new_cost) return False;
+  CLG_ASSERT(old && new_cost);
 
   i = 0;
   while(1) {
     if (i >= es->size) return False;
-    if (old[i] != new[i]) break;
+    if (old[i] != new_cost[i]) break;
     i = es->e[i].nextTop;
   }
 
@@ -444,16 +444,16 @@ Bool CLG_(add_diff_cost_lz)(EventSet* es, ULong** pdst,
     CLG_(zero_cost)(es,dst);
   }
 
-  dst[i] += new[i] - old[i];
-  old[i] = new[i];
+  dst[i] += new_cost[i] - old[i];
+  old[i] = new_cost[i];
   i++;
 
   while(i<es->size) {
-    if (new[i] == old[i])
+    if (new_cost[i] == old[i])
       i = es->e[i].nextTop;
     else {
-      dst[i] += new[i] - old[i];
-      old[i] = new[i];
+      dst[i] += new_cost[i] - old[i];
+      old[i] = new_cost[i];
       i++;
     }
   }
diff --git a/callgrind/events.h b/callgrind/events.h
index d2cad1e2..c3ddbe36 100644
--- a/callgrind/events.h
+++ b/callgrind/events.h
@@ -97,8 +97,8 @@ Bool CLG_(add_and_zero_cost)(EventSet*,ULong* dst, ULong* src);
 Bool CLG_(add_and_zero_cost_lz)(EventSet*,ULong** pdst, ULong* src);
 /* Adds difference of new and old to to dst, and set old to new.
  * Returns false if nothing changed */
-Bool CLG_(add_diff_cost)(EventSet*,ULong* dst, ULong* old, ULong* new);
-Bool CLG_(add_diff_cost_lz)(EventSet*,ULong** pdst, ULong* old, ULong* new);
+Bool CLG_(add_diff_cost)(EventSet*,ULong* dst, ULong* old, ULong* new_cost);
+Bool CLG_(add_diff_cost_lz)(EventSet*,ULong** pdst, ULong* old, ULong* new_cost);
 /* Returns number of characters written */
 Int CLG_(sprint_cost)(Char* buf, EventSet*, ULong*);
 
diff --git a/callgrind/fn.c b/callgrind/fn.c
index 79ae0292..58a69c87 100644
--- a/callgrind/fn.c
+++ b/callgrind/fn.c
@@ -227,35 +227,35 @@ static __inline__
 obj_node* new_obj_node(DebugInfo* di, obj_node* next)
 {
    Int i;
-   obj_node* new;
+   obj_node* obj;
 
-   new = (obj_node*) CLG_MALLOC("cl.fn.non.1", sizeof(obj_node));
-   new->name  = di ? VG_(strdup)( "cl.fn.non.2",VG_(seginfo_filename)(di) )
+   obj = (obj_node*) CLG_MALLOC("cl.fn.non.1", sizeof(obj_node));
+   obj->name  = di ? VG_(strdup)( "cl.fn.non.2",VG_(seginfo_filename)(di) )
                      : anonymous_obj;
    for (i = 0; i < N_FILE_ENTRIES; i++) {
-      new->files[i] = NULL;
+      obj->files[i] = NULL;
    }
    CLG_(stat).distinct_objs ++;
-   new->number  = CLG_(stat).distinct_objs;
+   obj->number  = CLG_(stat).distinct_objs;
    /* JRS 2008 Feb 19: maybe rename .start/.size/.offset to
       .text_avma/.text_size/.test_bias to make it clearer what these
       fields really mean */
-   new->start   = di ? VG_(seginfo_get_text_avma)(di) : 0;
-   new->size    = di ? VG_(seginfo_get_text_size)(di) : 0;
-   new->offset  = di ? VG_(seginfo_get_text_bias)(di) : 0;
-   new->next    = next;
+   obj->start   = di ? VG_(seginfo_get_text_avma)(di) : 0;
+   obj->size    = di ? VG_(seginfo_get_text_size)(di) : 0;
+   obj->offset  = di ? VG_(seginfo_get_text_bias)(di) : 0;
+   obj->next    = next;
 
    // not only used for debug output (see static.c)
-   new->last_slash_pos = 0;
+   obj->last_slash_pos = 0;
    i = 0;
-   while(new->name[i]) {
-	if (new->name[i]=='/') new->last_slash_pos = i+1;
+   while(obj->name[i]) {
+	if (obj->name[i]=='/') obj->last_slash_pos = i+1;
 	i++;
    }
 
-   if (runtime_resolve_addr == 0) search_runtime_resolve(new);
-   
-   return new;
+   if (runtime_resolve_addr == 0) search_runtime_resolve(obj);
+
+   return obj;
 }
 
 obj_node* CLG_(get_obj_node)(DebugInfo* di)
@@ -287,17 +287,17 @@ file_node* new_file_node(Char filename[FILENAME_LEN],
 			 obj_node* obj, file_node* next)
 {
   Int i;
-  file_node* new = (file_node*) CLG_MALLOC("cl.fn.nfn.1",
+  file_node* file = (file_node*) CLG_MALLOC("cl.fn.nfn.1",
                                            sizeof(file_node));
-  new->name  = VG_(strdup)("cl.fn.nfn.2", filename);
+  file->name  = VG_(strdup)("cl.fn.nfn.2", filename);
   for (i = 0; i < N_FN_ENTRIES; i++) {
-    new->fns[i] = NULL;
+    file->fns[i] = NULL;
   }
   CLG_(stat).distinct_files++;
-  new->number  = CLG_(stat).distinct_files;
-  new->obj     = obj;
-  new->next      = next;
-  return new;
+  file->number  = CLG_(stat).distinct_files;
+  file->obj     = obj;
+  file->next      = next;
+  return file;
 }
 
  
@@ -330,39 +330,39 @@ static __inline__
 fn_node* new_fn_node(Char fnname[FILENAME_LEN],
 		     file_node* file, fn_node* next)
 {
-    fn_node* new = (fn_node*) CLG_MALLOC("cl.fn.nfnnd.1",
+    fn_node* fn = (fn_node*) CLG_MALLOC("cl.fn.nfnnd.1",
                                          sizeof(fn_node));
-    new->name = VG_(strdup)("cl.fn.nfnnd.2", fnname);
+    fn->name = VG_(strdup)("cl.fn.nfnnd.2", fnname);
 
     CLG_(stat).distinct_fns++;
-    new->number   = CLG_(stat).distinct_fns;
-    new->last_cxt = 0;
-    new->pure_cxt = 0;
-    new->file     = file;
-    new->next     = next;
-
-    new->dump_before  = False;
-    new->dump_after   = False;
-    new->zero_before  = False;
-    new->toggle_collect = False;
-    new->skip         = False;
-    new->pop_on_jump  = CLG_(clo).pop_on_jump;
-    new->is_malloc    = False;
-    new->is_realloc   = False;
-    new->is_free      = False;
-
-    new->group        = 0;
-    new->separate_callers    = CLG_(clo).separate_callers;
-    new->separate_recursions = CLG_(clo).separate_recursions;
+    fn->number   = CLG_(stat).distinct_fns;
+    fn->last_cxt = 0;
+    fn->pure_cxt = 0;
+    fn->file     = file;
+    fn->next     = next;
+
+    fn->dump_before  = False;
+    fn->dump_after   = False;
+    fn->zero_before  = False;
+    fn->toggle_collect = False;
+    fn->skip         = False;
+    fn->pop_on_jump  = CLG_(clo).pop_on_jump;
+    fn->is_malloc    = False;
+    fn->is_realloc   = False;
+    fn->is_free      = False;
+
+    fn->group        = 0;
+    fn->separate_callers    = CLG_(clo).separate_callers;
+    fn->separate_recursions = CLG_(clo).separate_recursions;
 
 #if CLG_ENABLE_DEBUG
-    new->verbosity    = -1;
+    fn->verbosity    = -1;
 #endif
 
     if (CLG_(stat).distinct_fns >= current_fn_active.size)
 	resize_fn_array();
 
-    return new;
+    return fn;
 }
 
 
@@ -654,7 +654,7 @@ void CLG_(set_current_fn_array)(fn_array* a)
  */
 static void resize_fn_array(void)
 {
-    UInt* new;
+    UInt* new_array;
     Int i, newsize;
 
     newsize = current_fn_active.size;
@@ -663,15 +663,15 @@ static void resize_fn_array(void)
     CLG_DEBUG(0, "Resize fn_active_array: %d => %d\n",
 	     current_fn_active.size, newsize);
 
-    new = (UInt*) CLG_MALLOC("cl.fn.rfa.1", newsize * sizeof(UInt));
+    new_array = (UInt*) CLG_MALLOC("cl.fn.rfa.1", newsize * sizeof(UInt));
     for(i=0;i<current_fn_active.size;i++)
-      new[i] = current_fn_active.array[i];
+      new_array[i] = current_fn_active.array[i];
     while(i<newsize)
-	new[i++] = 0;
+	new_array[i++] = 0;
 
     VG_(free)(current_fn_active.array);
     current_fn_active.size = newsize;
-    current_fn_active.array = new;
+    current_fn_active.array = new_array;
     CLG_(stat).fn_array_resizes++;
 }
 
diff --git a/callgrind/jumps.c b/callgrind/jumps.c
index 1caa7ccf..668eda83 100644
--- a/callgrind/jumps.c
+++ b/callgrind/jumps.c
@@ -139,7 +139,7 @@ static void resize_jcc_table(void)
  */
 static jCC* new_jcc(BBCC* from, UInt jmp, BBCC* to)
 {
-   jCC* new;
+   jCC* jcc;
    UInt new_idx;
 
    /* check fill degree of jcc hash table and resize if needed (>80%) */
@@ -147,40 +147,40 @@ static jCC* new_jcc(BBCC* from, UInt jmp, BBCC* to)
    if (10 * current_jccs.entries / current_jccs.size > 8)
        resize_jcc_table();
 
-   new = (jCC*) CLG_MALLOC("cl.jumps.nj.1", sizeof(jCC));
+   jcc = (jCC*) CLG_MALLOC("cl.jumps.nj.1", sizeof(jCC));
 
-   new->from      = from;
-   new->jmp       = jmp;
-   new->to        = to;
-   new->jmpkind   = Ijk_Call;
-   new->call_counter = 0;
-   new->cost = 0;
+   jcc->from      = from;
+   jcc->jmp       = jmp;
+   jcc->to        = to;
+   jcc->jmpkind   = Ijk_Call;
+   jcc->call_counter = 0;
+   jcc->cost = 0;
 
    /* insert into JCC chain of calling BBCC.
     * This list is only used at dumping time */
 
    if (from) {
-       new->next_from = from->jmp[jmp].jcc_list;
-       from->jmp[jmp].jcc_list = new;
+       jcc->next_from = from->jmp[jmp].jcc_list;
+       from->jmp[jmp].jcc_list = jcc;
    }
    else {
-       new->next_from = current_jccs.spontaneous;
-       current_jccs.spontaneous = new;
+       jcc->next_from = current_jccs.spontaneous;
+       current_jccs.spontaneous = jcc;
    }
 
    /* insert into JCC hash table */
    new_idx = jcc_hash_idx(from, jmp, to, current_jccs.size);
-   new->next_hash = current_jccs.table[new_idx];
-   current_jccs.table[new_idx] = new;
+   jcc->next_hash = current_jccs.table[new_idx];
+   current_jccs.table[new_idx] = jcc;
 
    CLG_(stat).distinct_jccs++;
 
    CLG_DEBUGIF(3) {
      VG_(printf)("  new_jcc (now %d): %p\n",
-		 CLG_(stat).distinct_jccs, new);
+		 CLG_(stat).distinct_jccs, jcc);
    }
 
-   return new;
+   return jcc;
 }