| /external/valgrind/include/ |
| pub_tool_basics_asm.h | 44 // VG_/ML_ in both asm and C files.
52 # define VG_(str) VGAPPEND( vgPlain_, str)
55 # define VG_(str) VGAPPEND(_vgPlain_, str)
|
| pub_tool_seqmatch.h | 84 VG_(generic_match) calls (*haveInputInpC)(inputCompleter,ixInput) to
87 Bool VG_(generic_match) (
101 Bool VG_(string_match) ( const HChar* pat, const HChar* str );
|
| pub_tool_aspacemgr.h | 34 #include "pub_tool_basics.h" // VG_ macro
133 extern Int VG_(am_get_segment_starts)( UInt kind_mask, Addr* starts,
139 extern NSegment const * VG_(am_find_nsegment) ( Addr a );
143 extern const HChar* VG_(am_get_filename)( NSegment const * );
151 extern Bool VG_(am_is_valid_for_client) ( Addr start, SizeT len,
154 /* Really just a wrapper around VG_(am_mmap_anon_float_valgrind). */
155 extern void* VG_(am_shadow_alloc)(SizeT size);
159 extern SysRes VG_(am_munmap_valgrind)( Addr start, SizeT length );
|
| pub_tool_addrinfo.h | 34 #include "pub_tool_basics.h" // VG_ macro
92 A tid is an index in the VG_(threads)[] array. The entries
93 in VG_(threads) array are re-used, so the tid in an 'old' _Addrinfo
102 VG_(describe_addr) and the call to VG_(pp_addrinfo), then VG_(pp_addrinfo)
115 extern void VG_(initThreadInfo) (ThreadInfo *tinfo);
206 VG_(clear_addrinfo). */
207 extern void VG_(describe_addr) ( Addr a, /*OUT*/AddrInfo* ai );
209 extern void VG_(clear_addrinfo) ( AddrInfo* ai)
[all...] |
| /external/valgrind/memcheck/ |
| mc_leakcheck.c | 290 // VG_(printf)("find chunk for %p = ", ptr);
326 // VG_(printf)("%d\n", retVal);
345 mallocs = (MC_Chunk**) VG_(HT_to_array)( MC_(malloc_list), &n_mallocs );
351 VG_(ssort)(mallocs, n_mallocs, sizeof(VgHashNode*), compare_MC_Chunks);
355 malloc_chunk_holds_a_pool_chunk = VG_(calloc)( "mc.fas.1",
362 VG_(HT_ResetIter)(MC_(mempool_list));
363 while ( (mp = VG_(HT_Next)(MC_(mempool_list))) ) {
364 VG_(HT_ResetIter)(mp->chunks);
365 while ( (mc = VG_(HT_Next)(mp->chunks)) ) {
392 chunks = VG_(malloc)("mc.fas.2", sizeof(VgHashNode*) * (n_chunks))
[all...] |
| /external/valgrind/coregrind/m_gdbserver/ |
| remote-utils.c | 44 if (VG_(clo_verbosity) > 0 || VG_(debugLog_getLevel)() >= 1) {
47 VG_(show_sched_status) (True, // host_stacktrace
50 VG_(sigprocmask) (0, // dummy how.
53 VG_(dmsg)("current sigmask value { ");
55 if (VG_(sigismember)(&cursigset, i))
56 VG_(dmsg)("%u ", i);
58 VG_(dmsg)("}\n");
62 /* Calls VG_(poll) with given arguments. If VG_(poll) fails due to EINTR
[all...] |
| server.h | 64 Do not call this directly. Rather use VG_(gdb_printf)
66 (e.g. VG_(umsg)) to send output that can either go
92 and does VG_(umsg). If info != NULL, info added in VG_(usmg). */
95 // VG_(gdb_printf) by default writes to vgdb/gdb.
123 do { if (UNLIKELY(VG_(debugLog_getLevel)() >= level)) \
124 VG_(debugLog) (level, "gdbsrv",__VA_ARGS__); } \
140 #define strcmp(s1,s2) VG_(strcmp) ((s1),(s2))
141 #define strncmp(s1,s2,nmax) VG_(strncmp) ((s1),(s2),nmax)
142 #define strcat(s1,s2) VG_(strcat) ((s1),(s2)
[all...] |
| /external/valgrind/coregrind/ |
| m_stacktrace.c | 35 #include "pub_core_aspacemgr.h" // For VG_(is_addressable)()
41 #include "pub_core_stacks.h" // VG_(stack_limits)
44 #include "pub_core_clientstate.h" // VG_(client__dl_sysinfo_int80)
138 UInt VG_(get_StackTrace_wrk) ( ThreadId tid_if_known,
160 // = VG_(debugLog_getLevel) () > 3;
179 const Int cmrf = VG_(clo_merge_recursive_frames);
208 VG_(printf)("max_n_ips=%d fp_min=0x%08lx fp_max_orig=0x08%lx, "
229 if (UNLIKELY (fp_CF_verif_generation != VG_(CF_info_generation)())) {
230 fp_CF_verif_generation = VG_(CF_info_generation)();
231 VG_(memset)(&fp_CF_verif_cache, 0, sizeof(fp_CF_verif_cache))
[all...] |
| m_poolalloc.c | 51 PoolAlloc* VG_(newPA) ( UWord elemSzB,
65 VG_(memset)(pa, 0, sizeof(*pa));
73 pa->pools = VG_(newXA)( alloc_fn, cc, free_fn, sizeof(void*) );
79 void VG_(deletePA) ( PoolAlloc* pa)
83 for (i = 0; i < VG_(sizeXA) (pa->pools); i++)
84 pa->free_fn (*(UWord **)VG_(indexXA) ( pa->pools, i ));
85 VG_(deleteXA) (pa->pools);
110 VG_(addToXA)( pa->pools, &pool );
113 UWord VG_(sizePA) ( PoolAlloc* pa)
116 return pa->nPerPool * VG_(sizeXA) (pa->pools)
[all...] |
| pub_core_machine.h | 179 //Addr VG_(get_IP) ( ThreadId tid ); // in pub_tool_machine.h
180 //Addr VG_(get_SP) ( ThreadId tid ); // in pub_tool_machine.h
181 Addr VG_(get_FP) ( ThreadId tid );
183 void VG_(set_IP) ( ThreadId tid, Addr encip );
184 void VG_(set_SP) ( ThreadId tid, Addr sp );
190 void VG_(get_UnwindStartRegs) ( /*OUT*/UnwindStartRegs* regs,
203 x86: initially: call VG_(machine_get_hwcaps)
205 then safe to use VG_(machine_get_VexArchInfo)
206 and VG_(machine_x86_have_mxcsr)
208 amd64: initially: call VG_(machine_get_hwcaps
[all...] |
| m_stacks.c | 42 #define EDEBUG(fmt, args...) //VG_(debugLog)(2, "stacks", fmt, ## args)
157 VG_(printf)("(hgdev) %lu searches, %lu steps, %lu fails\n",
182 UWord VG_(register_stack)(Addr start, Addr end)
195 i = VG_(malloc)("stacks.rs.1", sizeof(Stack));
206 VG_(debugLog)(2, "stacks", "register [start-end] [%p-%p] as stack %lu\n",
216 void VG_(deregister_stack)(UWord id)
221 VG_(debugLog)(2, "stacks", "deregister stack %lu\n", id);
234 VG_(free)(i);
247 void VG_(change_stack)(UWord id, Addr start, Addr end)
253 VG_(debugLog)(2, "stacks",
[all...] |
| m_execontext.c | 34 #include "pub_core_libcprint.h" // For VG_(message)()
38 #include "pub_core_machine.h" // VG_(get_IP)
39 #include "pub_core_threadstate.h" // VG_(is_valid_tid)
140 ec_htab = VG_(malloc)("execontext.iEs1",
158 void VG_(print_ExeContext_stats) ( Bool with_stacktraces )
167 VG_(message)(Vg_DebugMsg, " exectx: Printing contexts stacktraces\n");
170 VG_(message)(Vg_DebugMsg, " exectx: stacktrace ecu %u n_ips %u\n",
172 VG_(pp_StackTrace)( ec->ips, ec->n_ips );
175 VG_(message)(Vg_DebugMsg,
185 VG_(message)(Vg_DebugMsg,
[all...] |
| /external/valgrind/helgrind/ |
| hg_errors.c | 43 #include "pub_tool_options.h" // VG_(clo_xml)
66 return string_table ? (ULong)VG_(sizeFM)(string_table) : 0;
70 return (Word)VG_(strcmp)( (HChar*)s1, (HChar*)s2 );
79 string_table = VG_(newFM)( HG_(zalloc), "hg.sts.1",
82 if (VG_(lookupFM)( string_table,
85 if (0) VG_(printf)("string_table_strdup: %p -> %p\n", str, copy );
89 VG_(addToFM)( string_table, (UWord)copy, (UWord)copy );
101 return map_LockN_to_P ? (ULong)VG_(sizeFM)(map_LockN_to_P) : 0;
166 map_LockN_to_P = VG_(newFM)( HG_(zalloc), "hg.mLPfLN.1",
169 if (!VG_(lookupFM)( map_LockN_to_P, NULL, (UWord*)&lkp, (UWord)lkn))
[all...] |
| /external/valgrind/coregrind/m_dispatch/ |
| dispatch-amd64-darwin.S | 42 /*--- The dispatch loop. VG_(disp_run_translations) is ---*/
53 void VG_(disp_run_translations)( UWord* two_words,
58 .globl VG_(disp_run_translations)
59 VG_(disp_run_translations):
110 VG_(cp_...) below. */
175 .globl VG_(disp_cp_chain_me_to_slowEP)
176 VG_(disp_cp_chain_me_to_slowEP):
183 /* 10 = movabsq $VG_(disp_chain_me_to_slowEP), %r11;
189 .globl VG_(disp_cp_chain_me_to_fastEP)
190 VG_(disp_cp_chain_me_to_fastEP)
[all...] |
| dispatch-tilegx-linux.S | 40 /*--- The dispatch loop. VG_(run_innerloop) is used to ---*/
50 void VG_(disp_run_translations)(UWord* two_words,
53 UWord VG_(run_innerloop) ( void* guest_state, UWord do_profiling );
57 .globl VG_(disp_run_translations)
58 VG_(disp_run_translations):
183 .global VG_(disp_cp_chain_me_to_slowEP)
184 VG_(disp_cp_chain_me_to_slowEP):
201 .global VG_(disp_cp_chain_me_to_fastEP)
202 VG_(disp_cp_chain_me_to_fastEP):
219 .global VG_(disp_cp_xindir
[all...] |
| /external/valgrind/exp-sgcheck/ |
| h_main.c | 51 #include "pub_tool_aspacemgr.h" // VG_(am_shadow_malloc)
53 #include "pub_tool_machine.h" // VG_({get,set}_shadow_regs_area) et al
54 #include "pub_tool_debuginfo.h" // VG_(get_fnname)
55 #include "pub_tool_threadstate.h" // VG_(get_running_tid)
163 SegGroup* g = VG_(malloc)("pc.h_main.nTG.1", sizeof(SegGroup));
164 VG_(memset)(g, 0, sizeof(*g));
244 addr_to_seg_map = VG_(newFM)( VG_(malloc), "pc.h_main.attmEI.1",
245 VG_(free), NULL/*unboxedcmp*/ );
253 if (VG_(lookupFM)( addr_to_seg_map, &keyW, &valW, (UWord)ga ))
[all...] |
| /external/valgrind/coregrind/m_debuginfo/ |
| storage.c | 41 #include "pub_core_options.h" /* VG_(clo_verbosity) */
62 /* Show a non-fatal debug info reading error. Use VG_(core_panic) for
68 if (VG_(clo_xml))
73 VG_(message)(Vg_DebugMsg, "WARNING: Serious error when "
75 if (True || VG_(clo_verbosity) < 2) {
78 VG_(message)(Vg_DebugMsg,
83 VG_(message)(Vg_DebugMsg, "%s\n", msg);
87 if (VG_(clo_verbosity) >= 2)
88 VG_(message)(Vg_DebugMsg, "%s\n", msg);
101 VG_(printf)( "%5d: %c%c %#8lx .. %#8lx (%d) %s%s"
[all...] |
| /external/valgrind/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_core_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)()
81 seg = VG_(am_find_nsegment)(sp);
83 VG_(am_is_valid_for_client)(sp, 1, VKI_PROT_READ | VKI_PROT_WRITE)) {
87 VG_(register_stack)(seg->start, tst->client_stack_highest_byte)
[all...] |
| /external/valgrind/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)() */
119 VG_(maybe_record_error)(VG_(get_running_tid)(),
121 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/coregrind/m_demangle/ |
| demangle.c | 53 Therefore, VG_(demangle) first tries to undo (2). If successful,
89 that buffer is owned by VG_(demangle). That means two things:
90 (1) Users of VG_(demangle) must not free that buffer.
94 after the next VG_(demangle) invocation. */
95 void VG_(demangle) ( Bool do_cxx_demangling, Bool do_z_demangling,
107 if (VG_(maybe_Z_demangle)( orig, NULL, /*soname*/
114 if (do_cxx_demangling && VG_(clo_demangle)) {
118 if (demangled) VG_(arena_free) (VG_AR_DEMANGLE, demangled);
128 // by calling the (now-removed) function VG_(is_empty_arena)(). But,
151 Bool VG_(maybe_Z_demangle) ( const HChar* sym,
[all...] |
| /external/valgrind/lackey/ |
| lk_main.c | 179 #include "pub_tool_machine.h" // VG_(fnptr_to_fnentry)
214 VG_(printf)(
226 VG_(printf)(
378 VG_(fnptr_to_fnentry)( &increment_detail ),
388 VG_(umsg)(" Type Loads Stores AluOps\n");
389 VG_(umsg)(" -------------------------------------------\n");
391 VG_(umsg)(" %-4s %'12llu %'12llu %'12llu\n",
459 VG_(printf)("I %08lx,%lu\n", addr, size);
464 VG_(printf)(" L %08lx,%lu\n", addr, size);
469 VG_(printf)(" S %08lx,%lu\n", addr, size)
[all...] |
| /external/valgrind/cachegrind/ |
| cg_arch.c | 48 (-1 == VG_(log2)(cache->size/cache->line_size/cache->assoc)))
54 if (-1 == VG_(log2)(cache->line_size)) {
87 i1 = VG_(strtoll10)(optval, &endptr); if (*endptr != ',') goto bad;
88 i2 = VG_(strtoll10)(endptr+1, &endptr); if (*endptr != ',') goto bad;
89 i3 = VG_(strtoll10)(endptr+1, &endptr); if (*endptr != '\0') goto bad;
101 VG_(fmsg)("%s", checkRes);
108 VG_(fmsg_bad_option)(opt, "Bad argument '%s'\n", optval);
111 VG_(fmsg_bad_option)(opt,
116 Bool VG_(str_clo_cache_opt)(const HChar *arg,
139 VG_(umsg)(" %s: %'d B, %d-way, %d B lines\n", desc
[all...] |
| cg_main.c | 45 #include "pub_tool_machine.h" // VG_(fnptr_to_fnentry)
121 res = VG_(strcmp)(a->file, b->file);
125 res = VG_(strcmp)(a->fn, b->fn);
188 return VG_(strcmp)(*(const HChar *const *)key, *(const HChar *const *)elem);
195 HChar** s_ptr = VG_(OSetGen_Lookup)(stringTable, &s);
199 HChar** s_node = VG_(OSetGen_AllocNode)(stringTable, sizeof(HChar*));
200 *s_node = VG_(strdup)("cg.main.gps.1", s);
201 VG_(OSetGen_Insert)(stringTable, s_node);
213 Bool found_file_line = VG_(get_filename_linenum)(
218 Bool found_fn = VG_(get_fnname)(instr_addr, fn)
[all...] |
| /external/valgrind/massif/ |
| ms_main.c | 75 // VG_(bsearch) function.
219 if (VG_(clo_verbosity) > verb) { \
220 VG_(dmsg)("Massif: " format, ##args); \
300 alloc_fns = VG_(newXA)(VG_(malloc), "ms.main.iaf.1",
301 VG_(free), sizeof(HChar*));
302 #define DO(x) { const HChar* s = x; VG_(addToXA)(alloc_fns, &s); }
347 ignore_fns = VG_(newXA)(VG_(malloc), "ms.main.iif.1",
348 VG_(free), sizeof(HChar*))
[all...] |
