You can subscribe to this list here.
| 2002 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(1) |
Oct
(122) |
Nov
(152) |
Dec
(69) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2003 |
Jan
(6) |
Feb
(25) |
Mar
(73) |
Apr
(82) |
May
(24) |
Jun
(25) |
Jul
(10) |
Aug
(11) |
Sep
(10) |
Oct
(54) |
Nov
(203) |
Dec
(182) |
| 2004 |
Jan
(307) |
Feb
(305) |
Mar
(430) |
Apr
(312) |
May
(187) |
Jun
(342) |
Jul
(487) |
Aug
(637) |
Sep
(336) |
Oct
(373) |
Nov
(441) |
Dec
(210) |
| 2005 |
Jan
(385) |
Feb
(480) |
Mar
(636) |
Apr
(544) |
May
(679) |
Jun
(625) |
Jul
(810) |
Aug
(838) |
Sep
(634) |
Oct
(521) |
Nov
(965) |
Dec
(543) |
| 2006 |
Jan
(494) |
Feb
(431) |
Mar
(546) |
Apr
(411) |
May
(406) |
Jun
(322) |
Jul
(256) |
Aug
(401) |
Sep
(345) |
Oct
(542) |
Nov
(308) |
Dec
(481) |
| 2007 |
Jan
(427) |
Feb
(326) |
Mar
(367) |
Apr
(255) |
May
(244) |
Jun
(204) |
Jul
(223) |
Aug
(231) |
Sep
(354) |
Oct
(374) |
Nov
(497) |
Dec
(362) |
| 2008 |
Jan
(322) |
Feb
(482) |
Mar
(658) |
Apr
(422) |
May
(476) |
Jun
(396) |
Jul
(455) |
Aug
(267) |
Sep
(280) |
Oct
(253) |
Nov
(232) |
Dec
(304) |
| 2009 |
Jan
(486) |
Feb
(470) |
Mar
(458) |
Apr
(423) |
May
(696) |
Jun
(461) |
Jul
(551) |
Aug
(575) |
Sep
(134) |
Oct
(110) |
Nov
(157) |
Dec
(102) |
| 2010 |
Jan
(226) |
Feb
(86) |
Mar
(147) |
Apr
(117) |
May
(107) |
Jun
(203) |
Jul
(193) |
Aug
(238) |
Sep
(300) |
Oct
(246) |
Nov
(23) |
Dec
(75) |
| 2011 |
Jan
(133) |
Feb
(195) |
Mar
(315) |
Apr
(200) |
May
(267) |
Jun
(293) |
Jul
(353) |
Aug
(237) |
Sep
(278) |
Oct
(611) |
Nov
(274) |
Dec
(260) |
| 2012 |
Jan
(303) |
Feb
(391) |
Mar
(417) |
Apr
(441) |
May
(488) |
Jun
(655) |
Jul
(590) |
Aug
(610) |
Sep
(526) |
Oct
(478) |
Nov
(359) |
Dec
(372) |
| 2013 |
Jan
(467) |
Feb
(226) |
Mar
(391) |
Apr
(281) |
May
(299) |
Jun
(252) |
Jul
(311) |
Aug
(352) |
Sep
(481) |
Oct
(571) |
Nov
(222) |
Dec
(231) |
| 2014 |
Jan
(185) |
Feb
(329) |
Mar
(245) |
Apr
(238) |
May
(281) |
Jun
(399) |
Jul
(382) |
Aug
(500) |
Sep
(579) |
Oct
(435) |
Nov
(487) |
Dec
(256) |
| 2015 |
Jan
(338) |
Feb
(357) |
Mar
(330) |
Apr
(294) |
May
(191) |
Jun
(108) |
Jul
(142) |
Aug
(261) |
Sep
(190) |
Oct
(54) |
Nov
(83) |
Dec
(22) |
| 2016 |
Jan
(49) |
Feb
(89) |
Mar
(33) |
Apr
(50) |
May
(27) |
Jun
(34) |
Jul
(53) |
Aug
(53) |
Sep
(98) |
Oct
(206) |
Nov
(93) |
Dec
(53) |
| 2017 |
Jan
(65) |
Feb
(82) |
Mar
(102) |
Apr
(86) |
May
(187) |
Jun
(67) |
Jul
(23) |
Aug
(93) |
Sep
(65) |
Oct
(45) |
Nov
(35) |
Dec
(17) |
| 2018 |
Jan
(26) |
Feb
(35) |
Mar
(38) |
Apr
(32) |
May
(8) |
Jun
(43) |
Jul
(27) |
Aug
(30) |
Sep
(43) |
Oct
(42) |
Nov
(38) |
Dec
(67) |
| 2019 |
Jan
(32) |
Feb
(37) |
Mar
(53) |
Apr
(64) |
May
(49) |
Jun
(18) |
Jul
(14) |
Aug
(53) |
Sep
(25) |
Oct
(30) |
Nov
(49) |
Dec
(31) |
| 2020 |
Jan
(87) |
Feb
(45) |
Mar
(37) |
Apr
(51) |
May
(99) |
Jun
(36) |
Jul
(11) |
Aug
(14) |
Sep
(20) |
Oct
(24) |
Nov
(40) |
Dec
(23) |
| 2021 |
Jan
(14) |
Feb
(53) |
Mar
(85) |
Apr
(15) |
May
(19) |
Jun
(3) |
Jul
(14) |
Aug
(1) |
Sep
(57) |
Oct
(73) |
Nov
(56) |
Dec
(22) |
| 2022 |
Jan
(3) |
Feb
(22) |
Mar
(6) |
Apr
(55) |
May
(46) |
Jun
(39) |
Jul
(15) |
Aug
(9) |
Sep
(11) |
Oct
(34) |
Nov
(20) |
Dec
(36) |
| 2023 |
Jan
(79) |
Feb
(41) |
Mar
(99) |
Apr
(169) |
May
(48) |
Jun
(16) |
Jul
(16) |
Aug
(57) |
Sep
(19) |
Oct
|
Nov
|
Dec
|
| S | M | T | W | T | F | S |
|---|---|---|---|---|---|---|
|
1
(15) |
2
(17) |
3
(23) |
4
(13) |
5
(7) |
6
(8) |
7
(9) |
|
8
(8) |
9
(31) |
10
(31) |
11
(19) |
12
(11) |
13
(38) |
14
(14) |
|
15
(8) |
16
(11) |
17
(7) |
18
(17) |
19
(12) |
20
(12) |
21
(17) |
|
22
(19) |
23
(33) |
24
(42) |
25
(37) |
26
(23) |
27
(27) |
28
(27) |
|
29
(16) |
30
(52) |
31
(33) |
|
|
|
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 23:44:21
|
CVS commit by nethercote:
Remove VG_() from name of local function.
M +5 -5 vg_symtab2.c 1.85
--- valgrind/coregrind/vg_symtab2.c #1.84:1.85
@@ -36,5 +36,5 @@
static Bool
-VG_(intercept_demangle)(const Char*, Char*, Int);
+intercept_demangle(const Char*, Char*, Int);
/* Majorly rewritten Sun 3 Feb 02 to enable loading symbols from
@@ -492,5 +492,5 @@ void canonicaliseSymtab ( SegInfo* si )
int len = VG_(strlen)(si->symtab[i].name);
char *buf = VG_(malloc)(len), *colon;
- VG_(intercept_demangle)(si->symtab[i].name, buf, len);
+ intercept_demangle(si->symtab[i].name, buf, len);
colon = buf + VG_(strlen)(buf) - 1;
while(*colon != ':') colon--;
@@ -783,5 +783,5 @@ Bool VG_(is_object_file)(const void *buf
static Bool
-VG_(intercept_demangle)(const Char* symbol, Char* result, Int nbytes)
+intercept_demangle(const Char* symbol, Char* result, Int nbytes)
{
int i, j = 0;
@@ -842,5 +842,5 @@ void handle_intercept( SegInfo* si, Char
Char *func;
- VG_(intercept_demangle)(symbol, lib, len);
+ intercept_demangle(symbol, lib, len);
func = lib + VG_(strlen)(lib)-1;
@@ -1125,5 +1125,5 @@ Addr open_debug_file( Char* name, UInt c
/*
- * Try and find a seperated debug file for a given object file.
+ * Try to find a separate debug file for a given object file.
*/
static
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 23:14:11
|
CVS commit by nethercote:
Tweaked sanity-checking: made function naming more consistent, removed
unnecessarily global functions from vg_include.h, etc.
Also tweaked printing of malloc stats.
M +2 -9 coregrind/vg_from_ucode.c 1.82
M +5 -7 coregrind/vg_include.h 1.221
M +7 -6 coregrind/vg_main.c 1.189
M +27 -28 coregrind/vg_malloc2.c 1.30
M +1 -1 coregrind/vg_proxylwp.c 1.18
M +1 -1 coregrind/vg_scheduler.c 1.165
M +2 -12 coregrind/vg_to_ucode.c 1.145
M +37 -5 coregrind/vg_translate.c 1.87
M +2 -2 memcheck/mc_translate.c 1.43
--- valgrind/coregrind/vg_from_ucode.c #1.81:1.82
@@ -4493,13 +4493,6 @@ UChar* VG_(emit_code) ( UCodeBlock* cb,
for (i = 0; i < cb->used; i++) {
UInstr* u = &cb->instrs[i];
+ VG_(sanity_check_UInstr)( i, u );
if (cb->instrs[i].opcode != NOP) {
-
- /* Check on the sanity of this insn. */
- Bool sane = VG_(saneUInstr)( False, False, u );
- if (!sane) {
- VG_(printf)("\ninsane instruction\n");
- VG_(up_UInstr)( i, u );
- }
- vg_assert(sane);
emitUInstr( cb, i, regs_live_before,
&sselive, &orig_eip, &curr_eip );
--- valgrind/coregrind/vg_include.h #1.220:1.221
@@ -380,5 +380,5 @@ extern void* VG_(arena_malloc_aligned) (
extern Int VG_(arena_payload_szB) ( ArenaId aid, void* payload );
-extern void VG_(mallocSanityCheckAll) ( void );
+extern void VG_(sanity_check_malloc_all) ( void );
extern void VG_(print_all_arena_stats) ( void );
@@ -1130,8 +1131,5 @@ struct _UCodeBlock {
extern void VG_(translate) ( ThreadId tid, Addr orig_addr, Bool debugging );
-extern Bool VG_(saneUInstr) ( Bool beforeRA, Bool beforeLiveness,
- UInstr* u );
-extern void VG_(saneUCodeBlock) ( UCodeBlock* cb );
-extern Bool VG_(saneUCodeBlockCalls) ( UCodeBlock* cb );
+extern void VG_(sanity_check_UInstr) ( UInt n, UInstr* u );
extern void VG_(print_reg_alloc_stats) ( void );
@@ -1230,5 +1228,5 @@ extern Bool VG_(logging_to_filedes);
/* Sanity checks which may be done at any time. The scheduler decides when. */
-extern void VG_(do_sanity_checks) ( Bool force_expensive );
+extern void VG_(sanity_check_general) ( Bool force_expensive );
/* Address space */
@@ -1403,5 +1401,5 @@ extern Int VG_(proxy_resfd) ( void )
/* Sanity-check the whole proxy-LWP machinery */
-void VG_(proxy_sanity)(void);
+void VG_(sanity_check_proxy)(void);
/* Send a signal from a thread's proxy to the thread. This longjmps
--- valgrind/coregrind/vg_main.c #1.188:1.189
@@ -255,10 +255,11 @@ static void print_all_stats ( void )
// Memory stats
- if (0) {
+ if (VG_(clo_verbosity) > 2) {
VG_(message)(Vg_DebugMsg, "");
VG_(message)(Vg_DebugMsg,
"------ Valgrind's internal memory use stats follow ------" );
- VG_(mallocSanityCheckAll)();
+ VG_(sanity_check_malloc_all)();
VG_(print_all_arena_stats)();
+ VG_(message)(Vg_DebugMsg, "");
VG_(message)(Vg_DebugMsg,
"------ Valgrind's ExeContext management stats follow ------" );
@@ -2578,5 +2579,5 @@ static void build_segment_map_callback
millisecond. */
-void VG_(do_sanity_checks) ( Bool force_expensive )
+void VG_(sanity_check_general) ( Bool force_expensive )
{
VGP_PUSHCC(VgpCoreCheapSanity);
@@ -2608,5 +2609,5 @@ void VG_(do_sanity_checks) ( Bool force_
sanity_slow_count++;
- VG_(proxy_sanity)();
+ VG_(sanity_check_proxy)();
# if 0
@@ -2634,5 +2635,5 @@ void VG_(do_sanity_checks) ( Bool force_
this check unless specially asked for. And because it's
potentially very expensive. */
- VG_(mallocSanityCheckAll)();
+ VG_(sanity_check_malloc_all)();
VGP_POPCC(VgpCoreExpensiveSanity);
}
@@ -3040,5 +3041,5 @@ int main(int argc, char **argv)
SK_(fini)( exitcode );
- VG_(do_sanity_checks)( True /*include expensive checks*/ );
+ VG_(sanity_check_general)( True /*include expensive checks*/ );
if (VG_(clo_verbosity) > 1)
--- valgrind/coregrind/vg_malloc2.c #1.29:1.30
@@ -225,13 +225,13 @@ void arena_init ( Arena* a, Char* name,
/* Print vital stats for an arena. */
-void VG_(show_all_arena_stats) ( void )
+void VG_(print_all_arena_stats) ( void )
{
Int i;
for (i = 0; i < VG_N_ARENAS; i++) {
VG_(message)(Vg_DebugMsg,
- "Arena `%s': %7d max useful, %7d mmap'd, %7d current useful",
+ "AR %8s: %8d mmap'd, %8d/%8d max/curr",
vg_arena[i].name,
- vg_arena[i].bytes_on_loan_max,
vg_arena[i].bytes_mmaped,
+ vg_arena[i].bytes_on_loan_max,
vg_arena[i].bytes_on_loan
);
@@ -294,5 +294,5 @@ void ensure_mm_init ( void )
init_done = True;
# ifdef DEBUG_MALLOC
- VG_(mallocSanityCheckAll)();
+ VG_(sanity_check_malloc_all)();
# endif
}
@@ -808,5 +808,5 @@ void ppSuperblocks ( Arena* a )
/* Sanity check both the superblocks and the chains. */
-static void mallocSanityCheckArena ( ArenaId aid )
+static void sanity_check_malloc_arena ( ArenaId aid )
{
Int i, superblockctr, b_bszW, b_pszW, blockctr_sb, blockctr_li;
@@ -819,10 +819,9 @@ static void mallocSanityCheckArena ( Are
Arena* a;
-# define BOMB VG_(core_panic)("mallocSanityCheckArena")
+# define BOMB VG_(core_panic)("sanity_check_malloc_arena")
a = arenaId_to_ArenaP(aid);
- /* First, traverse all the superblocks, inspecting the chunks in
- each. */
+ /* First, traverse all the superblocks, inspecting the chunks in each. */
superblockctr = blockctr_sb = blockctr_sb_free = 0;
arena_bytes_on_loan = 0;
@@ -838,5 +837,5 @@ static void mallocSanityCheckArena ( Are
b_bszW = get_bszW_lo(b);
if (!blockSane(a, b)) {
- VG_(printf)("mallocSanityCheckArena: sb %p, block %d (bszW %d): "
+ VG_(printf)("sanity_check_malloc_arena: sb %p, block %d (bszW %d): "
" BAD\n",
sb, i, b_bszW );
@@ -845,5 +844,5 @@ static void mallocSanityCheckArena ( Are
thisFree = !is_inuse_bszW(b_bszW);
if (thisFree && lastWasFree) {
- VG_(printf)("mallocSanityCheckArena: sb %p, block %d (bszW %d): "
+ VG_(printf)("sanity_check_malloc_arena: sb %p, block %d (bszW %d): "
"UNMERGED FREES\n",
sb, i, b_bszW );
@@ -857,5 +856,5 @@ static void mallocSanityCheckArena ( Are
}
if (i > sb->n_payload_words) {
- VG_(printf)( "mallocSanityCheckArena: sb %p: last block "
+ VG_(printf)( "sanity_check_malloc_arena: sb %p: last block "
"overshoots end\n", sb);
BOMB;
@@ -866,5 +865,5 @@ static void mallocSanityCheckArena ( Are
if (arena_bytes_on_loan != a->bytes_on_loan) {
VG_(printf)(
- "mallocSanityCheckArena: a->bytes_on_loan %d, "
+ "sanity_check_malloc_arena: a->bytes_on_loan %d, "
"arena_bytes_on_loan %d: "
"MISMATCH\n", a->bytes_on_loan, arena_bytes_on_loan);
@@ -886,5 +885,5 @@ static void mallocSanityCheckArena ( Are
b = get_next_p(b);
if (get_prev_p(b) != b_prev) {
- VG_(printf)( "mallocSanityCheckArena: list %d at %p: "
+ VG_(printf)( "sanity_check_malloc_arena: list %d at %p: "
"BAD LINKAGE\n",
listno, b );
@@ -894,5 +893,5 @@ static void mallocSanityCheckArena ( Are
if (b_pszW < list_min_pszW || b_pszW > list_max_pszW) {
VG_(printf)(
- "mallocSanityCheckArena: list %d at %p: "
+ "sanity_check_malloc_arena: list %d at %p: "
"WRONG CHAIN SIZE %d (%d, %d)\n",
listno, b, b_pszW, list_min_pszW, list_max_pszW );
@@ -906,5 +905,5 @@ static void mallocSanityCheckArena ( Are
if (blockctr_sb_free != blockctr_li) {
VG_(printf)(
- "mallocSanityCheckArena: BLOCK COUNT MISMATCH "
+ "sanity_check_malloc_arena: BLOCK COUNT MISMATCH "
"(via sbs %d, via lists %d)\n",
blockctr_sb_free, blockctr_li );
@@ -913,11 +912,11 @@ static void mallocSanityCheckArena ( Are
}
+ if (VG_(clo_verbosity) > 2)
VG_(message)(Vg_DebugMsg,
- "mSC [%8s]: %2d sbs, %5d tot bs, %4d/%-4d free bs, "
- "%2d lists, %7d mmap, %7d loan",
+ "AR %8s: %2d sbs, %5d bs, %2d/%-2d free bs, "
+ "%7d mmap, %7d loan",
a->name,
superblockctr,
blockctr_sb, blockctr_sb_free, blockctr_li,
- VG_N_MALLOC_LISTS,
a->bytes_mmaped, a->bytes_on_loan);
# undef BOMB
@@ -925,9 +924,9 @@ static void mallocSanityCheckArena ( Are
-void VG_(mallocSanityCheckAll) ( void )
+void VG_(sanity_check_malloc_all) ( void )
{
Int i;
for (i = 0; i < VG_N_ARENAS; i++)
- mallocSanityCheckArena ( i );
+ sanity_check_malloc_arena ( i );
}
@@ -1077,5 +1076,5 @@ void* VG_(arena_malloc) ( ArenaId aid, I
# ifdef DEBUG_MALLOC
- mallocSanityCheckArena(aid);
+ sanity_check_malloc_arena(aid);
# endif
@@ -1165,5 +1164,5 @@ void VG_(arena_free) ( ArenaId aid, void
# ifdef DEBUG_MALLOC
- mallocSanityCheckArena(aid);
+ sanity_check_malloc_arena(aid);
# endif
@@ -1306,5 +1305,5 @@ void* VG_(arena_malloc_aligned) ( ArenaI
# ifdef DEBUG_MALLOC
- mallocSanityCheckArena(aid);
+ sanity_check_malloc_arena(aid);
# endif
--- valgrind/coregrind/vg_proxylwp.c #1.17:1.18
@@ -1315,5 +1315,5 @@ Int VG_(sys_issue)(int tid)
/* Relatively expensive sanity tests for the syscall machinery */
-void VG_(proxy_sanity)(void)
+void VG_(sanity_check_proxy)(void)
{
Int tid;
--- valgrind/coregrind/vg_scheduler.c #1.164:1.165
@@ -866,5 +866,5 @@ VgSchedReturnCode VG_(scheduler) ( Int*
stage1:
scheduler_sanity();
- VG_(do_sanity_checks)( False );
+ VG_(sanity_check_general)( False );
/* ======================= Phase 1 of 3 =======================
--- valgrind/coregrind/vg_to_ucode.c #1.144:1.145
@@ -7323,10 +7323,7 @@ static Addr disInstr ( UCodeBlock* cb, A
DIP("\n");
for (; first_uinstr < cb->used; first_uinstr++) {
- Bool sane = VG_(saneUInstr)(True, True, &cb->instrs[first_uinstr]);
- if (!sane)
- VG_(up_UInstr)(first_uinstr, &cb->instrs[first_uinstr]);
- else if (VG_(print_codegen))
+ VG_(sanity_check_UInstr)( first_uinstr, &cb->instrs[first_uinstr] );
+ if (VG_(print_codegen))
VG_(pp_UInstr)(first_uinstr, &cb->instrs[first_uinstr]);
- vg_assert(sane);
}
return eip;
@@ -7342,5 +7339,4 @@ Int VG_(disBB) ( UCodeBlock* cb, Addr ei
Addr eip = eip0;
Bool isEnd = False;
- Bool block_sane;
Int delta = 0;
@@ -7401,10 +7397,4 @@ Int VG_(disBB) ( UCodeBlock* cb, Addr ei
LAST_UINSTR(cb).extra4b = delta;
- block_sane = VG_(saneUCodeBlockCalls)(cb);
- if (!block_sane) {
- VG_(pp_UCodeBlock)(cb, "block failing sanity check");
- vg_assert(block_sane);
- }
-
return eip - eip0;
}
--- valgrind/coregrind/vg_translate.c #1.86:1.87
@@ -367,4 +367,9 @@ UInstr* VG_(get_last_instr) ( UCodeBlock
/*------------------------------------------------------------*/
+// Global variables that indicate where we are in the translation of a basic
+// block, and affect exactly how UInstrs are sanity-checked.
+static Bool beforeRA = True;
+static Bool beforeLiveness = True;
+
/* This seems as good a place as any to record some important stuff
about ucode semantics.
@@ -439,5 +444,5 @@ UInstr* VG_(get_last_instr) ( UCodeBlock
ie those which do not directly move/operate on data.
*/
-Bool VG_(saneUInstr) ( Bool beforeRA, Bool beforeLiveness, UInstr* u )
+static Bool is_sane_UInstr ( UInstr* u )
{
# define LIT0 (u->lit32 == 0)
@@ -704,10 +709,21 @@ Bool VG_(saneUInstr) ( Bool beforeRA, Bo
}
-void VG_(saneUCodeBlock) ( UCodeBlock* cb )
+void VG_(sanity_check_UInstr)( UInt n, UInstr* u )
+{
+ Bool sane = is_sane_UInstr(u);
+ if (!sane) {
+ VG_(printf)("\nInsane instruction:\n");
+ VG_(pp_UInstr)(n, u);
+ VG_(up_UInstr)(n, u);
+ vg_assert(sane);
+ }
+}
+
+static void sanity_check_UCodeBlock ( UCodeBlock* cb )
{
Int i;
for (i = 0; i < cb->used; i++) {
- Bool sane = VG_(saneUInstr)(True, True, &cb->instrs[i]);
+ Bool sane = is_sane_UInstr(&cb->instrs[i]);
if (!sane) {
VG_(printf)("Instruction failed sanity check:\n");
@@ -719,5 +735,5 @@ void VG_(saneUCodeBlock) ( UCodeBlock* c
/* Sanity checks to do with CALLMs in UCodeBlocks. */
-Bool VG_(saneUCodeBlockCalls) ( UCodeBlock* cb )
+static Bool is_sane_UCodeBlockCalls ( UCodeBlock* cb )
{
Int callm = 0;
@@ -800,4 +816,11 @@ Bool VG_(saneUCodeBlockCalls) ( UCodeBlo
}
+static void sanity_check_UCodeBlockCalls( UCodeBlock* cb )
+{
+ if ( ! is_sane_UCodeBlockCalls( cb ) ) {
+ VG_(pp_UCodeBlock)(cb, "block failing calls sanity check");
+ VG_(core_panic)("bad block");
+ }
+}
/*------------------------------------------------------------*/
@@ -2419,4 +2442,7 @@ void VG_(translate) ( ThreadId tid, Addr
VGP_PUSHCC(VgpTranslate);
+ beforeRA = True;
+ beforeLiveness = True;
+
for (i = 0; i < VG_MAX_JUMPS; i++)
jumps[i] = (UShort)-1;
@@ -2486,4 +2512,8 @@ void VG_(translate) ( ThreadId tid, Addr
VGP_PUSHCC(VgpToUCode);
orig_size = VG_(disBB) ( cb, orig_addr );
+ sanity_check_UCodeBlock ( cb );
+ // Only sanity-check calls now because tools might remove the
+ // CALLM_[ES] pairs.
+ sanity_check_UCodeBlockCalls ( cb );
VGP_POPCC(VgpToUCode);
@@ -2503,5 +2533,5 @@ void VG_(translate) ( ThreadId tid, Addr
if (VG_(print_codegen))
VG_(pp_UCodeBlock) ( cb, "Instrumented UCode:" );
- VG_(saneUCodeBlock)( cb );
+ sanity_check_UCodeBlock( cb );
VGP_POPCC(VgpInstrument);
@@ -2518,4 +2548,5 @@ void VG_(translate) ( ThreadId tid, Addr
VGP_PUSHCC(VgpRegAlloc);
cb = vg_do_register_allocation ( cb );
+ beforeRA = False;
VGP_POPCC(VgpRegAlloc);
@@ -2524,4 +2555,5 @@ void VG_(translate) ( ThreadId tid, Addr
VGP_PUSHCC(VgpLiveness);
vg_realreg_liveness_analysis ( cb );
+ beforeLiveness = False;
VGP_POPCC(VgpLiveness);
--- valgrind/memcheck/mc_translate.c #1.42:1.43
@@ -37,6 +37,6 @@
/* Compare this with the restrictions on core instructions in
- vg_translate.c:VG_(saneUInstr)(). Everything general said there applies
- here too.
+ vg_translate.c:is_sane_UInstr(). Everything general said there
+ applies here too.
*/
Bool SK_(sane_XUInstr)(Bool beforeRA, Bool beforeLiveness, UInstr* u)
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 18:08:56
|
CVS commit by nethercote:
Tweak stats printing -- use more consistent function names, improve output
formatting slightly, etc.
M +2 -2 vg_execontext.c 1.16
M +3 -3 vg_include.h 1.220
M +28 -21 vg_main.c 1.188
M +3 -6 vg_syscalls.c 1.119
M +5 -3 vg_translate.c 1.86
--- valgrind/coregrind/vg_execontext.c #1.15:1.16
@@ -82,6 +82,6 @@ static void init_ExeContext_storage ( vo
-/* Show stats. */
-void VG_(show_ExeContext_stats) ( void )
+/* Print stats. */
+void VG_(print_ExeContext_stats) ( void )
{
init_ExeContext_storage();
--- valgrind/coregrind/vg_include.h #1.219:1.220
@@ -382,5 +382,5 @@ extern Int VG_(arena_payload_szB) ( Ar
extern void VG_(mallocSanityCheckAll) ( void );
-extern void VG_(show_all_arena_stats) ( void );
+extern void VG_(print_all_arena_stats) ( void );
extern Bool VG_(is_empty_arena) ( ArenaId aid );
@@ -1156,5 +1156,5 @@ struct _ExeContext {
/* Print stats (informational only). */
-extern void VG_(show_ExeContext_stats) ( void );
+extern void VG_(print_ExeContext_stats) ( void );
/* Like VG_(get_ExeContext), but with a slightly different type */
@@ -1428,5 +1428,5 @@ extern void VG_(atfork)(vg_atfork_t pre,
/* fd leakage calls. */
extern void VG_(init_preopened_fds) ( void );
-extern void VG_(fd_stats) ( void );
+extern void VG_(show_open_fds) ( void );
/* ---------------------------------------------------------------------
--- valgrind/coregrind/vg_main.c #1.187:1.188
@@ -207,10 +207,13 @@ static __inline__ Int safe_idiv(Int a, I
}
-static void show_counts ( void )
+static void print_all_stats ( void )
{
+ // Translation stats
VG_(message)(Vg_DebugMsg,
" TT/TC: %d tc sectors discarded.",
VG_(number_of_tc_discards) );
VG_(message)(Vg_DebugMsg,
+ " %d tt_fast misses.", VG_(tt_fast_misses));
+ VG_(message)(Vg_DebugMsg,
" %d chainings, %d unchainings.",
VG_(bb_enchain_count), VG_(bb_dechain_count) );
@@ -228,5 +231,5 @@ static void show_counts ( void )
safe_idiv(10*VG_(overall_out_tsize), VG_(overall_out_osize)));
VG_(message)(Vg_DebugMsg,
- " dispatch: %llu jumps (bb entries), of which %u (%lu%%) were unchained.",
+ " dispatch: %llu jumps (bb entries); of them %u (%lu%%) unchained.",
VG_(bbs_done),
VG_(unchained_jumps_done),
@@ -235,13 +238,31 @@ static void show_counts ( void )
);
+ // Scheduler stats
VG_(print_scheduler_stats)();
- VG_(message)(Vg_DebugMsg,
- " %d tt_fast misses.", VG_(tt_fast_misses));
+ // Reg-alloc stats
VG_(print_reg_alloc_stats)();
VG_(message)(Vg_DebugMsg,
" sanity: %d cheap, %d expensive checks.",
sanity_fast_count, sanity_slow_count );
+
+ // C call stats
VG_(print_ccall_stats)();
+
+ // UInstr histogram
+ if (VG_(clo_verbosity) > 3)
+ VG_(print_UInstr_histogram)();
+
+ // Memory stats
+ if (0) {
+ VG_(message)(Vg_DebugMsg, "");
+ VG_(message)(Vg_DebugMsg,
+ "------ Valgrind's internal memory use stats follow ------" );
+ VG_(mallocSanityCheckAll)();
+ VG_(print_all_arena_stats)();
+ VG_(message)(Vg_DebugMsg,
+ "------ Valgrind's ExeContext management stats follow ------" );
+ VG_(print_ExeContext_stats)();
+ }
}
@@ -3012,5 +3033,5 @@ int main(int argc, char **argv)
/* Print out file descriptor summary and stats. */
if (VG_(clo_track_fds))
- VG_(fd_stats)();
+ VG_(show_open_fds)();
if (VG_(needs).core_errors || VG_(needs).skin_errors)
@@ -3022,19 +3043,5 @@ int main(int argc, char **argv)
if (VG_(clo_verbosity) > 1)
- show_counts();
-
- if (VG_(clo_verbosity) > 3)
- VG_(print_UInstr_histogram)();
-
- if (0) {
- VG_(message)(Vg_DebugMsg, "");
- VG_(message)(Vg_DebugMsg,
- "------ Valgrind's internal memory use stats follow ------" );
- VG_(mallocSanityCheckAll)();
- VG_(show_all_arena_stats)();
- VG_(message)(Vg_DebugMsg,
- "------ Valgrind's ExeContext management stats follow ------" );
- VG_(show_ExeContext_stats)();
- }
+ print_all_stats();
if (VG_(clo_profile))
--- valgrind/coregrind/vg_syscalls.c #1.118:1.119
@@ -564,13 +564,10 @@ getsockdetails(int fd)
-/* Dump out a summary, and optionally a more detailed list, of open file
- descriptors. */
-
-void VG_(fd_stats) ()
+/* Dump out a summary, and a more detailed list, of open file descriptors. */
+void VG_(show_open_fds) ()
{
OpenFd *i = allocated_fds;
- VG_(message)(Vg_UserMsg,
- "FILE DESCRIPTORS: %d open at exit.", fd_count);
+ VG_(message)(Vg_UserMsg, "FILE DESCRIPTORS: %d open at exit.", fd_count);
while(i) {
--- valgrind/coregrind/vg_translate.c #1.85:1.86
@@ -50,8 +50,10 @@ void VG_(print_reg_alloc_stats)(void)
{
VG_(message)(Vg_DebugMsg,
- "reg-alloc: %d t-req-spill, "
- "%d+%d orig+spill uis, %d total-reg-r.",
+ "reg-alloc: %d t-req-spill, %d+%d orig+spill uis,",
n_translations_needing_spill,
- n_uinstrs_prealloc, n_uinstrs_spill, n_total_reg_rank );
+ n_uinstrs_prealloc, n_uinstrs_spill );
+ VG_(message)(Vg_DebugMsg,
+ " %d total-reg-rank",
+ n_total_reg_rank );
}
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 17:39:11
|
CVS commit by nethercote:
alloc_UCodeBlock didn't need to be in vg_include.h. Also tweaked how it works
slightly.
M +0 -2 vg_include.h 1.219
M +11 -13 vg_translate.c 1.85
--- valgrind/coregrind/vg_include.h #1.218:1.219
@@ -1128,6 +1128,4 @@ struct _UCodeBlock {
};
-extern UCodeBlock* VG_(alloc_UCodeBlock) ( void );
-
extern void VG_(translate) ( ThreadId tid, Addr orig_addr, Bool debugging );
--- valgrind/coregrind/vg_translate.c #1.84:1.85
@@ -66,21 +66,21 @@ void VG_(print_reg_alloc_stats)(void)
( ((FlagSet)set1) | ((FlagSet)set2) )
-/* This one is called by the core */
-UCodeBlock* VG_(alloc_UCodeBlock) ( void )
+// This one is local.
+static UCodeBlock* alloc_UCodeBlock ( Addr orig_eip )
{
UCodeBlock* cb = VG_(arena_malloc)(VG_AR_CORE, sizeof(UCodeBlock));
- cb->used = cb->size = cb->nextTemp = 0;
+ cb->orig_eip = orig_eip;
+ cb->used = 0;
+ cb->size = 0;
cb->instrs = NULL;
+ cb->nextTemp = 0;
return cb;
}
-/* This one is called by tools */
+// This one is called by tools.
UCodeBlock* VG_(setup_UCodeBlock) ( UCodeBlock* cb_in )
{
- UCodeBlock* cb = VG_(arena_malloc)(VG_AR_CORE, sizeof(UCodeBlock));
- cb->orig_eip = cb_in->orig_eip;
- cb->used = cb->size = 0;
+ UCodeBlock* cb = alloc_UCodeBlock( cb_in->orig_eip );
cb->nextTemp = cb_in->nextTemp;
- cb->instrs = NULL;
return cb;
}
@@ -2154,6 +2154,5 @@ UCodeBlock* vg_do_register_allocation (
/* Resulting code goes here. We generate it all in a forwards
pass. */
- c2 = VG_(alloc_UCodeBlock)();
- c2->orig_eip = c1->orig_eip;
+ c2 = alloc_UCodeBlock( c1->orig_eip );
/* At the start, no TempRegs are assigned to any real register.
@@ -2462,6 +2461,5 @@ void VG_(translate) ( ThreadId tid, Addr
seg->flags |= SF_CODE; /* contains cached code */
- cb = VG_(alloc_UCodeBlock)();
- cb->orig_eip = orig_addr;
+ cb = alloc_UCodeBlock( orig_addr );
/* If doing any code printing, print a basic block start marker */
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 17:26:46
|
CVS commit by nethercote:
Moved *definitions* of VALGRIND_INTERNAL_PRINTF and
VALGRIND_INTERNAL_PRINTF_BACKTRACE from vg_include.h to vg_messages.c. The
*declarations* stayed.
M +5 -27 vg_include.h 1.218
M +23 -0 vg_messages.c 1.12
--- valgrind/coregrind/vg_include.h #1.217:1.218
@@ -520,31 +520,4 @@ struct vg_mallocfunc_info {
};
-__attribute__((weak))
-int
-VALGRIND_INTERNAL_PRINTF(char *format, ...)
-{
- unsigned int _qzz_res = 0;
- va_list vargs;
- va_start(vargs, format);
- VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, VG_USERREQ__INTERNAL_PRINTF,
- (unsigned int)format, (unsigned int)vargs, 0, 0);
- va_end(vargs);
- return _qzz_res;
-}
-
-__attribute__((weak))
-int
-VALGRIND_INTERNAL_PRINTF_BACKTRACE(char *format, ...)
-{
- unsigned int _qzz_res = 0;
- va_list vargs;
- va_start(vargs, format);
- VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, VG_USERREQ__INTERNAL_PRINTF_BACKTRACE,
- (unsigned int)format, (unsigned int)vargs, 0, 0);
- va_end(vargs);
- return _qzz_res;
-}
-
-
/* ---------------------------------------------------------------------
Constants pertaining to the simulated CPU state, VG_(baseBlock),
@@ -1110,4 +1083,9 @@ extern void VG_(env_remove_valgrind_en
extern void VG_(send_bytes_to_logging_sink) ( Char* msg, Int nbytes );
+// Functions for printing from code within Valgrind, but which runs on the
+// sim'd CPU.
+int VALGRIND_INTERNAL_PRINTF ( char *format, ... );
+int VALGRIND_INTERNAL_PRINTF_BACKTRACE ( char *format, ... );
+
/* ---------------------------------------------------------------------
--- valgrind/coregrind/vg_messages.c #1.11:1.12
@@ -127,4 +127,27 @@ void VG_(send_bytes_to_logging_sink) ( C
}
+int VALGRIND_INTERNAL_PRINTF(char *format, ...)
+{
+ unsigned int _qzz_res = 0;
+ va_list vargs;
+ va_start(vargs, format);
+ VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, VG_USERREQ__INTERNAL_PRINTF,
+ (unsigned int)format, (unsigned int)vargs, 0, 0);
+ va_end(vargs);
+ return _qzz_res;
+}
+
+int VALGRIND_INTERNAL_PRINTF_BACKTRACE(char *format, ...)
+{
+ unsigned int _qzz_res = 0;
+ va_list vargs;
+ va_start(vargs, format);
+ VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, VG_USERREQ__INTERNAL_PRINTF_BACKTRACE,
+ (unsigned int)format, (unsigned int)vargs, 0, 0);
+ va_end(vargs);
+ return _qzz_res;
+}
+
+
/*--------------------------------------------------------------------*/
/*--- end vg_messages.c ---*/
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 17:17:09
|
CVS commit by nethercote:
Simplified the interface to VG_(translate)(), and merged it with
create_translation_for(). Cut about 40 lines of code as a side-effect.
M +2 -2 vg_errcontext.c 1.58
M +4 -5 vg_from_ucode.c 1.81
M +1 -6 vg_include.h 1.217
M +3 -35 vg_scheduler.c 1.164
M +36 -34 vg_translate.c 1.84
--- valgrind/coregrind/vg_errcontext.c #1.57:1.58
@@ -666,6 +666,6 @@ void VG_(show_all_errors) ( void )
if ((i+1 == VG_(clo_dump_error))) {
- VG_(translate) ( 0 /* dummy ThreadId; irrelevant due to below NULLs */,
- p_min->where->eips[0], NULL, NULL, NULL, NULL );
+ VG_(translate) ( 0 /* dummy ThreadId; irrelevant due to debugging*/,
+ p_min->where->eips[0], /*debugging*/True);
}
--- valgrind/coregrind/vg_from_ucode.c #1.80:1.81
@@ -4511,9 +4511,8 @@ UChar* VG_(emit_code) ( UCodeBlock* cb,
vg_assert(eflags_state != UPD_Real); /* flags can't just be in CPU */
- if (j != NULL) {
+ vg_assert(NULL != j);
vg_assert(jumpidx <= VG_MAX_JUMPS);
for(i = 0; i < jumpidx; i++)
j[i] = jumps[i];
- }
/* Returns a pointer to the emitted code. This will have to be
--- valgrind/coregrind/vg_include.h #1.216:1.217
@@ -1152,10 +1152,5 @@ struct _UCodeBlock {
extern UCodeBlock* VG_(alloc_UCodeBlock) ( void );
-extern void VG_(translate) ( ThreadId tid,
- Addr orig_addr,
- UInt* orig_size,
- Addr* trans_addr,
- UInt* trans_size,
- UShort jumps[VG_MAX_JUMPS]);
+extern void VG_(translate) ( ThreadId tid, Addr orig_addr, Bool debugging );
extern Bool VG_(saneUInstr) ( Bool beforeRA, Bool beforeLiveness,
--- valgrind/coregrind/vg_scheduler.c #1.163:1.164
@@ -229,35 +229,4 @@ Char* name_of_sched_event ( UInt event )
-/* Create a translation of the client basic block beginning at
- orig_addr, and add it to the translation cache & translation table.
- This probably doesn't really belong here, but, hey ...
-*/
-static
-void create_translation_for ( ThreadId tid, Addr orig_addr )
-{
- Addr trans_addr;
- Int orig_size, trans_size;
- UShort jumps[VG_MAX_JUMPS];
- Int i;
-
- for(i = 0; i < VG_MAX_JUMPS; i++)
- jumps[i] = (UShort)-1;
-
- /* Make a translation, into temporary storage. */
- VG_(translate)( tid, orig_addr, /* in */
- &orig_size, &trans_addr, &trans_size, jumps ); /* out */
-
- /* Copy data at trans_addr into the translation cache. */
- /* Since the .orig_size and .trans_size fields are UShort, be paranoid. */
- vg_assert(orig_size > 0 && orig_size < 65536);
- vg_assert(trans_size > 0 && trans_size < 65536);
-
- VG_(add_to_trans_tab)( orig_addr, orig_size, trans_addr, trans_size, jumps );
-
- /* Free the intermediary -- was allocated by VG_(emit_code). */
- VG_(arena_free)( VG_AR_JITTER, (void*)trans_addr );
-}
-
-
/* Allocate a completely empty ThreadState record. */
static
@@ -1019,5 +988,5 @@ VgSchedReturnCode VG_(scheduler) ( Int*
dispatch_ctr_SAVED = VG_(dispatch_ctr) = 2;
VG_(translate)(&VG_(threads)[tid], VG_(threads)[tid].m_eip,
- NULL,NULL,NULL);
+ /*debugging*/True);
}
vg_assert(VG_(threads)[tid].m_eip != 0);
@@ -1041,9 +1010,8 @@ VgSchedReturnCode VG_(scheduler) ( Int*
/* Trivial event. Miss in the fast-cache. Do a full
lookup for it. */
- trans_addr
- = VG_(search_transtab) ( VG_(threads)[tid].m_eip );
+ trans_addr = VG_(search_transtab) ( VG_(threads)[tid].m_eip );
if (trans_addr == (Addr)0) {
/* Not found; we need to request a translation. */
- create_translation_for( tid, VG_(threads)[tid].m_eip );
+ VG_(translate)( tid, VG_(threads)[tid].m_eip, /*debug*/False );
trans_addr = VG_(search_transtab) ( VG_(threads)[tid].m_eip );
if (trans_addr == (Addr)0)
--- valgrind/coregrind/vg_translate.c #1.83:1.84
@@ -2397,33 +2397,27 @@ static void vg_realreg_liveness_analysis
/*------------------------------------------------------------*/
-/* Translate the basic block beginning at orig_addr, placing the
- translation in a vg_malloc'd block, the address and size of which
- are returned in trans_addr and trans_size. Length of the original
- block is also returned in orig_size. If the latter three are NULL,
- this call is being done for debugging purposes, in which case (a)
- throw away the translation once it is made, and (b) produce a load
- of debugging output.
+/* Translate the basic block beginning at orig_addr, and add it to
+ the translation cache & translation table. Unless 'debugging' is true,
+ in which case the call is being done for debugging purposes, so
+ (a) throw away the translation once it is made, and (b) produce a
+ load of debugging output.
- 'tst' is the identity of the thread needing this block.
+ 'tid' is the identity of the thread needing this block.
*/
-void VG_(translate) ( /*IN*/ ThreadId tid,
- /*IN*/ Addr orig_addr,
- /*OUT*/ UInt* orig_size,
- /*OUT*/ Addr* trans_addr,
- /*OUT*/ UInt* trans_size,
- /*OUT*/ UShort jumps[VG_MAX_JUMPS])
+void VG_(translate) ( ThreadId tid, Addr orig_addr,
+ Bool debugging_translation )
{
- Int n_disassembled_bytes, final_code_size;
- Bool debugging_translation;
- UChar* final_code;
+ Addr trans_addr, redir, orig_addr0 = orig_addr;
+ UShort jumps[VG_MAX_JUMPS];
+ Int i, orig_size, trans_size;
UCodeBlock* cb;
Bool notrace_until_done;
UInt notrace_until_limit = 0;
Segment *seg;
- Addr redir;
VGP_PUSHCC(VgpTranslate);
- debugging_translation
- = orig_size == NULL || trans_addr == NULL || trans_size == NULL;
+
+ for (i = 0; i < VG_MAX_JUMPS; i++)
+ jumps[i] = (UShort)-1;
/* Look in the code redirect table to see if we should
@@ -2431,9 +2425,10 @@ void VG_(translate) ( /*IN*/ ThreadId t
redir = VG_(code_redirect)(orig_addr);
- if (redir != orig_addr && VG_(clo_verbosity) >= 2)
+ if (redir != orig_addr && VG_(clo_verbosity) >= 2) {
VG_(message)(Vg_UserMsg,
"TRANSLATE: %p redirected to %p",
orig_addr,
redir );
+ }
orig_addr = redir;
@@ -2444,6 +2439,5 @@ void VG_(translate) ( /*IN*/ ThreadId t
notrace_until_limit to be the number of translations to be made
before --trace-codegen= style printing takes effect. */
- notrace_until_done
- = VG_(overall_in_count) >= notrace_until_limit;
+ notrace_until_done = VG_(overall_in_count) >= notrace_until_limit;
seg = VG_(find_segment)(orig_addr);
@@ -2491,5 +2485,5 @@ void VG_(translate) ( /*IN*/ ThreadId t
VG_(print_codegen) = DECIDE_IF_PRINTING_CODEGEN_FOR_PHASE(1);
VGP_PUSHCC(VgpToUCode);
- n_disassembled_bytes = VG_(disBB) ( cb, orig_addr );
+ orig_size = VG_(disBB) ( cb, orig_addr );
VGP_POPCC(VgpToUCode);
@@ -2534,7 +2528,6 @@ void VG_(translate) ( /*IN*/ ThreadId t
/* Emit final code */
VG_(print_codegen) = DECIDE_IF_PRINTING_CODEGEN_FOR_PHASE(5);
-
VGP_PUSHCC(VgpFromUcode);
- final_code = VG_(emit_code)(cb, &final_code_size, jumps );
+ trans_addr = (Addr)VG_(emit_code)(cb, &trans_size, jumps );
VGP_POPCC(VgpFromUcode);
VG_(free_UCodeBlock)(cb);
@@ -2542,13 +2535,21 @@ void VG_(translate) ( /*IN*/ ThreadId t
#undef DECIDE_IF_PRINTING_CODEGEN_FOR_PHASE
- if (debugging_translation) {
- /* Only done for debugging -- throw away final result. */
- VG_(arena_free)(VG_AR_JITTER, final_code);
- } else {
- /* Doing it for real -- return values to caller. */
- *orig_size = n_disassembled_bytes;
- *trans_addr = (Addr)final_code;
- *trans_size = final_code_size;
+ /* Copy data at trans_addr into the translation cache. */
+ /* Since the .orig_size and .trans_size fields are UShort, be paranoid. */
+ vg_assert(orig_size > 0 && orig_size < 65536);
+ vg_assert(trans_size > 0 && trans_size < 65536);
+
+ // If debugging, don't do anything with the translated block; we
+ // only did this for the debugging output produced along the way.
+ if (!debugging_translation) {
+ // Note that we use orig_addr0, not orig_addr, which might have been
+ // changed by the redirection
+ VG_(add_to_trans_tab)( orig_addr0, orig_size, trans_addr, trans_size,
+ jumps );
}
+
+ /* Free the intermediary -- was allocated by VG_(emit_code). */
+ VG_(arena_free)( VG_AR_JITTER, (void*)trans_addr );
+
VGP_POPCC(VgpTranslate);
}
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 17:12:42
|
On Tue, 3 Aug 2004, Robert Walsh wrote: >> I'm confused... I just tried moving the definition of both >> VALGRIND_INTENAL_PRINTF and VALGRIND_INTERNAL_PRINTF_BACKTRACE into >> vg_messages.c, leaving the declaration in vg_include.h, and it worked fine >> -- I tested them with --trace-malloc=yes and by calling pvalloc() from a >> program (which causes an abort with backtrace). >> >> Am I missing something? > > Actually, no you're not. The INTERNAL variants are different from the > regular ones - they're not going to be called by a user program, so that > should be fine. > >> Why does it need the ((weak)) attribute? > > Well, it doesn't any more. It needed it before to avoid complaints > about multiple definitions. Cool, I'll fix it. Thanks. N |
|
From: Robert W. <rj...@du...> - 2004-08-03 17:01:51
|
> I'm confused... I just tried moving the definition of both=20 > VALGRIND_INTENAL_PRINTF and VALGRIND_INTERNAL_PRINTF_BACKTRACE into=20 > vg_messages.c, leaving the declaration in vg_include.h, and it worked fin= e=20 > -- I tested them with --trace-malloc=3Dyes and by calling pvalloc() from = a=20 > program (which causes an abort with backtrace). >=20 > Am I missing something? Actually, no you're not. The INTERNAL variants are different from the regular ones - they're not going to be called by a user program, so that should be fine. > Why does it need the ((weak)) attribute? Well, it doesn't any more. It needed it before to avoid complaints about multiple definitions. Regards, Robert. --=20 Robert Walsh Amalgamated Durables, Inc. - "We don't make the things you buy." Email: rj...@du... |
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 15:49:58
|
CVS commit by nethercote:
Put UCodeBlock get functions in a more sensible place -- moved from vg_needs.c
to vg_translate.c, where the other UCodeBlock functions live.
M +0 -23 vg_needs.c 1.18
M +20 -0 vg_translate.c 1.83
--- valgrind/coregrind/vg_needs.c #1.17:1.18
@@ -169,27 +169,4 @@ NEEDS(shadow_memory)
/*--------------------------------------------------------------------*/
-/* UCodeBlocks */
-
-Int VG_(get_num_instrs) ( UCodeBlock* cb )
-{
- return cb->used;
-}
-
-Int VG_(get_num_temps) ( UCodeBlock* cb )
-{
- return cb->nextTemp;
-}
-
-UInstr* VG_(get_instr) ( UCodeBlock* cb, Int i )
-{
- return & cb->instrs[i];
-}
-
-UInstr* VG_(get_last_instr) ( UCodeBlock* cb )
-{
- return & cb->instrs[cb->used-1];
-}
-
-/*--------------------------------------------------------------------*/
/*--- end vg_needs.c ---*/
/*--------------------------------------------------------------------*/
--- valgrind/coregrind/vg_translate.c #1.82:1.83
@@ -340,4 +340,24 @@ Int VG_(realreg_to_rank) ( Int realReg )
}
+Int VG_(get_num_instrs) ( UCodeBlock* cb )
+{
+ return cb->used;
+}
+
+Int VG_(get_num_temps) ( UCodeBlock* cb )
+{
+ return cb->nextTemp;
+}
+
+UInstr* VG_(get_instr) ( UCodeBlock* cb, Int i )
+{
+ return & cb->instrs[i];
+}
+
+UInstr* VG_(get_last_instr) ( UCodeBlock* cb )
+{
+ return & cb->instrs[cb->used-1];
+}
+
/*------------------------------------------------------------*/
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 15:45:53
|
CVS commit by nethercote:
Removed 6 global variables from vg_include.h without even having to add
anything, just by moving VG_(helper_offset)() from vg_from_ucode.c to
vg_main.c.
M +2 -38 vg_from_ucode.c 1.80
M +0 -15 vg_include.h 1.216
M +44 -7 vg_main.c 1.187
--- valgrind/coregrind/vg_from_ucode.c #1.79:1.80
@@ -2340,41 +2340,4 @@ void VG_(emit_AMD_prefetch_reg) ( Int re
/*----------------------------------------------------*/
-/*--- Helper offset -> addr translation ---*/
-/*----------------------------------------------------*/
-
-/* Finds the baseBlock offset of a tool-specified helper.
- * Searches through compacts first, then non-compacts. */
-Int VG_(helper_offset)(Addr a)
-{
- UInt i;
- Char buf[100];
-
- for (i = 0; i < VG_(n_compact_helpers); i++)
- if (VG_(compact_helper_addrs)[i] == a)
- return VG_(compact_helper_offsets)[i];
- for (i = 0; i < VG_(n_noncompact_helpers); i++)
- if (VG_(noncompact_helper_addrs)[i] == a)
- return VG_(noncompact_helper_offsets)[i];
-
- /* Shouldn't get here */
- VG_(get_fnname) ( a, buf, 100 );
-
- VG_(printf)(
- "\nCouldn't find offset of helper from its address (%p: %s).\n"
- "A helper function probably used hasn't been registered?\n\n", a, buf);
-
- VG_(printf)(" compact helpers: ");
- for (i = 0; i < VG_(n_compact_helpers); i++)
- VG_(printf)("%p ", VG_(compact_helper_addrs)[i]);
-
- VG_(printf)("\n non-compact helpers: ");
- for (i = 0; i < VG_(n_noncompact_helpers); i++)
- VG_(printf)("%p ", VG_(noncompact_helper_addrs)[i]);
-
- VG_(printf)("\n");
- VG_(skin_panic)("Unfound helper");
-}
-
-/*----------------------------------------------------*/
/*--- Instruction synthesisers ---*/
/*----------------------------------------------------*/
@@ -2610,5 +2573,6 @@ void VG_(synth_ccall) ( Addr fn, Int arg
/* Call the function - may trash all flags */
- VG_(synth_call) ( False, VG_(helper_offset) ( fn ), False, FlagsEmpty, FlagsOSZACP );
+ VG_(synth_call) ( False, VG_(helper_offset) ( fn ), False,
+ FlagsEmpty, FlagsOSZACP );
/* Clear any args from stack */
--- valgrind/coregrind/vg_include.h #1.215:1.216
@@ -1651,18 +1650,4 @@ extern Int VGOFF_(tls);
extern Int VGOFF_(helper_undefined_instruction);
-/* For storing extension-specific helpers, determined at runtime. The addr
- * and offset arrays together form a (addr, offset) map that allows a
- * helper's baseBlock offset to be computed from its address. It's done
- * like this so CCALL_M_Ns and other helper calls can use the function
- * address rather than having to much around with offsets. */
-extern UInt VG_(n_compact_helpers);
-extern UInt VG_(n_noncompact_helpers);
-
-extern Addr VG_(compact_helper_addrs) [];
-extern Int VG_(compact_helper_offsets)[];
-
-extern Addr VG_(noncompact_helper_addrs) [];
-extern Int VG_(noncompact_helper_offsets)[];
-
#endif /* ndef __VG_INCLUDE_H */
--- valgrind/coregrind/vg_main.c #1.186:1.187
@@ -2123,11 +2123,15 @@ Int VGOFF_(helper_undefined_instruction)
#define MAX_NONCOMPACT_HELPERS 50
-UInt VG_(n_compact_helpers) = 0;
-UInt VG_(n_noncompact_helpers) = 0;
-
-Addr VG_(compact_helper_addrs) [MAX_COMPACT_HELPERS];
-Int VG_(compact_helper_offsets)[MAX_COMPACT_HELPERS];
-Addr VG_(noncompact_helper_addrs) [MAX_NONCOMPACT_HELPERS];
-Int VG_(noncompact_helper_offsets)[MAX_NONCOMPACT_HELPERS];
+/* For storing tool-specific helpers, determined at runtime. The addr
+ * and offset arrays together form a (addr, offset) map that allows a
+ * helper's baseBlock offset to be computed from its address. It's done
+ * like this so CCALLs can use the function address rather than having to
+ * muck around with offsets. */
+static UInt VG_(n_compact_helpers) = 0;
+static UInt VG_(n_noncompact_helpers) = 0;
+static Addr VG_(compact_helper_addrs) [MAX_COMPACT_HELPERS];
+static Int VG_(compact_helper_offsets)[MAX_COMPACT_HELPERS];
+static Addr VG_(noncompact_helper_addrs) [MAX_NONCOMPACT_HELPERS];
+static Int VG_(noncompact_helper_offsets)[MAX_NONCOMPACT_HELPERS];
/* This is the actual defn of baseblock. */
@@ -2410,4 +2414,37 @@ static void init_baseBlock ( Addr client
}
+// Finds the baseBlock offset of a tool-specified helper.
+// Searches through compacts first, then non-compacts.
+Int VG_(helper_offset)(Addr a)
+{
+ UInt i;
+ Char buf[100];
+
+ for (i = 0; i < VG_(n_compact_helpers); i++)
+ if (VG_(compact_helper_addrs)[i] == a)
+ return VG_(compact_helper_offsets)[i];
+ for (i = 0; i < VG_(n_noncompact_helpers); i++)
+ if (VG_(noncompact_helper_addrs)[i] == a)
+ return VG_(noncompact_helper_offsets)[i];
+
+ /* Shouldn't get here */
+ VG_(get_fnname) ( a, buf, 100 );
+
+ VG_(printf)(
+ "\nCouldn't find offset of helper from its address (%p: %s).\n"
+ "A helper function probably used hasn't been registered?\n\n", a, buf);
+
+ VG_(printf)(" compact helpers: ");
+ for (i = 0; i < VG_(n_compact_helpers); i++)
+ VG_(printf)("%p ", VG_(compact_helper_addrs)[i]);
+
+ VG_(printf)("\n non-compact helpers: ");
+ for (i = 0; i < VG_(n_noncompact_helpers); i++)
+ VG_(printf)("%p ", VG_(noncompact_helper_addrs)[i]);
+
+ VG_(printf)("\n");
+ VG_(skin_panic)("Unfound helper");
+}
+
/*====================================================================*/
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 13:29:30
|
CVS commit by nethercote:
Comment changes only: s/skin/tool/
M +2 -2 addrcheck/ac_main.c 1.64
M +8 -8 coregrind/toolfuncs.def 1.2
M +2 -2 coregrind/vg_errcontext.c 1.57
M +1 -1 coregrind/vg_from_ucode.c 1.79
M +12 -12 coregrind/vg_include.h 1.215
M +2 -2 coregrind/vg_instrument.c 1.13
M +8 -8 coregrind/vg_main.c 1.186 [POSSIBLY UNSAFE: printf]
M +1 -1 coregrind/vg_malloc2.c 1.29
M +2 -2 coregrind/vg_memory.c 1.64
M +1 -1 coregrind/vg_symtab2.h 1.7
M +1 -1 coregrind/vg_symtypes.c 1.7
M +2 -2 coregrind/vg_syscalls.c 1.118
M +7 -7 coregrind/vg_translate.c 1.82
M +40 -40 include/vg_skin.h.base 1.28
M +2 -2 massif/ms_main.c 1.13
M +4 -4 memcheck/mac_leakcheck.c 1.14
M +2 -2 memcheck/mc_main.c 1.50
M +1 -1 memcheck/mc_translate.c 1.42
M +1 -1 memcheck/tests/zeropage.c 1.3
--- valgrind/addrcheck/ac_main.c #1.63:1.64
@@ -1127,7 +1127,7 @@ Bool ac_is_valid_address ( Addr a )
-/* Leak detector for this skin. We don't actually do anything, merely
+/* Leak detector for this tool. We don't actually do anything, merely
run the generic leak detector with suitable parameters for this
- skin. */
+ tool. */
static void ac_detect_memory_leaks ( void )
{
--- valgrind/coregrind/toolfuncs.def #1.1:1.2
@@ -9,5 +9,5 @@
## These are the parameterised functions in the core. The default definitions
-## are overridden by LD_PRELOADed skin version. At the very least, a skin
+## are overridden by LD_PRELOADed tool version. At the very least, a tool
## must define the fundamental template functions. Depending on what needs
## are set, extra template functions will be used too. Functions are
@@ -109,8 +109,8 @@
Bool, process_cmd_line_option, Char* argv
-## Print out command line usage for options for normal skin operation.
+## Print out command line usage for options for normal tool operation.
void, print_usage
-## Print out command line usage for options for debugging the skin.
+## Print out command line usage for options for debugging the tool.
void, print_debug_usage
@@ -124,5 +124,5 @@
## This function should use the VG_IS_SKIN_USERREQ macro (in
-## include/valgrind.h) to first check if it's a request for this skin. Then
+## include/valgrind.h) to first check if it's a request for this tool. Then
## should handle it if it's recognised (and return True), or return False if
## not recognised. arg_block[0] holds the request number, any further args
@@ -156,5 +156,5 @@
## VG_(needs).sanity_checks
-## Can be useful for ensuring a skin's correctness. SK_(cheap_sanity_check)
+## Can be useful for ensuring a tool's correctness. SK_(cheap_sanity_check)
## is called very frequently; SK_(expensive_sanity_check) is called less
## frequently and can be more involved.
@@ -177,5 +177,5 @@
## that case.
-## Memory events (Nb: to track heap allocation/freeing, a skin must replace
+## Memory events (Nb: to track heap allocation/freeing, a tool must replace
## malloc() et al. See above how to do this.)
@@ -192,5 +192,5 @@
void, die_mem_munmap, Addr a, UInt len
-## These ones are called when %esp changes. A skin could track these itself
+## These ones are called when %esp changes. A tool could track these itself
## (except for ban_mem_stack) but it's much easier to use the core's help.
@@ -242,5 +242,5 @@
void, post_reg_write_pthread_return, ThreadId tid, UInt reg
void, post_reg_write_clientreq_return, ThreadId tid, UInt reg
-## This one is called for malloc() et al if they are replaced by a skin.
+## This one is called for malloc() et al if they are replaced by a tool.
void, post_reg_write_clientcall_return, ThreadId tid, UInt reg, Addr f
--- valgrind/coregrind/vg_errcontext.c #1.56:1.57
@@ -57,5 +57,5 @@ static Supp* is_suppressible_error ( Err
/*------------------------------------------------------------*/
-/* Note: it is imperative this doesn't overlap with (0..) at all, as skins
+/* Note: it is imperative this doesn't overlap with (0..) at all, as tools
* effectively extend it by defining their own enums in the (0..) range. */
typedef
@@ -320,5 +320,5 @@ void construct_error ( Error* err, Threa
err->where = where;
- /* Skin-relevant parts */
+ /* Tool-relevant parts */
err->ekind = ekind;
err->addr = a;
--- valgrind/coregrind/vg_from_ucode.c #1.78:1.79
@@ -2343,5 +2343,5 @@ void VG_(emit_AMD_prefetch_reg) ( Int re
/*----------------------------------------------------*/
-/* Finds the baseBlock offset of a skin-specified helper.
+/* Finds the baseBlock offset of a tool-specified helper.
* Searches through compacts first, then non-compacts. */
Int VG_(helper_offset)(Addr a)
--- valgrind/coregrind/vg_include.h #1.214:1.215
@@ -44,6 +44,6 @@
#include "vg_constants.h"
-/* All stuff visible to core and skins goes in vg_skin.h. Things
- * visible to core but not visible to any skins should go in this
+/* All stuff visible to core and tools goes in vg_skin.h. Things
+ * visible to core but not visible to any tools should go in this
* file, vg_include.h. */
#include "vg_skin.h"
@@ -253,5 +253,5 @@ extern Bool VG_(clo_track_fds);
Default: YES. Note this is subservient to VG_(needs).libc_freeres;
if the latter says False, then the setting of VG_(clo_weird_hacks)
- is ignored. Ie if a skin says no, I don't want this to run, that
+ is ignored. Ie if a tool says no, I don't want this to run, that
cannot be overridden from the command line. */
extern Bool VG_(clo_run_libc_freeres);
@@ -282,8 +282,8 @@ extern void VGP_(done_profiling) ( void
/* ---------------------------------------------------------------------
- Skin-related types
+ Tool-related types
------------------------------------------------------------------ */
-/* These structs are not exposed to skins to mitigate possibility of
- binary-incompatibilities when the core/skin interface changes. Instead,
+/* These structs are not exposed to tools to mitigate possibility of
+ binary-incompatibilities when the core/tool interface changes. Instead,
set functions are provided (see include/vg_skin.h). */
typedef
@@ -346,6 +346,6 @@ void VG_(sanity_check_needs)(void);
SYMTAB for Valgrind's symbol table storage.
JITTER for small storage during translation.
- CLIENT for the client's mallocs/frees, if the skin replaces glibc's
- malloc() et al -- redzone size is chosen by the skin.
+ CLIENT for the client's mallocs/frees, if the tool replaces glibc's
+ malloc() et al -- redzone size is chosen by the tool.
DEMANGLE for the C++ demangler.
EXECTXT for storing ExeContexts.
@@ -392,5 +392,5 @@ extern Bool VG_(is_empty_arena) ( Arena
against. However, the scheduler does need to know the following
request codes. A few, publically-visible, request codes are also
- defined in valgrind.h, and similar headers for some skins. */
+ defined in valgrind.h, and similar headers for some tools. */
#define VG_USERREQ__MALLOC 0x2001
@@ -1271,5 +1271,5 @@ extern Addr VG_(client_trampoline_code);
extern Addr VG_(brk_base); /* start of brk */
extern Addr VG_(brk_limit); /* current brk */
-extern Addr VG_(shadow_base); /* skin's shadow memory */
+extern Addr VG_(shadow_base); /* tool's shadow memory */
extern Addr VG_(shadow_end);
extern Addr VG_(valgrind_base); /* valgrind's address range */
@@ -1562,5 +1562,5 @@ extern const Int VG_(tramp_syscall_offs
/* ---------------------------------------------------------------------
- Things relating to the used skin
+ Things relating to the used tool
------------------------------------------------------------------ */
@@ -1647,5 +1647,5 @@ extern Int VGOFF_(ldt);
extern Int VGOFF_(tls);
-/* Nb: Most helper offsets are in include/vg_skin.h, for use by skins */
+/* Nb: Most helper offsets are in include/vg_skin.h, for use by tools */
extern Int VGOFF_(helper_undefined_instruction);
--- valgrind/coregrind/vg_instrument.c #1.12:1.13
@@ -31,6 +31,6 @@
/* We only import vg_skin.h here, because this file only provides functions
- for doing things that could be done directly by the skin -- it's just to
- make skins' lives easier, rather than let them do something they
+ for doing things that could be done directly by the tool -- it's just to
+ make tools' lives easier, rather than let them do something they
couldn't otherwise do. */
#include "vg_skin.h"
--- valgrind/coregrind/vg_main.c #1.185:1.186
@@ -105,5 +105,5 @@ Addr VG_(brk_base); /* start of
Addr VG_(brk_limit); /* current brk */
-Addr VG_(shadow_base); /* skin's shadow memory */
+Addr VG_(shadow_base); /* tool's shadow memory */
Addr VG_(shadow_end);
@@ -1317,7 +1317,7 @@ static void load_tool( const char *tooln
fprintf(stderr, " You need to at least recompile, and possibly update,\n");
if (VG_CORE_INTERFACE_MAJOR_VERSION > toolinfo->interface_major_version)
- fprintf(stderr, " your skin to work with this version of Valgrind.\n");
+ fprintf(stderr, " your tool to work with this version of Valgrind.\n");
else
- fprintf(stderr, " your version of Valgrind to work with this skin.\n");
+ fprintf(stderr, " your version of Valgrind to work with this tool.\n");
goto bad_load;
}
@@ -1918,5 +1918,5 @@ static void process_cmd_line_options( UI
if (VG_(clo_verbosity > 0)) {
- /* Skin details */
+ /* Tool details */
VG_(message)(Vg_UserMsg, "%s%s%s, %s for x86-linux.",
VG_(details).name,
@@ -1980,5 +1980,5 @@ static void process_cmd_line_options( UI
if (VG_(clo_n_suppressions) < VG_CLO_MAX_SFILES-1 &&
(VG_(needs).core_errors || VG_(needs).skin_errors)) {
- /* If there are no suppression files specified and the skin
+ /* If there are no suppression files specified and the tool
needs one, load the default */
static const Char default_supp[] = "default.supp";
@@ -2193,5 +2193,5 @@ void VG_(register_noncompact_helper)(Add
}
-/* Allocate offsets in baseBlock for the skin helpers */
+/* Allocate offsets in baseBlock for the tool helpers */
static
void assign_helpers_in_baseBlock(UInt n, Int offsets[], Addr addrs[])
@@ -2589,5 +2589,5 @@ void VG_(do_sanity_checks) ( Bool force_
/*
This code decides on the layout of the client and Valgrind address
- spaces, loads valgrind.so and the skin.so into the valgrind part,
+ spaces, loads valgrind.so and the tool.so into the valgrind part,
loads the client executable (and the dynamic linker, if necessary)
into the client part, and calls into Valgrind proper.
@@ -2610,5 +2610,5 @@ void VG_(do_sanity_checks) ( Bool force_
shadow_base +-------------------------+
| |
- : shadow memory for skins :
+ : shadow memory for tools :
| (may be 0 sized) |
shadow_end +-------------------------+
--- valgrind/coregrind/vg_malloc2.c #1.28:1.29
@@ -1391,5 +1391,5 @@ void* VG_(arena_realloc) ( ArenaId aid,
/*------------------------------------------------------------*/
-/*--- Skin-visible functions. ---*/
+/*--- Tool-visible functions. ---*/
/*------------------------------------------------------------*/
--- valgrind/coregrind/vg_memory.c #1.63:1.64
@@ -671,5 +671,5 @@ Segment *VG_(next_segment)(Segment *s)
/* This function gets called if new_mem_stack and/or die_mem_stack are
- tracked by the skin, and one of the specialised cases (eg. new_mem_stack_4)
+ tracked by the tool, and one of the specialised cases (eg. new_mem_stack_4)
isn't used in preference */
__attribute__((regparm(1)))
@@ -842,5 +842,5 @@ void VG_(init_shadow_range)(Addr p, UInt
if (call_init)
while(sz) {
- /* ask the skin to initialize each page */
+ /* ask the tool to initialize each page */
VG_TRACK( init_shadow_page, PGROUNDDN(p) );
--- valgrind/coregrind/vg_symtab2.h #1.6:1.7
@@ -160,5 +160,5 @@ struct _SegInfo {
UInt offset;
- /* Bounds of data, BSS, PLT and GOT, so that skins can see what
+ /* Bounds of data, BSS, PLT and GOT, so that tools can see what
section an address is in */
Addr plt_start;
--- valgrind/coregrind/vg_symtypes.c #1.6:1.7
@@ -677,5 +677,5 @@ static void describe_addr_addbuf(Char c)
describe_addr_bufsz *= 2;
- /* use tool malloc so that the skin client can free it */
+ /* use tool malloc so that the tool can free it */
n = VG_(malloc)(describe_addr_bufsz);
if (describe_addr_buf != NULL && describe_addr_bufidx != 0)
--- valgrind/coregrind/vg_syscalls.c #1.117:1.118
@@ -38,5 +38,5 @@
/* All system calls are channelled through here, doing two things:
- * notify the skin of the memory events (reads, writes) happening
+ * notify the tool of the memory events (reads, writes) happening
* perform the syscall, usually by passing it along to the kernel
@@ -5865,5 +5865,5 @@ void VG_(post_syscall) ( ThreadId tid, B
tst = VG_(get_ThreadState)(tid);
- /* Tell the skin about the syscall return value */
+ /* Tell the tool about the syscall return value */
SET_SYSCALL_RETVAL(tst->tid, tst->m_eax);
--- valgrind/coregrind/vg_translate.c #1.81:1.82
@@ -75,5 +75,5 @@ UCodeBlock* VG_(alloc_UCodeBlock) ( void
}
-/* This one is called by skins */
+/* This one is called by tools */
UCodeBlock* VG_(setup_UCodeBlock) ( UCodeBlock* cb_in )
{
@@ -1460,5 +1460,5 @@ Int containingArchRegOf ( Int sz, Int ar
/* If u reads an ArchReg, return the number of the containing arch
reg. Otherwise return -1. Used in redundant-PUT elimination.
- Note that this is not required for skins extending UCode because
+ Note that this is not required for tools extending UCode because
this happens before instrumentation. */
static
@@ -1847,7 +1847,7 @@ static void vg_improve ( UCodeBlock* cb
/*------------------------------------------------------------*/
-/* For skins that want to know about %ESP changes, this pass adds
- in the appropriate hooks. We have to do it after the skin's
- instrumentation, so the skin doesn't have to worry about the CCALLs
+/* For tools that want to know about %ESP changes, this pass adds
+ in the appropriate hooks. We have to do it after the tool's
+ instrumentation, so the tool doesn't have to worry about the CCALLs
it adds in, and we must do it before register allocation because
spilled temps make it much harder to work out the %esp deltas.
@@ -2054,5 +2054,5 @@ UCodeBlock* vg_do_register_allocation (
VG_(printf)("At instr %d...\n", i);
VG_(core_panic)("First use of tmp not a write,"
- " probably a skin instrumentation error");
+ " probably a tool instrumentation error");
}
/* Reads only hold it live until before this insn. */
@@ -2492,5 +2492,5 @@ void VG_(translate) ( /*IN*/ ThreadId t
VGP_POPCC(VgpInstrument);
- /* Add %ESP-update hooks if the skin requires them */
+ /* Add %ESP-update hooks if the tool requires them */
/* Nb: We don't print out this phase, because it doesn't do much */
if (VG_(need_to_handle_esp_assignment)()) {
--- valgrind/include/vg_skin.h.base #1.27:1.28
@@ -1,4 +1,4 @@
/*-*- c -*- ----------------------------------------------------------*/
-/*--- The only header your skin will ever need to #include... ---*/
+/*--- The only header your tool will ever need to #include... ---*/
/*--- vg_skin.h ---*/
/*--------------------------------------------------------------------*/
@@ -120,9 +120,9 @@
/*====================================================================*/
-/*=== Core/skin interface version ===*/
+/*=== Core/tool interface version ===*/
/*====================================================================*/
/* The major version number indicates binary-incompatible changes to the
- interface; if the core and skin major versions don't match, Valgrind
+ interface; if the core and tool major versions don't match, Valgrind
will abort. The minor version indicates binary-compatible changes.
*/
@@ -135,5 +135,5 @@
Int interface_minor_version;
- /* Initialise skin. Must do the following:
+ /* Initialise tool. Must do the following:
- initialise the `details' struct, via the VG_(details_*)() functions
- register any helpers called by generated code
@@ -143,6 +143,6 @@
the VG_(needs_*)() functions
- initialize all the tool's entrypoints via the VG_(init_*)() functions
- - register any skin-specific profiling events
- - any other skin-specific initialisation
+ - register any tool-specific profiling events
+ - any other tool-specific initialisation
*/
void (*sk_pre_clo_init) ( void );
@@ -153,5 +153,5 @@
} ToolInfo;
-/* Every skin must include this macro somewhere, exactly once. */
+/* Every tool must include this macro somewhere, exactly once. */
#define VG_DETERMINE_INTERFACE_VERSION(pre_clo_init, shadow) \
const ToolInfo SK_(tool_info) = { \
@@ -171,5 +171,5 @@
&& VG_(strcmp)((s1),(s2))==0)
-/* Use these for recognising skin command line options -- stops comparing
+/* Use these for recognising tool command line options -- stops comparing
once whitespace is reached. */
#define VG_CLO_STREQ(s1,s2) (0==VG_(strcmp_ws)((s1),(s2)))
@@ -276,11 +276,11 @@
VGP_PAIR(VgpCoreCheapSanity, "core-cheap-sanity"), \
VGP_PAIR(VgpCoreExpensiveSanity, "core-expensive-sanity"), \
- /* These ones depend on the skin */ \
+ /* These ones depend on the tool */ \
VGP_PAIR(VgpPreCloInit, "pre-clo-init"), \
VGP_PAIR(VgpPostCloInit, "post-clo-init"), \
VGP_PAIR(VgpInstrument, "instrument"), \
- VGP_PAIR(VgpSkinSysWrap, "skin-syscall-wrapper"), \
- VGP_PAIR(VgpSkinCheapSanity, "skin-cheap-sanity"), \
- VGP_PAIR(VgpSkinExpensiveSanity, "skin-expensive-sanity"), \
+ VGP_PAIR(VgpSkinSysWrap, "tool-syscall-wrapper"), \
+ VGP_PAIR(VgpSkinCheapSanity, "tool-cheap-sanity"), \
+ VGP_PAIR(VgpSkinExpensiveSanity, "tool-expensive-sanity"), \
VGP_PAIR(VgpFini, "fini")
@@ -289,5 +289,5 @@
#undef VGP_PAIR
-/* When registering skin profiling events, ensure that the 'n' value is in
+/* When registering tool profiling events, ensure that the 'n' value is in
* the range (VgpFini+1..) */
extern void VGP_(register_profile_event) ( Int n, Char* name );
@@ -900,5 +900,5 @@
CCALL,
- /* This opcode makes it easy for skins that extend UCode to do this to
+ /* This opcode makes it easy for tools that extend UCode to do this to
avoid opcode overlap:
@@ -1046,5 +1046,5 @@
- CCALL
- PUT (when %ESP is the target)
- - possibly skin-specific UInstrs
+ - possibly tool-specific UInstrs
*/
UChar argc:2; /* Number of args, max 3 */
@@ -1219,5 +1219,5 @@
/* ------------------------------------------------------------------ */
-/* UCode pretty/ugly printing. Probably only useful to call from a skin
+/* UCode pretty/ugly printing. Probably only useful to call from a tool
if VG_(needs).extended_UCode == True. */
@@ -1308,5 +1308,5 @@
/*====================================================================*/
-/* All this only necessary for skins with VG_(needs).extends_UCode == True. */
+/* All this only necessary for tools with VG_(needs).extends_UCode == True. */
/* This is the Intel register encoding -- integer regs. */
@@ -1495,5 +1495,5 @@
extern Addr VG_(get_EIP)( ThreadId tid );
-/* For skins needing more control over stack traces: walks the stack to get
+/* For tools needing more control over stack traces: walks the stack to get
%eips from the top stack frames for thread 'tid'. Maximum of 'n_eips'
addresses put into 'eips'; 0 is the top of the stack, 1 is its caller,
@@ -1522,5 +1522,5 @@
SuppKind;
-/* The skin-relevant parts of a suppression are:
+/* The tool-relevant parts of a suppression are:
kind: what kind of suppression; must be in the range (0..)
string: use is optional. NULL by default.
@@ -1554,5 +1554,5 @@
ErrorKind;
-/* The skin-relevant parts of an Error are:
+/* The tool-relevant parts of an Error are:
kind: what kind of error; must be in the range (0..)
addr: use is optional. 0 by default.
@@ -1598,5 +1598,5 @@
/* Gets a non-blank, non-comment line of at most nBuf chars from fd.
Skips leading spaces on the line. Returns True if EOF was hit instead.
- Useful for reading in extra skin-specific suppression lines. */
+ Useful for reading in extra tool-specific suppression lines. */
extern Bool VG_(get_line) ( Int fd, Char* buf, Int nBuf );
@@ -1682,7 +1682,7 @@
/* Generic type for a separately-chained hash table. Via a kind of dodgy
- C-as-C++ style inheritance, skins can extend the VgHashNode type, so long
+ C-as-C++ style inheritance, tools can extend the VgHashNode type, so long
as the first two fields match the sizes of these two fields. Requires
- a bit of casting by the skin. */
+ a bit of casting by the tool. */
typedef
struct _VgHashNode {
@@ -1829,5 +1829,5 @@
/*====================================================================*/
-/* If a skin replaces malloc() et al, the easiest way to do so is to
+/* If a tool replaces malloc() et al, the easiest way to do so is to
link with vg_replace_malloc.o into its vgpreload_*.so file, and
follow the following instructions. You can do it from scratch,
@@ -1835,5 +1835,5 @@
/* Arena size for valgrind's own malloc(); default value is 0, but can
- be overridden by skin -- but must be done so *statically*, eg:
+ be overridden by tool -- but must be done so *statically*, eg:
Int VG_(vg_malloc_redzone_szB) = 4;
@@ -1851,6 +1851,6 @@
/* ------------------------------------------------------------------ */
-/* Some options that can be used by a skin if malloc() et al are replaced.
- The skin should call the functions in the appropriate places to give
+/* Some options that can be used by a tool if malloc() et al are replaced.
+ The tool should call the functions in the appropriate places to give
control over these aspects of Valgrind's version of malloc(). */
@@ -1869,5 +1869,5 @@
/*====================================================================*/
-/*=== Skin-specific stuff ===*/
+/*=== Tool-specific stuff ===*/
/*====================================================================*/
@@ -1881,8 +1881,8 @@
/* Information used in the startup message. `name' also determines the
string used for identifying suppressions in a suppression file as
- belonging to this skin. `version' can be NULL, in which case (not
+ belonging to this tool. `version' can be NULL, in which case (not
surprisingly) no version info is printed; this mechanism is designed for
- skins distributed with Valgrind that share a version number with
- Valgrind. Other skins not distributed as part of Valgrind should
+ tools distributed with Valgrind that share a version number with
+ Valgrind. Other tools not distributed as part of Valgrind should
probably have their own version number. */
extern void VG_(details_name) ( Char* name );
@@ -1906,5 +1906,5 @@
operations to be defined if `True' */
-/* Should __libc_freeres() be run? Bugs in it can crash the skin. */
+/* Should __libc_freeres() be run? Bugs in it can crash the tool. */
extern void VG_(needs_libc_freeres) ( void );
@@ -1920,5 +1920,5 @@
lot like being a member of a type class. */
-/* Want to report errors from skin? This implies use of suppressions, too. */
+/* Want to report errors from tool? This implies use of suppressions, too. */
extern void VG_(needs_skin_errors) ( void );
@@ -1931,20 +1931,20 @@
extern void VG_(needs_basic_block_discards) ( void );
-/* Skin maintains information about each register? */
+/* Tool maintains information about each register? */
extern void VG_(needs_shadow_regs) ( void );
-/* Skin defines its own command line options? */
+/* Tool defines its own command line options? */
extern void VG_(needs_command_line_options) ( void );
-/* Skin defines its own client requests? */
+/* Tool defines its own client requests? */
extern void VG_(needs_client_requests) ( void );
-/* Skin defines its own UInstrs? */
+/* Tool defines its own UInstrs? */
extern void VG_(needs_extended_UCode) ( void );
-/* Skin does stuff before and/or after system calls? */
+/* Tool does stuff before and/or after system calls? */
extern void VG_(needs_syscall_wrapper) ( void );
-/* Are skin-state sanity checks performed? */
+/* Are tool-state sanity checks performed? */
extern void VG_(needs_sanity_checks) ( void );
@@ -1952,5 +1952,5 @@
extern void VG_(needs_data_syms) ( void );
-/* Does the skin need shadow memory allocated (if you set this, you must also statically initialize
+/* Does the tool need shadow memory allocated (if you set this, you must also statically initialize
float SK_(shadow_ratio) = n./m;
to define how many shadow bits you need per client address space bit.
--- valgrind/massif/ms_main.c #1.12:1.13
@@ -1,9 +1,9 @@
/*--------------------------------------------------------------------*/
-/*--- Massif: a heap profiling skin. ms_main.c ---*/
+/*--- Massif: a heap profiling tool. ms_main.c ---*/
/*--------------------------------------------------------------------*/
/*
- This file is part of Massif, a Valgrind skin for profiling memory
+ This file is part of Massif, a Valgrind tool for profiling memory
usage of programs.
--- valgrind/memcheck/mac_leakcheck.c #1.13:1.14
@@ -65,6 +65,6 @@ void vg_scan_all_valid_memory_sighandler
passed to notify_word.
- This is all to avoid duplication of this machinery between the
- memcheck and addrcheck skins.
+ This is all to avoid duplication of this machinery between
+ Memcheck and Addrcheck.
*/
static
@@ -369,6 +369,6 @@ static Int lc_compar(void* n1, void* n2)
suitable address-validating functions (see comment at top of
vg_scan_all_valid_memory above). All this is to avoid duplication
- of the leak-detection code for the Memcheck and Addrcheck skins.
- Also pass in a skin-specific function to extract the .where field
+ of the leak-detection code for Memcheck and Addrcheck.
+ Also pass in a tool-specific function to extract the .where field
for allocated blocks, an indication of the resolution wanted for
distinguishing different allocation points, and whether or not
--- valgrind/memcheck/mc_main.c #1.49:1.50
@@ -1458,7 +1458,7 @@ Bool mc_is_valid_address ( Addr a )
-/* Leak detector for this skin. We don't actually do anything, merely
+/* Leak detector for this tool. We don't actually do anything, merely
run the generic leak detector with suitable parameters for this
- skin. */
+ tool. */
void MC_(detect_memory_leaks) ( void )
{
--- valgrind/memcheck/mc_translate.c #1.41:1.42
@@ -574,5 +574,5 @@ static UCodeBlock* memcheck_instrument (
check. 15 Dec 02: optionalisation removed, since it no
longer makes much sense given we also have an addrcheck
- skin.
+ tool.
The LOADV/STOREV does an addressibility check for the
--- valgrind/memcheck/tests/zeropage.c #1.2:1.3
@@ -5,5 +5,5 @@
#include <unistd.h>
-/* The quick sanity check of Memcheck (and other skins with shadow memory)
+/* The quick sanity check of Memcheck (and other tools with shadow memory)
relies on the first 64KB of memory never being used. So our mmap()
refuses to touch this area. This program tests for that. */
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 13:08:48
|
CVS commit by nethercote:
Factor out differences between VG_(system) and PRE(execve). Required moving
mash_colon_env() from vg_syscalls.c to vg_mylibc.c. Saved 20 lines of code.
M +4 -6 vg_include.h 1.214
M +98 -30 vg_mylibc.c 1.84
M +5 -91 vg_syscalls.c 1.117
--- valgrind/coregrind/vg_include.h #1.213:1.214
@@ -1097,6 +1097,8 @@ extern Int VG_(connect_via_socket)( UCha
/* Environment manipulations */
-extern Char **VG_(env_setenv) ( Char ***envp, const Char* varname, const Char *val );
+extern Char **VG_(env_setenv) ( Char ***envp, const Char* varname,
+ const Char *val );
extern void VG_(env_unsetenv) ( Char **env, const Char *varname );
+extern void VG_(env_remove_valgrind_env_stuff) ( Char** env );
/* ---------------------------------------------------------------------
@@ -1457,8 +1459,4 @@ extern void VG_(init_preopened_fds) ( vo
extern void VG_(fd_stats) ( void );
-/* Walk through a colon separated list variable, removing entries
- which match pattern. */
-extern void VG_(mash_colon_env)(Char *varp, const Char *pattern);
-
/* ---------------------------------------------------------------------
Exports of vg_transtab.c
--- valgrind/coregrind/vg_mylibc.c #1.83:1.84
@@ -1489,23 +1489,69 @@ Int VG_(setpgid) ( Int pid, Int pgrp )
}
-/* Return -1 if error, else 0. NOTE does not indicate return code of
- child! */
-Int VG_(system) ( Char* cmd )
+/* Walk through a colon-separated environment variable, and remove the
+ entries which match remove_pattern. It slides everything down over
+ the removed entries, and pads the remaining space with '\0'. It
+ modifies the entries in place (in the client address space), but it
+ shouldn't matter too much, since we only do this just before an
+ execve().
+
+ This is also careful to mop up any excess ':'s, since empty strings
+ delimited by ':' are considered to be '.' in a path.
+*/
+static void mash_colon_env(Char *varp, const Char *remove_pattern)
{
- Int pid, res;
- if (cmd == NULL)
- return 1;
- pid = VG_(do_syscall)(__NR_fork);
- if (VG_(is_kerror)(pid))
- return -1;
- if (pid == 0) {
- /* child */
- static Char** envp = NULL;
- Char* argv[4];
+ Char *const start = varp;
+ Char *entry_start = varp;
+ Char *output = varp;
- /* restore the DATA rlimit for the child */
- VG_(setrlimit)(VKI_RLIMIT_DATA, &VG_(client_rlimit_data));
+ if (varp == NULL)
+ return;
- if (envp == NULL) {
+ while(*varp) {
+ if (*varp == ':') {
+ Char prev;
+ Bool match;
+
+ /* This is a bit subtle: we want to match against the entry
+ we just copied, because it may have overlapped with
+ itself, junking the original. */
+
+ prev = *output;
+ *output = '\0';
+
+ match = VG_(string_match)(remove_pattern, entry_start);
+
+ *output = prev;
+
+ if (match) {
+ output = entry_start;
+ varp++; /* skip ':' after removed entry */
+ } else
+ entry_start = output+1; /* entry starts after ':' */
+ }
+
+ *output++ = *varp++;
+ }
+
+ /* match against the last entry */
+ if (VG_(string_match)(remove_pattern, entry_start)) {
+ output = entry_start;
+ if (output > start) {
+ /* remove trailing ':' */
+ output--;
+ vg_assert(*output == ':');
+ }
+ }
+
+ /* pad out the left-overs with '\0' */
+ while(output < varp)
+ *output++ = '\0';
+}
+
+
+// Removes all the Valgrind-added stuff from the passed environment. Used
+// when starting child processes, so they don't see that added stuff.
+void VG_(env_remove_valgrind_env_stuff)(Char** envp)
+{
Int i;
Char* ld_preload_str = NULL;
@@ -1513,6 +1559,5 @@ Int VG_(system) ( Char* cmd )
Char* buf;
- envp = env_clone(VG_(client_envp));
-
+ // Find LD_* variables
for (i = 0; envp[i] != NULL; i++) {
if (VG_(strncmp)(envp[i], "LD_PRELOAD=", 11) == 0)
@@ -1524,17 +1569,40 @@ Int VG_(system) ( Char* cmd )
buf = VG_(arena_malloc)(VG_AR_CORE, VG_(strlen)(VG_(libdir)) + 20);
+ // Remove Valgrind-specific entries from LD_*.
VG_(sprintf)(buf, "%s*/vg_inject.so", VG_(libdir));
- VG_(mash_colon_env)(ld_preload_str, buf);
-
+ mash_colon_env(ld_preload_str, buf);
VG_(sprintf)(buf, "%s*/vgpreload_*.so", VG_(libdir));
- VG_(mash_colon_env)(ld_preload_str, buf);
-
+ mash_colon_env(ld_preload_str, buf);
VG_(sprintf)(buf, "%s*", VG_(libdir));
- VG_(mash_colon_env)(ld_library_path_str, buf);
+ mash_colon_env(ld_library_path_str, buf);
+ // Remove VALGRIND_CLO variable.
VG_(env_unsetenv)(envp, VALGRINDCLO);
+ // XXX if variable becomes empty, remove it completely?
+
VG_(arena_free)(VG_AR_CORE, buf);
- }
+}
+
+/* Return -1 if error, else 0. NOTE does not indicate return code of
+ child! */
+Int VG_(system) ( Char* cmd )
+{
+ Int pid, res;
+ if (cmd == NULL)
+ return 1;
+ pid = VG_(do_syscall)(__NR_fork);
+ if (VG_(is_kerror)(pid))
+ return -1;
+ if (pid == 0) {
+ /* child */
+ static Char** envp = NULL;
+ Char* argv[4];
+
+ /* restore the DATA rlimit for the child */
+ VG_(setrlimit)(VKI_RLIMIT_DATA, &VG_(client_rlimit_data));
+
+ envp = env_clone(VG_(client_envp));
+ VG_(env_remove_valgrind_env_stuff)( envp );
argv[0] = "/bin/sh";
--- valgrind/coregrind/vg_syscalls.c #1.116:1.117
@@ -154,65 +154,4 @@ static Bool valid_client_addr(Addr start
}
-/* Walk through a colon-separated environment variable, and remove the
- entries which matches file_pattern. It slides everything down over
- the removed entries, and pads the remaining space with '\0'. It
- modifies the entries in place (in the client address space), but it
- shouldn't matter too much, since we only do this just before an
- execve().
-
- This is also careful to mop up any excess ':'s, since empty strings
- delimited by ':' are considered to be '.' in a path.
-*/
-void VG_(mash_colon_env)(Char *varp, const Char *remove_pattern)
-{
- Char *const start = varp;
- Char *entry_start = varp;
- Char *output = varp;
-
- if (varp == NULL)
- return;
-
- while(*varp) {
- if (*varp == ':') {
- Char prev;
- Bool match;
-
- /* This is a bit subtle: we want to match against the entry
- we just copied, because it may have overlapped with
- itself, junking the original. */
-
- prev = *output;
- *output = '\0';
-
- match = VG_(string_match)(remove_pattern, entry_start);
-
- *output = prev;
-
- if (match) {
- output = entry_start;
- varp++; /* skip ':' after removed entry */
- } else
- entry_start = output+1; /* entry starts after ':' */
- }
-
- *output++ = *varp++;
- }
-
- /* match against the last entry */
- if (VG_(string_match)(remove_pattern, entry_start)) {
- output = entry_start;
- if (output > start) {
- /* remove trailing ':' */
- output--;
- vg_assert(*output == ':');
- }
- }
-
- /* pad out the left-overs with '\0' */
- while(output < varp)
- *output++ = '\0';
-}
-
-
/* ---------------------------------------------------------------------
Doing mmap, mremap
@@ -1840,37 +1779,12 @@ PRE(execve)
{
- /* Make the LD_LIBRARY_PATH/LD_PRELOAD disappear so that the
- child doesn't get our libpthread and other stuff. This is
- done unconditionally, since if we are tracing the child,
- stage1/2 will set up the appropriate client environment. */
- Int i;
+ // Remove the valgrind-specific stuff from the environment so the
+ // child doesn't get our libpthread and other stuff. This is
+ // done unconditionally, since if we are tracing the child,
+ // stage1/2 will set up the appropriate client environment.
Char** envp = (Char**)arg3;
- Char* ld_preload_str = NULL;
- Char* ld_library_path_str = NULL;
if (envp != NULL) {
- Char *buf;
-
- for (i = 0; envp[i] != NULL; i++) {
- if (VG_(strncmp)(envp[i], "LD_PRELOAD=", 11) == 0)
- ld_preload_str = &envp[i][11];
- if (VG_(strncmp)(envp[i], "LD_LIBRARY_PATH=", 16) == 0)
- ld_library_path_str = &envp[i][16];
- }
-
- buf = VG_(arena_malloc)(VG_AR_CORE, VG_(strlen)(VG_(libdir)) + 20);
-
- VG_(sprintf)(buf, "%s*/vg_inject.so", VG_(libdir));
- VG_(mash_colon_env)(ld_preload_str, buf);
-
- VG_(sprintf)(buf, "%s*/vgpreload_*.so", VG_(libdir));
- VG_(mash_colon_env)(ld_preload_str, buf);
-
- VG_(sprintf)(buf, "%s*", VG_(libdir));
- VG_(mash_colon_env)(ld_library_path_str, buf);
-
- VG_(env_unsetenv)(envp, VALGRINDCLO);
-
- /* XXX if variable becomes empty, remove it completely? */
+ VG_(env_remove_valgrind_env_stuff)( envp );
}
}
|
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 11:31:47
|
CVS commit by nethercote: disambiguate M +1 -1 downloads.html 1.15 --- devel-home/valgrind/downloads.html #1.14:1.15 @@ -43,5 +43,5 @@ been fixed, and so if you use 2.1.1 you should try 2.1.2. Users of the last stable release, 2.0.0, might also want to try this release. -For one thing, 2.1.2 compiles with gcc-3.4.X, whereas 2.0.0 doesn't. +For one thing, 2.1.2 can be compiled with gcc-3.4.X, whereas 2.0.0 cannot. <p> |
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 09:44:47
|
On Mon, 2 Aug 2004, Robert Walsh wrote: >> VALGRIND_INTERNAL_PRINTF() is *defined* in coregrind/vg_include.h. Any >> reason why? Surely this should not be defined in a .h file? > > I'm open to suggestions for other ways to do this - I certainly couldn't > think of any way of passing varargs stuff around. I'm confused... I just tried moving the definition of both VALGRIND_INTENAL_PRINTF and VALGRIND_INTERNAL_PRINTF_BACKTRACE into vg_messages.c, leaving the declaration in vg_include.h, and it worked fine -- I tested them with --trace-malloc=yes and by calling pvalloc() from a program (which causes an abort with backtrace). Am I missing something? Why does it need the ((weak)) attribute? Thanks. N |
|
From: Doug R. <df...@nl...> - 2004-08-03 09:40:56
|
On Tuesday 03 August 2004 10:34, Nicholas Nethercote wrote: > On Mon, 2 Aug 2004, Doug Rabson wrote: > > If you are re-organising things, would it be possible to do > > whatever is necessary to facilitate merging in all the FreeBSD > > bits? I would quite like to get all that stuff into the mainline > > sources at some point. > > I'm not going to be committing anything soon, but it's certainly a > good idea to get things in place as much as possible for the FreeBSD > port. Can you explain (or point to an old email message if there is > one) what the differences are, what changes are required? There is a thread on this mailing list from back in January which covers some of it. This message <107...@he...> includes some detail on what is different in the FreeBSD valgrind. |
|
From: Nicholas N. <nj...@ca...> - 2004-08-03 09:34:26
|
On Mon, 2 Aug 2004, Doug Rabson wrote: > If you are re-organising things, would it be possible to do whatever is > necessary to facilitate merging in all the FreeBSD bits? I would quite > like to get all that stuff into the mainline sources at some point. I'm not going to be committing anything soon, but it's certainly a good idea to get things in place as much as possible for the FreeBSD port. Can you explain (or point to an old email message if there is one) what the differences are, what changes are required? Thanks. N |
|
From: <js...@ac...> - 2004-08-03 02:58:24
|
Nightly build on nemesis ( SuSE 9.1 ) started at 2004-08-03 03:50:00 BST Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow sem: valgrind ./sem semlimit: valgrind ./semlimit sha1_test: valgrind ./sha1_test shortpush: valgrind ./shortpush shorts: valgrind ./shorts smc1: valgrind ./smc1 susphello: valgrind ./susphello syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 169 tests, 4 stderr failures, 0 stdout failures ================= corecheck/tests/as_mmap (stderr) corecheck/tests/fdleak_fcntl (stderr) memcheck/tests/writev (stderr) memcheck/tests/zeropage (stderr) make: *** [regtest] Error 1 |
|
From: Robert W. <rj...@du...> - 2004-08-03 02:25:47
|
> VALGRIND_INTERNAL_PRINTF() is *defined* in coregrind/vg_include.h. Any=20 > reason why? Surely this should not be defined in a .h file? I'm open to suggestions for other ways to do this - I certainly couldn't think of any way of passing varargs stuff around. Regards, Robert. --=20 Robert Walsh Amalgamated Durables, Inc. - "We don't make the things you buy." Email: rj...@du... |
|
From: Tom H. <to...@co...> - 2004-08-03 02:25:19
|
Nightly build on dunsmere ( Fedora Core 2 ) started at 2004-08-03 03:20:02 BST Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow shorts: valgrind ./shorts smc1: valgrind ./smc1 susphello: valgrind ./susphello syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 174 tests, 7 stderr failures, 1 stdout failure ================= corecheck/tests/fdleak_cmsg (stderr) corecheck/tests/fdleak_fcntl (stderr) corecheck/tests/fdleak_ipv4 (stderr) corecheck/tests/fdleak_socketpair (stderr) memcheck/tests/buflen_check (stderr) memcheck/tests/execve (stderr) memcheck/tests/writev (stderr) none/tests/exec-sigmask (stdout) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2004-08-03 02:20:01
|
Nightly build on audi ( Red Hat 9 ) started at 2004-08-03 03:15:02 BST Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow shortpush: valgrind ./shortpush shorts: valgrind ./shorts smc1: valgrind ./smc1 susphello: valgrind ./susphello syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 174 tests, 7 stderr failures, 0 stdout failures ================= corecheck/tests/fdleak_cmsg (stderr) corecheck/tests/fdleak_fcntl (stderr) corecheck/tests/fdleak_ipv4 (stderr) corecheck/tests/fdleak_socketpair (stderr) memcheck/tests/buflen_check (stderr) memcheck/tests/execve (stderr) memcheck/tests/writev (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2004-08-03 02:13:23
|
Nightly build on ginetta ( Red Hat 8.0 ) started at 2004-08-03 03:10:03 BST Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow seg_override: valgrind ./seg_override sem: valgrind ./sem semlimit: valgrind ./semlimit sha1_test: valgrind ./sha1_test shortpush: valgrind ./shortpush shorts: valgrind ./shorts smc1: valgrind ./smc1 susphello: valgrind ./susphello syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 174 tests, 3 stderr failures, 0 stdout failures ================= helgrind/tests/race (stderr) helgrind/tests/race2 (stderr) memcheck/tests/writev (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2004-08-03 02:08:16
|
Nightly build on alvis ( Red Hat 7.3 ) started at 2004-08-03 03:05:05 BST Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow susphello: valgrind ./susphello syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 174 tests, 9 stderr failures, 1 stdout failure ================= addrcheck/tests/toobig-allocs (stderr) helgrind/tests/deadlock (stderr) helgrind/tests/race (stderr) helgrind/tests/race2 (stderr) memcheck/tests/badjump (stderr) memcheck/tests/brk (stderr) memcheck/tests/error_counts (stdout) memcheck/tests/new_nothrow (stderr) memcheck/tests/toobig-allocs (stderr) memcheck/tests/writev (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2004-08-03 02:07:00
|
Nightly build on standard ( Red Hat 7.2 ) started at 2004-08-03 03:00:01 BST Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow rcrl: valgrind ./rcrl readline1: valgrind ./readline1 resolv: valgrind ./resolv rlimit_nofile: valgrind ./rlimit_nofile seg_override: valgrind ./seg_override sem: valgrind ./sem semlimit: valgrind ./semlimit sha1_test: valgrind ./sha1_test shortpush: valgrind ./shortpush shorts: valgrind ./shorts smc1: valgrind ./smc1 susphello: valgrind ./susphello syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 174 tests, 0 stderr failures, 0 stdout failures ================= |