3/*--- Command line options.                     pub_core_options.h ---*/
7   This file is part of Valgrind, a dynamic binary instrumentation
8   framework.
10   Copyright (C) 2000-2013 Julian Seward
11      jseward@acm.org
13   This program is free software; you can redistribute it and/or
14   modify it under the terms of the GNU General Public License as
15   published by the Free Software Foundation; either version 2 of the
16   License, or (at your option) any later version.
18   This program is distributed in the hope that it will be useful, but
19   WITHOUT ANY WARRANTY; without even the implied warranty of
21   General Public License for more details.
23   You should have received a copy of the GNU General Public License
24   along with this program; if not, write to the Free Software
25   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26   02111-1307, USA.
28   The GNU General Public License is contained in the file COPYING.
31#ifndef __PUB_CORE_OPTIONS_H
32#define __PUB_CORE_OPTIONS_H
35// PURPOSE: This module holds the variables for all command line options,
36// plus some functions and macros for manipulating them.  Almost every
37// other module imports this one, if only for VG_(clo_verbosity).
40#include "pub_tool_options.h"
42/* The max number of suppression files. */
43#define VG_CLO_MAX_SFILES 100
45/* The max number of --require-text-symbol= specification strings. */
46#define VG_CLO_MAX_REQ_TSYMS 100
48/* The max number of --fullpath-after= parameters. */
51/* Should we stop collecting errors if too many appear?  default: YES */
52extern Bool  VG_(clo_error_limit);
53/* Alternative exit code to hand to parent if errors were found.
54   default: 0 (no, return the application's exit code in the normal
55   way. */
56extern Int   VG_(clo_error_exitcode);
59   enum {
60      Vg_VgdbNo,   // Do not activate gdbserver.
61      Vg_VgdbYes,  // Activate gdbserver (default).
62      Vg_VgdbFull, // ACtivate gdbserver in full mode, allowing
63                   // a precise handling of watchpoints and single stepping
64                   // at any moment.
65   }
66   VgVgdb;
67/* if != Vg_VgdbNo, allows valgrind to serve vgdb/gdb. */
68extern VgVgdb VG_(clo_vgdb);
69/* if > 0, checks every VG_(clo_vgdb_poll) BBS if vgdb wants to be served. */
70extern Int VG_(clo_vgdb_poll);
72/* Specify when Valgrind gdbserver stops the execution and wait
73   for a GDB to connect. */
75   enum {                       // Stop :
76      VgdbStopAt_Startup,       // just before the client starts to execute.
77      VgdbStopAt_Exit,          // just before the client exits.
78      VgdbStopAt_ValgrindAbExit // on abnormal valgrind exit.
79   }
80   VgdbStopAt;
81// Build mask to check or set VgdbStop_At a membership
82#define VgdbStopAt2S(a) (1 << (a))
83// VgdbStopAt a is member of the Set s ?
84#define VgdbStopAtiS(a,s) ((s) & VgdbStopAt2S(a))
85// A set with all VgdbStopAt:
86#define VgdbStopAtallS \
87     (VgdbStopAt2S(VgdbStopAt_Startup) \
88    | VgdbStopAt2S(VgdbStopAt_Exit)    \
89    | VgdbStopAt2S(VgdbStopAt_ValgrindAbExit)
90extern UInt VG_(clo_vgdb_stop_at); // A set of VgdbStopAt reasons.
92/* prefix for the named pipes (FIFOs) used by vgdb/gdb to communicate with valgrind */
93extern const HChar *VG_(clo_vgdb_prefix);
95/* if True, gdbserver in valgrind will expose a target description containing
96   shadow registers */
97extern Bool  VG_(clo_vgdb_shadow_registers);
99/* Enquire about whether to attach to a debugger at errors?   default: NO */
100extern Bool  VG_(clo_db_attach);
101/* The debugger command?  default: whatever gdb ./configure found */
102extern const HChar* VG_(clo_db_command);
103/* Generating a suppression for each error?   default: 0 (NO)
104   Other values: 1 (yes, but ask user), 2 (yes, don't ask user) */
105extern Int   VG_(clo_gen_suppressions);
106/* Sanity-check level: 0 = none, 1 (default), > 1 = expensive. */
107extern Int   VG_(clo_sanity_level);
108/* Automatically attempt to demangle C++ names?  default: YES */
109extern Bool  VG_(clo_demangle);
110/* Simulate child processes? default: NO */
111/* Soname synonyms : a string containing a list of pairs
112   xxxxx=yyyyy separated by commas.
113   E.g. --soname-synonyms=somalloc=libtcmalloc*.so*,solibtruc=NONE */
114extern const HChar* VG_(clo_soname_synonyms);
115extern Bool  VG_(clo_trace_children);
116/* String containing comma-separated patterns for executable names
117   that should not be traced into even when --trace-children=yes */
118extern const HChar* VG_(clo_trace_children_skip);
119/* The same as VG_(clo_trace_children), except that these patterns are
120   tested against the arguments for child processes, rather than the
121   executable name. */
122extern const HChar* VG_(clo_trace_children_skip_by_arg);
123/* After a fork, the child's output can become confusingly
124   intermingled with the parent's output.  This is especially
125   problematic when VG_(clo_xml) is True.  Setting
126   VG_(clo_child_silent_after_fork) causes children to fall silent
127   after fork() calls.  Although note they become un-silent again
128   after the subsequent exec(). */
129extern Bool  VG_(clo_child_silent_after_fork);
131/* If the user specified --log-file=STR and/or --xml-file=STR, these
132   hold STR after expansion of the %p and %q templates. */
133extern HChar* VG_(clo_log_fname_expanded);
134extern HChar* VG_(clo_xml_fname_expanded);
136/* Add timestamps to log messages?  default: NO */
137extern Bool  VG_(clo_time_stamp);
139/* The file descriptor to read for input.  default: 0 == stdin */
140extern Int   VG_(clo_input_fd);
142/* The number of suppression files specified. */
143extern Int   VG_(clo_n_suppressions);
144/* The names of the suppression files. */
145extern const HChar* VG_(clo_suppressions)[VG_CLO_MAX_SFILES];
147/* An array of strings harvested from --fullpath-after= flags. */
148extern Int   VG_(clo_n_fullpath_after);
149extern const HChar* VG_(clo_fullpath_after)[VG_CLO_MAX_FULLPATH_AFTER];
151/* Full path to additional path to search for debug symbols */
152extern const HChar* VG_(clo_extra_debuginfo_path);
154/* Address of a debuginfo server to use.  Either an IPv4 address of
155   the form "d.d.d.d" or that plus a port spec, hence of the form
156   "d.d.d.d:d", where d is one or more digits. */
157extern const HChar* VG_(clo_debuginfo_server);
159/* Do we allow reading debuginfo from debuginfo objects that don't
160   match (in some sense) the main object?  This is dangerous, so the
161   default is NO (False).  In any case it applies only to objects
162   found either in _extra_debuginfo_path or via the
163   _debuginfo_server. */
164extern Bool VG_(clo_allow_mismatched_debuginfo);
166/* DEBUG: print generated code?  default: 00000000 ( == NO ) */
167extern UChar VG_(clo_trace_flags);
169/* DEBUG: do SB profiling? default: False (== NO).  NOTE: does not
170   have an associated command line flag.  Is set to True whenever
171   --profile-flags= is specified. */
172extern Bool  VG_(clo_profyle_sbs);
173/* DEBUG: if doing SB profiling, provides bits for which JIT stages
174   are shown.  Same meaning as for clo_trace_flags.  default: zero (==
175   show block counts only) */
176extern UChar VG_(clo_profyle_flags);
177/* DEBUG: if doing SB profiling, dump blocks and zero counters after
178   this-many back edges (event checks).  default: zero (== show
179   profiling results only at the end of the run. */
180extern ULong VG_(clo_profyle_interval);
182/* DEBUG: if tracing codegen, be quiet until after this bb */
183extern Int   VG_(clo_trace_notbelow);
184/* DEBUG: if tracing codegen, be quiet after this bb  */
185extern Int   VG_(clo_trace_notabove);
186/* DEBUG: print system calls?  default: NO */
187extern Bool  VG_(clo_trace_syscalls);
188/* DEBUG: print signal details?  default: NO */
189extern Bool  VG_(clo_trace_signals);
190/* DEBUG: print symtab details?  default: NO */
191extern Bool  VG_(clo_trace_symtab);
192/* DEBUG: restrict symtab etc details to object name pattern.  Default: "*" */
193extern const HChar* VG_(clo_trace_symtab_patt);
194/* DEBUG: print call-frame-info details?  default: NO */
195extern Bool  VG_(clo_trace_cfi);
196/* DEBUG:  mimic /usr/bin/readelf --syms?  default: NO */
197extern Bool  VG_(clo_debug_dump_syms);
198/* DEBUG: mimic /usr/bin/readelf --debug-dump=line?  default: NO */
199extern Bool  VG_(clo_debug_dump_line);
200/* DEBUG: mimic  /usr/bin/readelf --debug-dump=frames?  default: NO */
201extern Bool  VG_(clo_debug_dump_frames);
202/* DEBUG: print redirection details?  default: NO */
203extern Bool  VG_(clo_trace_redir);
204/* Enable fair scheduling on multicore systems? default: NO */
205enum FairSchedType { disable_fair_sched, enable_fair_sched, try_fair_sched };
206extern enum FairSchedType VG_(clo_fair_sched);
207/* DEBUG: print thread scheduling events?  default: NO */
208extern Bool  VG_(clo_trace_sched);
209/* DEBUG: do heap profiling?  default: NO */
210extern Bool  VG_(clo_profile_heap);
211#define MAX_REDZONE_SZB 128
212// Maximum for the default values for core arenas and for client
213// arena given by the tool.
214// 128 is no special figure, just something not too big
215#define MAX_CLO_REDZONE_SZB 4096
216// We allow the user to increase the redzone size to 4Kb :
217// This allows "off by one" in an array of pages to be detected.
219extern Int VG_(clo_core_redzone_size);
220// VG_(clo_redzone_size) has default value -1, indicating to keep
221// the tool provided value.
222extern Int VG_(clo_redzone_size);
223/* DEBUG: display gory details for the k'th most popular error.
224   default: Infinity. */
225extern Int   VG_(clo_dump_error);
226/* Engage miscellaneous weird hacks needed for some progs. */
227extern const HChar* VG_(clo_sim_hints);
228/* Show symbols in the form 'name+offset' ?  Default: NO */
229extern Bool VG_(clo_sym_offsets);
230/* Read DWARF3 variable info even if tool doesn't ask for it? */
231extern Bool VG_(clo_read_var_info);
232/* Which prefix to strip from full source file paths, if any. */
233extern const HChar* VG_(clo_prefix_to_strip);
235/* An array of strings harvested from --require-text-symbol=
236   flags.
238   Each string specifies a pair: a soname pattern and a text symbol
239   name pattern, separated by a colon.  The patterns can be written
240   using the normal "?" and "*" wildcards.  For example:
241   ":*libc.so*:foo?bar".
243   These flags take effect when reading debuginfo from objects.  If an
244   object is loaded and the object's soname matches the soname
245   component of one of the specified pairs, then Valgrind will examine
246   all the text symbol names in the object.  If none of them match the
247   symbol name component of that same specification, then the run is
248   aborted, with an error message.
250   The purpose of this is to support reliable usage of marked-up
251   libraries.  For example, suppose we have a version of GCC's
252   libgomp.so which has been marked up with annotations to support
253   Helgrind.  It is only too easy and confusing to load the 'wrong'
254   libgomp.so into the application.  So the idea is: add a text symbol
255   in the marked-up library (eg), "annotated_for_helgrind_3_6", and
256   then give the flag
258     --require-text-symbol=:*libgomp*so*:annotated_for_helgrind_3_6
260   so that when libgomp.so is loaded, we scan the symbol table, and if
261   the symbol isn't present the run is aborted, rather than continuing
262   silently with the un-marked-up library.  Note that you should put
263   the entire flag in quotes to stop shells messing up the * and ?
264   wildcards. */
265extern Int    VG_(clo_n_req_tsyms);
266extern const HChar* VG_(clo_req_tsyms)[VG_CLO_MAX_REQ_TSYMS];
268/* Track open file descriptors? */
269extern Bool  VG_(clo_track_fds);
271/* Should we run __libc_freeres at exit?  Sometimes causes crashes.
272   Default: YES.  Note this is subservient to VG_(needs).libc_freeres;
273   if the latter says False, then the setting of VG_(clo_run_libc_freeres)
274   is ignored.  Ie if a tool says no, I don't want this to run, that
275   cannot be overridden from the command line. */
276extern Bool  VG_(clo_run_libc_freeres);
278/* Should we show VEX emulation warnings?  Default: NO */
279extern Bool VG_(clo_show_emwarns);
281/* How much does the stack pointer have to change before tools
282   consider a stack switch to have happened?  Default: 2000000 bytes
283   NB: must be host-word-sized to be correct (hence Word). */
284extern Word VG_(clo_max_stackframe);
285/* How large should Valgrind allow the primary thread's guest stack to
286   be? */
287extern Word VG_(clo_main_stacksize);
289/* If the same IP is found twice in a backtrace in a sequence of max
290   VG_(clo_merge_recursive_frames) frames, then the recursive call
291   is merged in the backtrace.
292   Note also that the merge is done during unwinding, to obtain
293   an much as possible significant backtrace.
294   Note that the value is changeable by a gdbsrv command. */
295extern Int VG_(clo_merge_recursive_frames);
297/* Max number of sectors that will be used by the translation code cache. */
298extern UInt VG_(clo_num_transtab_sectors);
300/* Only client requested fixed mapping can be done below
301   VG_(clo_aspacem_minAddr). */
302extern Addr VG_(clo_aspacem_minAddr);
304/* Delay startup to allow GDB to be attached?  Default: NO */
305extern Bool VG_(clo_wait_for_gdb);
307/* To what extent should self-checking translations be made?  These
308   are needed to deal with self-modifying code on uncooperative
309   platforms. */
311   enum {
312      Vg_SmcNone,  // never generate self-checking translations
313      Vg_SmcStack, // generate s-c-t's for code found in stacks
314                   // (this is the default)
315      Vg_SmcAll,   // make all translations self-checking.
316      Vg_SmcAllNonFile // make all translations derived from
317                   // non-file-backed memory self checking
318   }
319   VgSmc;
321/* Describe extent to which self-modifying-code should be
322   auto-detected. */
323extern VgSmc VG_(clo_smc_check);
325/* String containing comma-separated names of minor kernel variants,
326   so they can be properly handled by m_syswrap. */
327extern const HChar* VG_(clo_kernel_variant);
329/* Darwin-specific: automatically run /usr/bin/dsymutil to update
330   .dSYM directories as necessary? */
331extern Bool VG_(clo_dsymutil);
333/* Should we trace into this child executable (across execve etc) ?
334   This involves considering --trace-children=,
335   --trace-children-skip=, --trace-children-skip-by-arg=, and the name
336   of the executable.  'child_argv' must not include the name of the
337   executable itself; iow child_argv[0] must be the first arg, if any,
338   for the child. */
339extern Bool VG_(should_we_trace_this_child) ( HChar* child_exe_name,
340                                              HChar** child_argv );
342/* Whether illegal instructions should be reported/diagnosed.
343   Can be explicitly set through --sigill-diagnostics otherwise
344   depends on verbosity (False if -q). */
345extern Bool VG_(clo_sigill_diag);
347/* Unwind using stack scanning (a nasty hack at the best of times)
348   when the normal CFI/FP-chain scan fails.  If the number of
349   "normally" recovered frames is below this number, stack scanning
350   will be used (on platforms on which it is supported, currently only
351   arm-linux).  The default value of zero has the effect of disabling
352   stack scanning.  Default: zero*/
353extern UInt VG_(clo_unw_stack_scan_thresh);
355/* If stack scanning is used, this is how many frames it may recover.
356   Since it tends to pick up a lot of junk, this value is set pretty
357   low by default.  Default: 5 */
358extern UInt VG_(clo_unw_stack_scan_frames);
360#endif   // __PUB_CORE_OPTIONS_H
363/*--- end                                                          ---*/