| /external/valgrind/main/helgrind/ |
| hg_main.c | 52 #include "pub_tool_debuginfo.h" // VG_(find_seginfo), VG_(seginfo_soname)
55 #include "pub_tool_libcproc.h" // VG_(atfork)
56 #include "pub_tool_aspacemgr.h" // VG_(am_is_valid_for_client)
213 VG_(deleteBag)( lk->heldBy );
228 VG_(memset)(lk, 0xAA, sizeof(*lk));
250 = VG_(record_ExeContext)(tid, 0/*first_ip_delta*/);
262 lk->heldBy = VG_(newBag)( HG_(zalloc), "hg.lNaw.1", HG_(free) );
263 VG_(addToBag)( lk->heldBy, (Word)thr );
271 tl_assert(VG_(sizeUniqueBag(lk->heldBy)) == 1)
[all...] |
| hg_errors.c | 42 #include "pub_tool_options.h" // VG_(clo_xml)
62 return string_table ? (ULong)VG_(sizeFM)(string_table) : 0;
66 return (Word)VG_(strcmp)( (HChar*)s1, (HChar*)s2 );
75 string_table = VG_(newFM)( HG_(zalloc), "hg.sts.1",
79 if (VG_(lookupFM)( string_table,
82 if (0) VG_(printf)("string_table_strdup: %p -> %p\n", str, copy );
87 VG_(addToFM)( string_table, (Word)copy, (Word)copy );
99 return map_LockN_to_P ? (ULong)VG_(sizeFM)(map_LockN_to_P) : 0;
164 map_LockN_to_P = VG_(newFM)( HG_(zalloc), "hg.mLPfLN.1",
168 if (!VG_(lookupFM)( map_LockN_to_P, NULL, (Word*)&lkp, (Word)lkn))
[all...] |
| /external/valgrind/main/memcheck/ |
| mc_leakcheck.c | 288 // VG_(printf)("find chunk for %p = ", ptr);
324 // VG_(printf)("%d\n", retVal);
343 mallocs = (MC_Chunk**) VG_(HT_to_array)( MC_(malloc_list), &n_mallocs );
349 VG_(ssort)(mallocs, n_mallocs, sizeof(VgHashNode*), compare_MC_Chunks);
353 malloc_chunk_holds_a_pool_chunk = VG_(calloc)( "mc.fas.1",
360 VG_(HT_ResetIter)(MC_(mempool_list));
361 while ( (mp = VG_(HT_Next)(MC_(mempool_list))) ) {
362 VG_(HT_ResetIter)(mp->chunks);
363 while ( (mc = VG_(HT_Next)(mp->chunks)) ) {
390 chunks = VG_(malloc)("mc.fas.2", sizeof(VgHashNode*) * (n_chunks))
[all...] |
| /external/valgrind/main/drd/ |
| drd_mutex.c | 30 #include "pub_tool_errormgr.h" /* VG_(maybe_record_error)() */
32 #include "pub_tool_libcbase.h" /* VG_(strlen) */
33 #include "pub_tool_libcprint.h" /* VG_(message)() */
34 #include "pub_tool_libcproc.h" /* VG_(read_millisecond_timer)() */
35 #include "pub_tool_machine.h" /* VG_(get_IP)() */
36 #include "pub_tool_threadstate.h" /* VG_(get_running_tid)() */
101 VG_(maybe_record_error)(VG_(get_running_tid)(),
103 VG_(get_IP)(VG_(get_running_tid)())
[all...] |
| drd_hb.c | 28 #include "pub_tool_errormgr.h" /* VG_(maybe_record_error)() */
30 #include "pub_tool_libcprint.h" /* VG_(printf)() */
31 #include "pub_tool_machine.h" /* VG_(get_IP)() */
32 #include "pub_tool_mallocfree.h" /* VG_(malloc)(), VG_(free)()*/
33 #include "pub_tool_threadstate.h" /* VG_(get_running_tid)() */
94 p->oset = VG_(OSetGen_Create)(0, 0, VG_(malloc), "drd.hb",
95 VG_(free));
107 VG_(OSetGen_ResetIter)(p->oset)
[all...] |
| /external/valgrind/main/coregrind/m_demangle/ |
| demangle.c | 53 Therefore, VG_(demangle) first tries to undo (2). If successful,
89 void VG_(demangle) ( Bool do_cxx_demangling, Bool do_z_demangling,
102 if (VG_(maybe_Z_demangle)( orig, NULL,0,/*soname*/
109 if (do_cxx_demangling && VG_(clo_demangle)) {
115 VG_(strncpy_safely)(result, demangled, result_size);
116 VG_(arena_free) (VG_AR_DEMANGLE, demangled);
118 VG_(strncpy_safely)(result, orig, result_size);
122 // by calling the (now-removed) function VG_(is_empty_arena)(). But,
146 Bool VG_(maybe_Z_demangle) ( const HChar* sym,
186 && VG_(isdigit)(sym[4]
[all...] |
| /external/valgrind/main/coregrind/ |
| m_translate.c | 36 #include "pub_core_machine.h" // VG_(fnptr_to_fnentry)
37 // VG_(get_SP)
38 // VG_(machine_get_VexArchInfo)
44 #include "pub_core_debuginfo.h" // VG_(get_fnname_w_offset)
45 #include "pub_core_redir.h" // VG_(redir_do_lookup)
47 #include "pub_core_signals.h" // VG_(synth_fault_{perms,mapping}
48 #include "pub_core_stacks.h" // VG_(unknown_SP_update)()
49 #include "pub_core_tooliface.h" // VG_(tdict)
53 #include "pub_core_dispatch.h" // VG_(run_innerloop__dispatch_{un}profiled)
54 // VG_(run_a_noredir_translation__return_point
[all...] |
| m_poolalloc.c | 51 PoolAlloc* VG_(newPA) ( UWord elemSzB,
66 VG_(memset)(pa, 0, sizeof(*pa));
74 pa->pools = VG_(newXA)( alloc, cc, free_fn, sizeof(void*) );
80 void VG_(deletePA) ( PoolAlloc* pa)
84 for (i = 0; i < VG_(sizeXA) (pa->pools); i++)
85 pa->free (*(UWord **)VG_(indexXA) ( pa->pools, i ));
86 VG_(deleteXA) (pa->pools);
112 VG_(addToXA)( pa->pools, &pool );
115 void* VG_(allocEltPA) ( PoolAlloc* pa)
127 void VG_(freeEltPA) ( PoolAlloc* pa, void* p
[all...] |
| m_stacktrace.c | 36 #include "pub_core_aspacemgr.h" // For VG_(is_addressable)()
42 #include "pub_core_stacks.h" // VG_(stack_limits)
45 #include "pub_core_clientstate.h" // VG_(client__dl_sysinfo_int80)
69 UInt VG_(get_StackTrace_wrk) ( ThreadId tid_if_known,
101 VG_(printf)("max_n_ips=%d fp_min=0x%lx fp_max_orig=0x%lx, "
178 VG_(printf)(" ipsF[%d]=0x%08lx\n", i-1, ips[i-1]);
186 if ( VG_(use_CF_info)( &uregs, fp_min, fp_max ) ) {
192 VG_(printf)(" ipsC[%d]=0x%08lx\n", i-1, ips[i-1]);
199 if ( VG_(use_FPO_info)( &uregs.xip, &uregs.xsp, &uregs.xbp,
206 VG_(printf)(" ipsC[%d]=0x%08lx\n", i-1, ips[i-1])
[all...] |
| m_stacks.c | 153 VG_(printf)("(hgdev) %lu searches, %lu steps, %lu fails\n",
178 UWord VG_(register_stack)(Addr start, Addr end)
188 i = (Stack *)VG_(arena_malloc)(VG_AR_CORE, "stacks.rs.1", sizeof(Stack));
199 VG_(debugLog)(2, "stacks", "register %p-%p as stack %lu\n",
209 void VG_(deregister_stack)(UWord id)
214 VG_(debugLog)(2, "stacks", "deregister stack %lu\n", id);
227 VG_(arena_free)(VG_AR_CORE, i);
240 void VG_(change_stack)(UWord id, Addr start, Addr end)
246 VG_(debugLog)(2, "stacks", "change stack %lu from %p-%p to %p-%p\n",
261 void VG_(stack_limits)(Addr SP, Addr *start, Addr *end
[all...] |
| pub_core_ume.h | 81 extern SysRes VG_(pre_exec_check)(const HChar* exe_name, Int* out_fd,
88 extern Int VG_(do_exec)(const HChar* exe, ExeInfo* info);
|
| m_mallocfree.c | 55 Long VG_(free_queue_volume) = 0;
56 Long VG_(free_queue_length) = 0;
430 vg_assert( VG_(clo_profile_heap) );
437 vg_assert( VG_(clo_profile_heap) );
498 SizeT VG_(malloc_effective_client_redzone_size)(void)
500 vg_assert(VG_(needs).malloc_replacement);
509 // It might be overriden by VG_(clo_redzone_size) or VG_(clo_core_redzone_size).
526 if (VG_(clo_redzone_size) != -1)
527 rz_szB = VG_(clo_redzone_size)
[all...] |
| m_xarray.c | 53 XArray* VG_(newXA) ( void*(*alloc_fn)(HChar*,SizeT),
82 XArray* VG_(cloneXA)( HChar* cc, XArray* xao )
112 VG_(memcpy)( nyu->arr, xa->arr, nyu->totsizeE * nyu->elemSzB );
118 void VG_(deleteXA) ( XArray* xao )
128 void VG_(setCmpFnXA) ( XArray* xao, Int (*compar)(void*,void*) )
137 inline void* VG_(indexXA) ( XArray* xao, Word n )
168 VG_(printf)("addToXA: increasing from %ld to %ld\n",
173 VG_(memcpy)(tmp, xa->arr, xa->usedsizeE * xa->elemSzB);
181 Word VG_(addToXA) ( XArray* xao, void* elem )
191 VG_(memcpy)( ((UChar*)xa->arr) + xa->usedsizeE * xa->elemSzB
[all...] |
| pub_core_threadstate.h | 36 // VG_(threads)[] data structure which holds all the important thread
367 extern ThreadState VG_(threads)[VG_N_THREADS];
371 extern ThreadId VG_(running_tid);
379 void VG_(init_Threads)(void);
382 const HChar* VG_(name_of_ThreadStatus) ( ThreadStatus status );
385 extern ThreadState *VG_(get_ThreadState) ( ThreadId tid );
388 extern Bool VG_(is_valid_tid) ( ThreadId tid );
391 extern Bool VG_(is_running_thread)(ThreadId tid);
394 extern Bool VG_(is_exiting)(ThreadId tid);
397 extern Int VG_(count_living_threads)(void)
[all...] |
| /external/valgrind/main/lackey/ |
| lk_main.c | 179 #include "pub_tool_machine.h" // VG_(fnptr_to_fnentry)
214 VG_(printf)(
226 VG_(printf)(
364 VG_(fnptr_to_fnentry)( &increment_detail ),
373 VG_(umsg)(" Type Loads Stores AluOps\n");
374 VG_(umsg)(" -------------------------------------------\n");
376 VG_(umsg)(" %4s %'12llu %'12llu %'12llu\n",
446 VG_(printf)("I %08lx,%lu\n", addr, size);
451 VG_(printf)(" L %08lx,%lu\n", addr, size);
456 VG_(printf)(" S %08lx,%lu\n", addr, size)
[all...] |
| /external/valgrind/main/coregrind/m_syswrap/ |
| syswrap-generic.c | 39 #include "pub_core_debuginfo.h" // VG_(di_notify_*)
41 #include "pub_core_transtab.h" // VG_(discard_translations)
43 #include "pub_core_clientstate.h" // VG_(brk_base), VG_(brk_limit)
46 #include "pub_tool_gdbserver.h" // VG_(gdbserver)
53 #include "pub_core_machine.h" // VG_(get_SP)
58 #include "pub_core_stacktrace.h" // For VG_(get_and_pp_StackTrace)()
82 ret = VG_(am_is_valid_for_client_or_free_or_resvn)
86 VG_(printf)("%s: test=%#lx-%#lx ret=%d\n",
90 VG_(message)(Vg_UserMsg, "Warning: client syscall %s tried
[all...] |
| /external/valgrind/main/callgrind/ |
| main.c | 276 VG_(memset)(ev, 0, sizeof(Event));
333 VG_(printf)("Ir (InstrInfo %p) at +%d\n",
337 VG_(printf)("Dr (InstrInfo %p) at +%d %d EA=",
340 VG_(printf)("\n");
343 VG_(printf)("Dw (InstrInfo %p) at +%d %d EA=",
346 VG_(printf)("\n");
349 VG_(printf)("Dm (InstrInfo %p) at +%d %d EA=",
352 VG_(printf)("\n");
355 VG_(printf)("Bc %p GA=", ev->inode);
357 VG_(printf)("\n")
[all...] |
| /external/valgrind/main/massif/ |
| ms_main.c | 81 // VG_(bsearch) function.
225 if (VG_(clo_verbosity) > verb) { \
226 VG_(dmsg)("Massif: " format, ##args); \
231 if (VG_(clo_stats)) { \
232 VG_(dmsg)("Massif: " format, ##args); \
312 alloc_fns = VG_(newXA)(VG_(malloc), "ms.main.iaf.1",
313 VG_(free), sizeof(Char*));
314 #define DO(x) { Char* s = x; VG_(addToXA)(alloc_fns, &s); }
359 ignore_fns = VG_(newXA)(VG_(malloc), "ms.main.iif.1"
[all...] |
| /external/valgrind/main/coregrind/m_gdbserver/ |
| server.h | 66 Do not call this directly. Rather use VG_(monitor_print)
68 (e.g. VG_(umsg)) to send output that can either go
94 and does VG_(umsg). If info != NULL, info added in VG_(usmg). */
120 do { if (UNLIKELY(VG_(debugLog_getLevel)() >= level)) \
121 VG_(debugLog) (level, "gdbsrv",__VA_ARGS__); } \
137 #define strcmp(s1,s2) VG_(strcmp) ((Char *)(s1),(Char *)(s2))
138 #define strncmp(s1,s2,nmax) VG_(strncmp) ((Char *)(s1),(Char *)(s2),nmax)
139 #define strcat(s1,s2) VG_(strcat) ((Char *)(s1),(Char *)(s2))
140 #define strcpy(s1,s2) VG_(strcpy) ((Char *)(s1),(Char *)(s2)
[all...] |
| target.c | 47 VG_(sprintf) (result, "id %ld", ptid);
55 if (!VG_(lwpid_to_vgtid)(thread_to_gdb_id(thread))) {
78 ti, tid, VG_(name_of_ThreadStatus) (ts->status), \
81 if (VG_(is_valid_tid) (tid)) {
82 ts = VG_(get_ThreadState) (tid);
129 void VG_(set_watchpoint_stop_address) (Addr addr)
172 VG_(describe_IP) (addr, buf, 200);
231 VG_(set_watchpoint_stop_address) ((Addr) 0);
252 pid = VG_(getpid) ();
270 tst = VG_(get_ThreadState) (vgdb_interrupted_tid)
[all...] |
| /external/valgrind/main/coregrind/m_sigframe/ |
| sigframe-amd64-darwin.c | 109 void VG_(sigframe_create) ( ThreadId tid,
130 tst = VG_(get_ThreadState)(tid);
139 VG_(memset)(&frame->lower_guardzone, 0, 512);
140 VG_(memset)(&frame->gst, 0, sizeof(VexGuestAMD64State));
141 VG_(memset)(&frame->gshadow1, 0, sizeof(VexGuestAMD64State));
142 VG_(memset)(&frame->gshadow2, 0, sizeof(VexGuestAMD64State));
143 VG_(memset)(&frame->fake_siginfo, 0, sizeof(frame->fake_siginfo));
144 VG_(memset)(&frame->fake_ucontext, 0, sizeof(frame->fake_ucontext));
161 VG_(set_SP)(tid, rsp);
165 VG_(set_IP)(tid, (ULong)handler)
[all...] |
| sigframe-x86-darwin.c | 112 void VG_(sigframe_create) ( ThreadId tid,
133 tst = VG_(get_ThreadState)(tid);
142 VG_(memset)(&frame->lower_guardzone, 0, 512);
143 VG_(memset)(&frame->gst, 0, sizeof(VexGuestX86State));
144 VG_(memset)(&frame->gshadow1, 0, sizeof(VexGuestX86State));
145 VG_(memset)(&frame->gshadow2, 0, sizeof(VexGuestX86State));
146 VG_(memset)(&frame->fake_siginfo, 0, sizeof(frame->fake_siginfo));
147 VG_(memset)(&frame->fake_ucontext, 0, sizeof(frame->fake_ucontext));
164 VG_(set_SP)(tid, esp);
168 VG_(set_IP)(tid, (UInt)handler)
[all...] |
| /external/valgrind/main/coregrind/m_debuginfo/ |
| tytypes.c | 73 VG_(printf)("{");
74 for (i = 0; i < VG_(sizeXA)(xa); i++) {
75 UWord cuOff = *(UWord*)VG_(indexXA)(xa, i);
76 VG_(printf)("0x%05lx", cuOff);
77 if (i+1 < VG_(sizeXA)(xa))
78 VG_(printf)(",");
80 VG_(printf)("}");
85 VG_(printf)("0x%05lx ", te->cuOff);
88 VG_(printf)("EMPTY");
91 VG_(printf)("INDIR(0x%05lx)", te->Te.INDIR.indR)
[all...] |
| debuginfo.c | 42 #include "pub_core_libcproc.h" // VG_(getenv)
45 #include "pub_core_redir.h" // VG_(redir_notify_{new,delete}_SegInfo)
50 #include "pub_core_stacktrace.h" // VG_(get_StackTrace) XXX: circular dependency
181 di->fsm.maps = VG_(newXA)(
188 = VG_(string_match)( VG_(clo_trace_symtab_patt), filename );
190 di->trace_symtab = VG_(clo_trace_symtab);
191 di->trace_cfi = VG_(clo_trace_cfi);
192 di->ddump_syms = VG_(clo_debug_dump_syms);
193 di->ddump_line = VG_(clo_debug_dump_line)
[all...] |
| /external/valgrind/main/coregrind/m_ume/ |
| macho.c | 38 #include "pub_core_libcassert.h" // VG_(exit), vg_assert
39 #include "pub_core_libcbase.h" // VG_(memcmp), etc
40 #include "pub_core_libcfile.h" // VG_(open) et al
44 #include "pub_core_mallocfree.h" // VG_(malloc), VG_(free)
45 #include "pub_core_syscall.h" // VG_(strerror)
73 VG_(printf)("%s", str);
79 VG_(printf)("valgrind: mmap-FIXED(0x%llx, %lld) failed in UME (%s).\n",
81 VG_(exit)(1);
89 VG_(printf)("valgrind: mmap-FLOAT(size=%lld) failed in UME (%s).\n",
[all...] |
