| /external/valgrind/coregrind/m_initimg/ |
| initimg-linux.c | 67 /* Load the client whose name is VG_(argv_the_exename). */
77 vg_assert( VG_(args_the_exename) != NULL);
78 exe_name = ML_(find_executable)( VG_(args_the_exename) );
81 VG_(printf)("valgrind: %s: command not found\n", VG_(args_the_exename));
82 VG_(exit)(127); // 127 is Posix NOTFOUND
85 VG_(memset)(info, 0, sizeof(*info));
86 ret = VG_(do_exec)(exe_name, info);
88 VG_(printf)("valgrind: could not execute '%s'\n", exe_name);
89 VG_(exit)(1)
[all...] |
| /external/valgrind/cachegrind/ |
| cg_arch.h | 43 // clo_*c used in the call to VG_(str_clo_cache_opt) should be statically
50 Bool VG_(str_clo_cache_opt)(const HChar *arg,
61 void VG_(post_clo_init_configure_caches)(cache_t* I1c,
68 void VG_(print_cache_clo_opts)(void);
|
| /external/valgrind/coregrind/ |
| m_addrinfo.c | 58 VG_(stack_limits)(a, &start, &end);
71 So, scan all 'active' stacks with VG_(thread_stack_reset_iter) ... */
75 VG_(thread_stack_reset_iter)(&tid);
76 while ( VG_(thread_stack_next)(&tid, &stack_min, &stack_max) ) {
89 void VG_(describe_addr) ( Addr a, /*OUT*/AddrInfo* ai )
95 = VG_(newXA)( VG_(malloc), "mc.da.descr1",
96 VG_(free), sizeof(HChar) );
98 = VG_(newXA)( VG_(malloc), "mc.da.descr2"
[all...] |
| m_vkiscnums.c | 47 const HChar* VG_(sysnum_string)(Word sysnum)
51 VG_(sprintf)(buf, "%ld", sysnum);
59 const HChar* VG_(sysnum_string)(Word sysnum)
71 VG_(sprintf)(buf, "%s:%ld", classname, VG_DARWIN_SYSNO_INDEX(sysnum));
|
| pub_core_aspacemgr.h | 62 extern Addr VG_(am_startup) ( Addr sp_at_startup );
66 extern Bool VG_(am_is_valid_for_aspacem_minAddr)( Addr addr,
75 extern NSegment const* VG_(am_next_nsegment) ( const NSegment* here,
84 extern Bool VG_(am_is_valid_for_valgrind)
87 /* Variant of VG_(am_is_valid_for_client) which allows free areas to
91 extern Bool VG_(am_is_valid_for_client_or_free_or_resvn)
96 extern Bool VG_(am_addr_is_in_extensible_client_stack)( Addr addr );
101 extern ULong VG_(am_get_anonsize_total)( void );
104 extern void VG_(am_show_nsegments) ( Int logLevel, const HChar* who );
106 /* VG_(am_get_segment_starts) is also part of this section, but it
[all...] |
| m_libcprint.c | 35 #include "pub_core_gdbserver.h" // VG_(gdb_printf)
38 #include "pub_core_libcfile.h" // VG_(write)(), VG_(write_socket)()
40 #include "pub_core_libcproc.h" // VG_(getpid)(), VG_(read_millisecond_timer()
41 #include "pub_core_mallocfree.h" // VG_(malloc)
57 OutputSink VG_(log_output_sink) = { 2, False }; /* 2 = stderr */
58 OutputSink VG_(xml_output_sink) = { -1, False }; /* disabled */
65 Int rc = VG_(write_socket)( sink->fd, msg, nbytes );
70 VG_(write)( sink->fd, msg, nbytes )
[all...] |
| m_compiler.c | 152 return VG_(memcpy)( dest, src, sz );
158 return VG_(memcpy)( dest, src, sz );
164 return VG_(memcpy)( dest, src, sz );
170 return VG_(memcpy)( dest, src, sz );
176 return VG_(memcpy)( dest, src, sz );
182 return VG_(memcpy)( dest, src, sz );
188 return VG_(memcpy)( dest, src, sz );
194 return VG_(memset)( dest, value, num );
200 return VG_(memset)( dest, value, num );
206 return VG_(memset)( dest, value, num );
[all...] |
| m_libcfile.c | 39 #include "pub_core_libcprint.h" // VG_(sprintf)
40 #include "pub_core_libcproc.h" // VG_(getpid), VG_(getppid)
41 #include "pub_core_clientstate.h" // VG_(fd_hard_limit)
42 #include "pub_core_mallocfree.h" // VG_(realloc)
55 Int VG_(safe_fd)(Int oldfd)
59 vg_assert(VG_(fd_hard_limit) != -1);
61 newfd = VG_(fcntl)(oldfd, VKI_F_DUPFD, VG_(fd_hard_limit));
63 VG_(close)(oldfd)
[all...] |
| m_signals.c | 110 VG_(poll_signals), which calls through to VG_(sigtimedwait_zero) to
189 blocked, but we can and do poll for them using VG_(poll_signals).
191 Now, re VG_(poll_signals), it polls the kernel by doing
192 VG_(sigtimedwait_zero). This is trivial on Linux, since it's just a
198 scheduler/delivering the signal, a call to VG_(gdbserver_report_signal)
210 #include "pub_core_debugger.h" // For VG_(start_debugger)
223 #include "pub_core_sigframe.h" // For VG_(sigframe_create)()
224 #include "pub_core_stacks.h" // For VG_(change_stack)()
225 #include "pub_core_stacktrace.h" // For VG_(get_and_pp_StackTrace)(
[all...] |
| m_machine.c | 48 Addr VG_(get_IP) ( ThreadId tid ) {
49 return INSTR_PTR( VG_(threads)[tid].arch );
51 Addr VG_(get_SP) ( ThreadId tid ) {
52 return STACK_PTR( VG_(threads)[tid].arch );
54 Addr VG_(get_FP) ( ThreadId tid ) {
55 return FRAME_PTR( VG_(threads)[tid].arch );
58 void VG_(set_IP) ( ThreadId tid, Addr ip ) {
59 INSTR_PTR( VG_(threads)[tid].arch ) = ip;
61 void VG_(set_SP) ( ThreadId tid, Addr sp ) {
62 STACK_PTR( VG_(threads)[tid].arch ) = sp
[all...] |
| pub_core_cpuid.h | 34 #include "pub_core_basics.h" // VG_ macro
42 extern Bool VG_(has_cpuid) ( void );
44 extern void VG_(cpuid) ( UInt eax, UInt ecx,
|
| pub_core_demangle.h | 34 #include "pub_core_basics.h" // VG_ macro
45 void VG_(demangle) ( Bool do_cxx_demangling, Bool do_z_demangling,
61 Bool VG_(maybe_Z_demangle) ( const HChar* sym,
|
| pub_core_sigframe.h | 35 #include "pub_core_basics.h" // VG_ macro
46 void VG_(sigframe_create) ( ThreadId tid,
58 void VG_(sigframe_destroy)( ThreadId tid, Bool isRT );
|
| /external/valgrind/coregrind/m_dispatch/ |
| dispatch-arm-linux.S | 43 /*--- The dispatch loop. VG_(disp_run_translations) is ---*/
54 void VG_(disp_run_translations)( UWord* two_words,
59 .global VG_(disp_run_translations)
60 VG_(disp_run_translations):
80 VG_(cp_...) below. */
120 .global VG_(disp_cp_chain_me_to_slowEP)
121 VG_(disp_cp_chain_me_to_slowEP):
135 .global VG_(disp_cp_chain_me_to_fastEP)
136 VG_(disp_cp_chain_me_to_fastEP):
150 .global VG_(disp_cp_xindir
[all...] |
| dispatch-ppc32-linux.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 .type VG_(disp_run_translations), @function
60 VG_(disp_run_translations):
65 /* ----- entry point to VG_(disp_run_translations) ----- */
81 lis 6,VG_(machine_ppc32_has_FP)@ha
82 lwz 6,VG_(machine_ppc32_has_FP)@l(6)
133 lis 6,VG_(machine_ppc32_has_VMX)@ha
134 lwz 6,VG_(machine_ppc32_has_VMX)@l(6
[all...] |
| /external/valgrind/drd/ |
| drd_barrier.c | 29 #include "pub_tool_errormgr.h" // VG_(maybe_record_error)()
31 #include "pub_tool_libcprint.h" // VG_(printf)()
32 #include "pub_tool_machine.h" // VG_(get_IP)()
33 #include "pub_tool_mallocfree.h" // VG_(malloc)(), VG_(free)()
35 #include "pub_tool_threadstate.h" // VG_(get_running_tid)()
134 p->oset[i] = VG_(OSetGen_Create)(0, 0, VG_(malloc), "drd.barrier.bi.1",
135 VG_(free));
159 VG_(maybe_record_error)(VG_(get_running_tid)()
[all...] |
| drd_malloc_wrappers.c | 74 p = VG_(cli_malloc)(align, size);
78 VG_(memset)(p, 0, size);
102 mc = VG_(malloc)("drd.malloc_wrappers.cDC.1", sizeof(DRD_Chunk));
105 mc->where = VG_(record_ExeContext)(tid, 0);
106 VG_(HT_add_node)(s_malloc_list, mc);
130 mc = VG_(HT_lookup)(s_malloc_list, (UWord)p);
137 VG_(cli_free)((void*)p);
138 VG_(HT_remove)(s_malloc_list, (UWord)p);
139 VG_(free)(mc);
148 return new_block(tid, n, VG_(clo_alignment), /*is_zeroed*/False)
[all...] |
| drd_cond.c | 29 #include "pub_tool_errormgr.h" /* VG_(maybe_record_error)() */
31 #include "pub_tool_libcbase.h" /* VG_(memcmp)() */
32 #include "pub_tool_libcprint.h" /* VG_(printf)() */
33 #include "pub_tool_machine.h" /* VG_(get_IP)() */
34 #include "pub_tool_threadstate.h" /* VG_(get_running_tid)() */
91 VG_(maybe_record_error)(VG_(get_running_tid)(),
93 VG_(get_IP)(VG_(get_running_tid)()),
111 VG_(maybe_record_error)(VG_(get_running_tid)()
[all...] |
| drd_semaphore.c | 29 #include "pub_tool_errormgr.h" // VG_(maybe_record_error)()
31 #include "pub_tool_libcprint.h" // VG_(printf)()
32 #include "pub_tool_machine.h" // VG_(get_IP)()
33 #include "pub_tool_mallocfree.h" // VG_(malloc), VG_(free)
34 #include "pub_tool_threadstate.h" // VG_(get_running_tid)()
56 n = VG_(addToXA)(p->last_sem_post_seg, &sg);
58 VG_(message)(Vg_DebugMsg, "0x%lx push: added at position %ld/%ld\n",
59 p->a1, n, VG_(sizeXA)(p->last_sem_post_seg));
61 tl_assert(*(Segment**)VG_(indexXA)(p->last_sem_post_seg, n) == sg)
[all...] |
| /external/valgrind/include/ |
| pub_tool_libcsignal.h | 34 #include "pub_tool_basics.h" // VG_ macro
43 extern Int VG_(sigprocmask) ( Int how, const vki_sigset_t* set,
|
| pub_tool_stacktrace.h | 61 extern UInt VG_(get_StackTrace) ( ThreadId tid,
72 extern void VG_(apply_StackTrace)(
79 extern void VG_(pp_StackTrace) ( StackTrace ips, UInt n_ips );
82 // calling VG_(get_StackTrace)() then VG_(pp_StackTrace)().
83 extern void VG_(get_and_pp_StackTrace) ( ThreadId tid, UInt n_ips );
|
| /external/valgrind/coregrind/m_gdbserver/ |
| utils.c | 33 VG_(umsg) ("error %ld %s\n", sr_Err(sr), VG_(strerror) (sr_Err(sr)));
35 VG_(umsg) ("sr_perror called with no error!!!\n");
37 VG_(vmessage) ( Vg_UserMsg, string, args );
49 VG_(vmessage) ( Vg_UserMsg, string, args );
63 VG_(vmessage) ( Vg_UserMsg, string, args );
65 VG_(exit) (1);
73 VG_(vmessage) ( Vg_UserMsg, string, args );
84 res = VG_(do_syscall2)(__NR_gettimeofday, (UWord)&dbgtv, (UWord)NULL);
|
| valgrind-low-amd64.c | 154 ThreadState* tst = VG_(get_ThreadState)(tid);
164 case 0: VG_(transfer) (&amd64->guest_RAX, buf, dir, size, mod); break;
165 case 1: VG_(transfer) (&amd64->guest_RBX, buf, dir, size, mod); break;
166 case 2: VG_(transfer) (&amd64->guest_RCX, buf, dir, size, mod); break;
167 case 3: VG_(transfer) (&amd64->guest_RDX, buf, dir, size, mod); break;
168 case 4: VG_(transfer) (&amd64->guest_RSI, buf, dir, size, mod); break;
169 case 5: VG_(transfer) (&amd64->guest_RDI, buf, dir, size, mod); break;
170 case 6: VG_(transfer) (&amd64->guest_RBP, buf, dir, size, mod); break;
171 case 7: VG_(transfer) (&amd64->guest_RSP, buf, dir, size, mod); break;
172 case 8: VG_(transfer) (&amd64->guest_R8, buf, dir, size, mod); break
[all...] |
| /external/valgrind/callgrind/ |
| debug.c | 44 VG_(printf)("%s", sp+40-s);
54 VG_(printf)("BB %#lx (Obj '%s')", bb_addr(bb), bb->obj->name);
63 VG_(printf)("(none)");
65 VG_(printf)("%s", cxt->fn[0]->name);
67 VG_(printf)("'%d", rec_index +1);
69 VG_(printf)("'%s", cxt->fn[i]->name);
86 VG_(printf)("Cxt %d" ,cxt->base_number + rec_index);
88 VG_(printf)(" [active=%d]", *pactive);
89 VG_(printf)(": ");
91 VG_(printf)("\n")
[all...] |
| /external/valgrind/memcheck/ |
| mc_malloc_wrappers.c | 44 #include "pub_tool_stacktrace.h" // For VG_(get_and_pp_StackTrace)
91 (e.g. bigger than VG_(clo_freelist_vol)) without losing
122 VG_(free_queue_volume) += (Long)mc->szB;
124 VG_(printf)("mc_freelist: acquire: volume now %lld\n",
125 VG_(free_queue_volume));
126 VG_(free_queue_length)++;
132 On entry, VG_(free_queue_volume) must be > MC_(clo_freelist_vol).
133 On exit, VG_(free_queue_volume) will be <= MC_(clo_freelist_vol). */
138 tl_assert (VG_(free_queue_volume) > MC_(clo_freelist_vol));
142 while (VG_(free_queue_volume) > MC_(clo_freelist_vol
[all...] |
