From 6961dcf591eb1850829b2c4f0485735180e3bc4d Mon Sep 17 00:00:00 2001 From: Tom Hughes Date: Wed, 12 Oct 2005 10:45:27 +0000 Subject: [PATCH] Fix statement-before-declaration warnings for the core code. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@4906 --- coregrind/m_debuginfo/dwarf.c | 47 ++++++++++++++--------- coregrind/m_debuginfo/symtab.c | 5 +-- coregrind/m_libcfile.c | 3 +- coregrind/m_main.c | 24 ++++++------ coregrind/m_mallocfree.c | 2 +- coregrind/m_oset.c | 6 ++- coregrind/m_syswrap/syswrap-amd64-linux.c | 14 +++++-- coregrind/m_syswrap/syswrap-generic.c | 4 +- coregrind/m_syswrap/syswrap-linux.c | 8 ++-- coregrind/m_syswrap/syswrap-main.c | 9 ++++- 10 files changed, 71 insertions(+), 51 deletions(-) diff --git a/coregrind/m_debuginfo/dwarf.c b/coregrind/m_debuginfo/dwarf.c index 54ed384d7..e2794c7ea 100644 --- a/coregrind/m_debuginfo/dwarf.c +++ b/coregrind/m_debuginfo/dwarf.c @@ -1630,8 +1630,8 @@ static inline Bool host_is_little_endian ( void ) static Short read_Short ( UChar* data ) { - vg_assert(host_is_little_endian()); Short r = 0; + vg_assert(host_is_little_endian()); r = data[0] | ( ((UInt)data[1]) << 8 ); return r; @@ -1639,8 +1639,8 @@ static Short read_Short ( UChar* data ) static Int read_Int ( UChar* data ) { - vg_assert(host_is_little_endian()); Int r = 0; + vg_assert(host_is_little_endian()); r = data[0] | ( ((UInt)data[1]) << 8 ) | ( ((UInt)data[2]) << 16 ) @@ -1650,8 +1650,8 @@ static Int read_Int ( UChar* data ) static Long read_Long ( UChar* data ) { - vg_assert(host_is_little_endian()); Long r = 0; + vg_assert(host_is_little_endian()); r = data[0] | ( ((ULong)data[1]) << 8 ) | ( ((ULong)data[2]) << 16 ) @@ -1665,8 +1665,8 @@ static Long read_Long ( UChar* data ) static UShort read_UShort ( UChar* data ) { - vg_assert(host_is_little_endian()); UInt r = 0; + vg_assert(host_is_little_endian()); r = data[0] | ( ((UInt)data[1]) << 8 ); return r; @@ -1674,8 +1674,8 @@ static UShort read_UShort ( UChar* data ) static UInt read_UInt ( UChar* data ) { - vg_assert(host_is_little_endian()); UInt r = 0; + vg_assert(host_is_little_endian()); r = data[0] | ( ((UInt)data[1]) << 8 ) | ( ((UInt)data[2]) << 16 ) @@ -1685,8 +1685,8 @@ static UInt read_UInt ( UChar* data ) static ULong read_ULong ( UChar* data ) { - vg_assert(host_is_little_endian()); ULong r = 0; + vg_assert(host_is_little_endian()); r = data[0] | ( ((ULong)data[1]) << 8 ) | ( ((ULong)data[2]) << 16 ) @@ -2236,6 +2236,9 @@ void ML_(read_callframe_info_dwarf2) previously-seen CIE. */ while (True) { + UChar* ciefde_start; + UInt ciefde_len; + UInt cie_pointer; /* Are we done? */ if (data == ehframe + ehframe_sz) @@ -2250,12 +2253,12 @@ void ML_(read_callframe_info_dwarf2) /* Ok, we must be looking at the start of a new CIE or FDE. Figure out which it is. */ - UChar* ciefde_start = data; + ciefde_start = data; if (VG_(clo_trace_cfi)) VG_(printf)("\ncie/fde.start = %p (ehframe + 0x%x)\n", ciefde_start, ciefde_start - ehframe); - UInt ciefde_len = read_UInt(data); data += sizeof(UInt); + ciefde_len = read_UInt(data); data += sizeof(UInt); if (VG_(clo_trace_cfi)) VG_(printf)("cie/fde.length = %d\n", ciefde_len); @@ -2269,7 +2272,7 @@ void ML_(read_callframe_info_dwarf2) goto bad; } - UInt cie_pointer = read_UInt(data); + cie_pointer = read_UInt(data); data += sizeof(UInt); /* XXX see XXX below */ if (VG_(clo_trace_cfi)) VG_(printf)("cie.pointer = %d\n", cie_pointer); @@ -2277,7 +2280,9 @@ void ML_(read_callframe_info_dwarf2) /* If cie_pointer is zero, we've got a CIE; else it's an FDE. */ if (cie_pointer == 0) { - Int this_CIE; + Int this_CIE; + UChar cie_version; + UChar* cie_augmentation; /* --------- CIE --------- */ if (VG_(clo_trace_cfi)) @@ -2299,7 +2304,7 @@ void ML_(read_callframe_info_dwarf2) later when looking at an FDE. */ the_CIEs[this_CIE].offset = ciefde_start - ehframe; - UChar cie_version = read_UChar(data); data += sizeof(UChar); + cie_version = read_UChar(data); data += sizeof(UChar); if (VG_(clo_trace_cfi)) VG_(printf)("cie.version = %d\n", (Int)cie_version); if (cie_version != 1) { @@ -2307,7 +2312,7 @@ void ML_(read_callframe_info_dwarf2) goto bad; } - UChar* cie_augmentation = data; + cie_augmentation = data; data += 1 + VG_(strlen)(cie_augmentation); if (VG_(clo_trace_cfi)) VG_(printf)("cie.augment = \"%s\"\n", cie_augmentation); @@ -2408,9 +2413,13 @@ void ML_(read_callframe_info_dwarf2) } else { UnwindContext ctx, restore_ctx; - Int cie; - UInt look_for; - Bool ok; + Int cie; + UInt look_for; + Bool ok; + Addr fde_initloc; + UWord fde_arange; + UChar* fde_instrs; + Int fde_ilen; /* --------- FDE --------- */ @@ -2433,14 +2442,14 @@ void ML_(read_callframe_info_dwarf2) goto bad; } - Addr fde_initloc + fde_initloc = read_encoded_Addr(data, the_CIEs[cie].address_encoding, &nbytes, ehframe, ehframe_addr); data += nbytes; if (VG_(clo_trace_cfi)) VG_(printf)("fde.initloc = %p\n", (void*)fde_initloc); - UWord fde_arange + fde_arange = read_encoded_Addr(data, the_CIEs[cie].address_encoding & 0xf, &nbytes, ehframe, ehframe_addr); data += nbytes; @@ -2452,8 +2461,8 @@ void ML_(read_callframe_info_dwarf2) data += nbytes; } - UChar* fde_instrs = data; - Int fde_ilen = ciefde_start + ciefde_len + sizeof(UInt) - data; + fde_instrs = data; + fde_ilen = ciefde_start + ciefde_len + sizeof(UInt) - data; if (VG_(clo_trace_cfi)) { VG_(printf)("fde.instrs = %p\n", fde_instrs); VG_(printf)("fde.ilen = %d\n", (Int)fde_ilen); diff --git a/coregrind/m_debuginfo/symtab.c b/coregrind/m_debuginfo/symtab.c index e9b804a54..8ee1c4d4e 100644 --- a/coregrind/m_debuginfo/symtab.c +++ b/coregrind/m_debuginfo/symtab.c @@ -498,6 +498,8 @@ void ML_(addScopeInfo) ( SegInfo* si, void ML_(addCfiSI) ( SegInfo* si, CfiSI* cfisi ) { static const Bool debug = False; + UInt new_sz, i; + CfiSI* new_tab; if (debug) { VG_(printf)("adding CfiSI: "); @@ -506,9 +508,6 @@ void ML_(addCfiSI) ( SegInfo* si, CfiSI* cfisi ) vg_assert(cfisi->len > 0 && cfisi->len < 2000000); - UInt new_sz, i; - CfiSI* new_tab; - /* Rule out ones which are completely outside the segment. These probably indicate some kind of bug, but for the meantime ignore them. */ diff --git a/coregrind/m_libcfile.c b/coregrind/m_libcfile.c index 2da57532e..f86f2e277 100644 --- a/coregrind/m_libcfile.c +++ b/coregrind/m_libcfile.c @@ -212,8 +212,7 @@ SysRes VG_(pread) ( Int fd, void* buf, Int count, Int offset ) OffT off = VG_(lseek)( fd, (OffT)offset, VKI_SEEK_SET); if (off != 0) return VG_(mk_SysRes_Error)( VKI_EINVAL ); - SysRes res = VG_(do_syscall3)(__NR_read, fd, (UWord)buf, count ); - return res; + return VG_(do_syscall3)(__NR_read, fd, (UWord)buf, count ); } /* Create and open (-rw------) a tmp file name incorporating said arg. diff --git a/coregrind/m_main.c b/coregrind/m_main.c index 26e8701ff..a76bc4722 100644 --- a/coregrind/m_main.c +++ b/coregrind/m_main.c @@ -114,7 +114,7 @@ static HChar** setup_client_env ( HChar** origenv, const HChar* toolname) HChar** cpp; HChar** ret; - HChar* preload_tool_path;; + HChar* preload_tool_path; Int envc, i; /* Alloc space for the vgpreload_core.so path and vgpreload_.so @@ -417,6 +417,7 @@ Addr setup_client_stack( void* init_sp, Addr anon_start = clstack_start; Addr resvn_start = anon_start - resvn_size; SizeT inner_HACK = 0; + Bool ok; vg_assert(VG_IS_PAGE_ALIGNED(anon_size)); vg_assert(VG_IS_PAGE_ALIGNED(resvn_size)); @@ -434,12 +435,12 @@ Addr setup_client_stack( void* init_sp, /* Create a shrinkable reservation followed by an anonymous segment. Together these constitute a growdown stack. */ - Bool ok = VG_(am_create_reservation)( - resvn_start, - resvn_size -inner_HACK, - SmUpper, - anon_size +inner_HACK - ); + ok = VG_(am_create_reservation)( + resvn_start, + resvn_size -inner_HACK, + SmUpper, + anon_size +inner_HACK + ); vg_assert(ok); /* allocate a stack - mmap enough space for the stack */ res = VG_(am_mmap_anon_fixed_client)( @@ -1468,8 +1469,10 @@ static Bool process_cmd_line_options( UInt* client_auxv, const char* toolname ) results of a run which encompasses multiple processes. */ static void print_preamble(Bool logging_to_fd, const char* toolname) { - Int i; - + HChar* xpre = VG_(clo_xml) ? " " : ""; + HChar* xpost = VG_(clo_xml) ? "" : ""; + Int i; + if (VG_(clo_xml)) { VG_(message)(Vg_UserMsg, ""); VG_(message)(Vg_UserMsg, ""); @@ -1479,9 +1482,6 @@ static void print_preamble(Bool logging_to_fd, const char* toolname) VG_(message)(Vg_UserMsg, ""); } - HChar* xpre = VG_(clo_xml) ? " " : ""; - HChar* xpost = VG_(clo_xml) ? "" : ""; - if (VG_(clo_verbosity > 0)) { if (VG_(clo_xml)) diff --git a/coregrind/m_mallocfree.c b/coregrind/m_mallocfree.c index 47c487333..751139225 100644 --- a/coregrind/m_mallocfree.c +++ b/coregrind/m_mallocfree.c @@ -607,8 +607,8 @@ Superblock* findSb ( Arena* a, Block* b ) static UInt pszB_to_listNo ( SizeT pszB ) { - vg_assert(0 == pszB % VG_MIN_MALLOC_SZB); SizeT n = pszB / VG_MIN_MALLOC_SZB; + vg_assert(0 == pszB % VG_MIN_MALLOC_SZB); // The first 13 lists hold blocks of size VG_MIN_MALLOC_SZB * list_num. // The final 5 hold bigger blocks. diff --git a/coregrind/m_oset.c b/coregrind/m_oset.c index c3570ee03..695d45d9b 100644 --- a/coregrind/m_oset.c +++ b/coregrind/m_oset.c @@ -433,11 +433,13 @@ static Bool avl_insert(AvlTree* t, AvlNode* n) // avl_insert() which doesn't return a Bool. void VG_(OSet_Insert)(AvlTree* t, void* e) { + AvlNode* n; + vg_assert(t); // Initialise. Even though OSet_AllocNode zeroes these fields, we should // do it again in case a node is removed and then re-added to the tree. - AvlNode* n = node_of_elem(e); + n = node_of_elem(e); n->left = 0; n->right = 0; n->balance = 0; @@ -532,9 +534,9 @@ static Bool avl_remove(AvlTree* t, AvlNode* n) Int cmpres = cmp_key_root(t, n); if (cmpres < 0) { + AvlTree left_subtree; // Remove from the left subtree vg_assert(t->root->left); - AvlTree left_subtree; // Only need to set the used fields in the subtree. left_subtree.root = t->root->left; left_subtree.cmp = t->cmp; diff --git a/coregrind/m_syswrap/syswrap-amd64-linux.c b/coregrind/m_syswrap/syswrap-amd64-linux.c index c18cd42a3..e4804e1db 100644 --- a/coregrind/m_syswrap/syswrap-amd64-linux.c +++ b/coregrind/m_syswrap/syswrap-amd64-linux.c @@ -107,6 +107,8 @@ static Addr allocstack(ThreadId tid) static void run_a_thread_NORETURN ( Word tidW ) { ThreadId tid = (ThreadId)tidW; + VgSchedReturnCode src; + Int c; VG_(debugLog)(1, "syswrap-amd64-linux", "run_a_thread_NORETURN(tid=%lld): " @@ -114,14 +116,14 @@ static void run_a_thread_NORETURN ( Word tidW ) (ULong)tidW); /* Run the thread all the way through. */ - VgSchedReturnCode src = ML_(thread_wrapper)(tid); + src = ML_(thread_wrapper)(tid); VG_(debugLog)(1, "syswrap-amd64-linux", "run_a_thread_NORETURN(tid=%lld): " "ML_(thread_wrapper) done\n", (ULong)tidW); - Int c = VG_(count_living_threads)(); + c = VG_(count_living_threads)(); vg_assert(c >= 1); /* stay sane */ if (c == 1) { @@ -138,13 +140,15 @@ static void run_a_thread_NORETURN ( Word tidW ) } else { + ThreadState *tst; + VG_(debugLog)(1, "syswrap-amd64-linux", "run_a_thread_NORETURN(tid=%lld): " "not last one standing\n", (ULong)tidW); /* OK, thread is dead, but others still exist. Just exit. */ - ThreadState *tst = VG_(get_ThreadState)(tid); + tst = VG_(get_ThreadState)(tid); /* This releases the run lock */ VG_(exit_thread)(tid); @@ -220,10 +224,12 @@ asm( */ void VG_(main_thread_wrapper_NORETURN)(ThreadId tid) { + Addr rsp; + VG_(debugLog)(1, "syswrap-amd64-linux", "entering VG_(main_thread_wrapper_NORETURN)\n"); - Addr rsp = allocstack(tid); + rsp = allocstack(tid); /* If we can't even allocate the first thread's stack, we're hosed. Give up. */ diff --git a/coregrind/m_syswrap/syswrap-generic.c b/coregrind/m_syswrap/syswrap-generic.c index d92b085f6..005197f45 100644 --- a/coregrind/m_syswrap/syswrap-generic.c +++ b/coregrind/m_syswrap/syswrap-generic.c @@ -1095,9 +1095,9 @@ ML_(generic_POST_sys_socketpair) ( ThreadId tid, UWord arg2, UWord arg3 ) { SysRes r = res; - vg_assert(!res.isError); /* guaranteed by caller */ Int fd1 = ((Int*)arg3)[0]; Int fd2 = ((Int*)arg3)[1]; + vg_assert(!res.isError); /* guaranteed by caller */ POST_MEM_WRITE( arg3, 2*sizeof(int) ); if (!ML_(fd_allowed)(fd1, "socketcall.socketpair", tid, True) || !ML_(fd_allowed)(fd2, "socketcall.socketpair", tid, True)) { @@ -4761,8 +4761,8 @@ PRE(sys_poll) int poll(struct pollfd *ufds, unsigned int nfds, int timeout) */ UInt i; - *flags |= SfMayBlock; struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1; + *flags |= SfMayBlock; PRINT("sys_poll ( %p, %d, %d )\n", ARG1,ARG2,ARG3); PRE_REG_READ3(long, "poll", struct pollfd *, ufds, unsigned int, nfds, long, timeout); diff --git a/coregrind/m_syswrap/syswrap-linux.c b/coregrind/m_syswrap/syswrap-linux.c index a9d81ba98..322063585 100644 --- a/coregrind/m_syswrap/syswrap-linux.c +++ b/coregrind/m_syswrap/syswrap-linux.c @@ -54,14 +54,14 @@ // scheduler-return-code. VgSchedReturnCode ML_(thread_wrapper)(Word /*ThreadId*/ tidW) { - VG_(debugLog)(1, "core_os", - "ML_(thread_wrapper)(tid=%lld): entry\n", - (ULong)tidW); - VgSchedReturnCode ret; ThreadId tid = (ThreadId)tidW; ThreadState* tst = VG_(get_ThreadState)(tid); + VG_(debugLog)(1, "core_os", + "ML_(thread_wrapper)(tid=%lld): entry\n", + (ULong)tidW); + vg_assert(tst->status == VgTs_Init); /* make sure we get the CPU lock before doing anything significant */ diff --git a/coregrind/m_syswrap/syswrap-main.c b/coregrind/m_syswrap/syswrap-main.c index 821164ed8..44393294f 100644 --- a/coregrind/m_syswrap/syswrap-main.c +++ b/coregrind/m_syswrap/syswrap-main.c @@ -405,10 +405,10 @@ static void putSyscallStatusIntoGuestState ( /*IN*/ SyscallStatus* canonical, /*OUT*/VexGuestArchState* gst_vanilla ) { - vg_assert(canonical->what == SsSuccess - || canonical->what == SsFailure); #if defined(VGP_x86_linux) VexGuestX86State* gst = (VexGuestX86State*)gst_vanilla; + vg_assert(canonical->what == SsSuccess + || canonical->what == SsFailure); if (canonical->what == SsFailure) { /* This isn't exactly right, in that really a Failure with res not in the range 1 .. 4095 is unrepresentable in the @@ -419,6 +419,8 @@ void putSyscallStatusIntoGuestState ( /*IN*/ SyscallStatus* canonical, } #elif defined(VGP_amd64_linux) VexGuestAMD64State* gst = (VexGuestAMD64State*)gst_vanilla; + vg_assert(canonical->what == SsSuccess + || canonical->what == SsFailure); if (canonical->what == SsFailure) { /* This isn't exactly right, in that really a Failure with res not in the range 1 .. 4095 is unrepresentable in the @@ -432,6 +434,9 @@ void putSyscallStatusIntoGuestState ( /*IN*/ SyscallStatus* canonical, VexGuestPPC32State* gst = (VexGuestPPC32State*)gst_vanilla; UInt old_cr = LibVEX_GuestPPC32_get_CR(gst); + vg_assert(canonical->what == SsSuccess + || canonical->what == SsFailure); + gst->guest_GPR3 = canonical->val; if (canonical->what == SsFailure) {