1 2 /*--------------------------------------------------------------------*/ 3 /*--- Command line options. pub_core_options.h ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2000-2017 Julian Seward 11 jseward@acm.org 12 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. 17 18 This program is distributed in the hope that it will be useful, but 19 WITHOUT ANY WARRANTY; without even the implied warranty of 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 General Public License for more details. 22 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. 27 28 The GNU General Public License is contained in the file COPYING. 29 */ 30 31 #ifndef __PUB_CORE_OPTIONS_H 32 #define __PUB_CORE_OPTIONS_H 33 34 //-------------------------------------------------------------------- 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). 38 //-------------------------------------------------------------------- 39 #include "pub_tool_options.h" 40 #include "pub_core_xarray.h" 41 42 /* Valgrind tool name. Defaults to "memcheck". */ 43 extern const HChar *VG_(clo_toolname); 44 45 /* Should we stop collecting errors if too many appear? default: YES */ 46 extern Bool VG_(clo_error_limit); 47 /* Should we exit if an error appears? default: NO */ 48 extern Bool VG_(clo_exit_on_first_error); 49 /* Alternative exit code to hand to parent if errors were found. 50 default: 0 (no, return the application's exit code in the normal 51 way. */ 52 extern Int VG_(clo_error_exitcode); 53 54 /* For tools that report errors, list detected errors and show suppression 55 usage counts at exit. Default: No. 56 Unless set explicitly by the user, the option is automatically 57 considered as set to yes for verbosity > 1. */ 58 extern Bool VG_(clo_show_error_list); 59 60 61 /* Markers used to mark the begin/end of an error, when errors are 62 printed in textual (non xml) format. 63 [0] is the error begin marker, [1] is the error end marker. 64 default: no markers. */ 65 extern HChar *VG_(clo_error_markers)[2]; 66 67 typedef 68 enum { 69 Vg_VgdbNo, // Do not activate gdbserver. 70 Vg_VgdbYes, // Activate gdbserver (default). 71 Vg_VgdbFull, // ACtivate gdbserver in full mode, allowing 72 // a precise handling of watchpoints and single stepping 73 // at any moment. 74 } 75 VgVgdb; 76 /* if != Vg_VgdbNo, allows valgrind to serve vgdb/gdb. */ 77 extern VgVgdb VG_(clo_vgdb); 78 /* if > 0, checks every VG_(clo_vgdb_poll) BBS if vgdb wants to be served. */ 79 extern Int VG_(clo_vgdb_poll); 80 81 /* Specify when Valgrind gdbserver stops the execution and wait 82 for a GDB to connect. */ 83 typedef 84 enum { // Stop : 85 VgdbStopAt_Startup, // just before the client starts to execute. 86 VgdbStopAt_Exit, // just before the client exits. 87 VgdbStopAt_ValgrindAbExit // on abnormal valgrind exit. 88 } 89 VgdbStopAt; 90 // Build mask to check or set VgdbStop_At a membership 91 #define VgdbStopAt2S(a) (1 << (a)) 92 // VgdbStopAt a is member of the Set s ? 93 #define VgdbStopAtiS(a,s) ((s) & VgdbStopAt2S(a)) 94 extern UInt VG_(clo_vgdb_stop_at); // A set of VgdbStopAt reasons. 95 96 /* prefix for the named pipes (FIFOs) used by vgdb/gdb to communicate with valgrind */ 97 extern const HChar *VG_(clo_vgdb_prefix); 98 99 /* if True, gdbserver in valgrind will expose a target description containing 100 shadow registers */ 101 extern Bool VG_(clo_vgdb_shadow_registers); 102 103 /* Generating a suppression for each error? default: 0 (NO) 104 Other values: 1 (yes, but ask user), 2 (yes, don't ask user) */ 105 extern Int VG_(clo_gen_suppressions); 106 /* Sanity-check level: 0 = none, 1 (default), > 1 = expensive. */ 107 extern Int VG_(clo_sanity_level); 108 /* Automatically attempt to demangle C++ names? default: YES */ 109 extern Bool VG_(clo_demangle); 110 /* Soname synonyms : a string containing a list of pairs 111 xxxxx=yyyyy separated by commas. 112 E.g. --soname-synonyms=somalloc=libtcmalloc*.so*,solibtruc=NONE */ 113 extern const HChar* VG_(clo_soname_synonyms); 114 /* Valgrind-ise child processes (follow execve)? default : NO */ 115 extern 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 */ 118 extern 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. */ 122 extern 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(). */ 129 extern Bool VG_(clo_child_silent_after_fork); 130 131 /* If the user specified --log-file=STR and/or --xml-file=STR, these 132 hold STR before expansion. */ 133 extern const HChar *VG_(clo_log_fname_unexpanded); 134 extern const HChar *VG_(clo_xml_fname_unexpanded); 135 136 /* Add timestamps to log messages? default: NO */ 137 extern Bool VG_(clo_time_stamp); 138 139 /* The file descriptor to read for input. default: 0 == stdin */ 140 extern Int VG_(clo_input_fd); 141 142 /* Whether or not to load the default suppressions. */ 143 extern Bool VG_(clo_default_supp); 144 145 /* The names of the suppression files. */ 146 extern XArray *VG_(clo_suppressions); 147 148 /* An array of strings harvested from --fullpath-after= flags. */ 149 extern XArray *VG_(clo_fullpath_after); 150 151 /* Full path to additional path to search for debug symbols */ 152 extern const HChar* VG_(clo_extra_debuginfo_path); 153 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. */ 157 extern const HChar* VG_(clo_debuginfo_server); 158 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. */ 164 extern Bool VG_(clo_allow_mismatched_debuginfo); 165 166 /* DEBUG: print generated code? default: 00000000 ( == NO ) */ 167 extern UChar VG_(clo_trace_flags); 168 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. */ 172 extern 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) */ 176 extern 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. */ 180 extern ULong VG_(clo_profyle_interval); 181 182 /* DEBUG: if tracing codegen, be quiet until after this bb */ 183 extern Int VG_(clo_trace_notbelow); 184 /* DEBUG: if tracing codegen, be quiet after this bb */ 185 extern Int VG_(clo_trace_notabove); 186 /* DEBUG: print system calls? default: NO */ 187 extern Bool VG_(clo_trace_syscalls); 188 /* DEBUG: print signal details? default: NO */ 189 extern Bool VG_(clo_trace_signals); 190 /* DEBUG: print symtab details? default: NO */ 191 extern Bool VG_(clo_trace_symtab); 192 /* DEBUG: restrict symtab etc details to object name pattern. Default: "*" */ 193 extern const HChar* VG_(clo_trace_symtab_patt); 194 /* DEBUG: print call-frame-info details? default: NO */ 195 extern Bool VG_(clo_trace_cfi); 196 /* DEBUG: mimic /usr/bin/readelf --syms? default: NO */ 197 extern Bool VG_(clo_debug_dump_syms); 198 /* DEBUG: mimic /usr/bin/readelf --debug-dump=line? default: NO */ 199 extern Bool VG_(clo_debug_dump_line); 200 /* DEBUG: mimic /usr/bin/readelf --debug-dump=frames? default: NO */ 201 extern Bool VG_(clo_debug_dump_frames); 202 /* DEBUG: print redirection details? default: NO */ 203 extern Bool VG_(clo_trace_redir); 204 /* Enable fair scheduling on multicore systems? default: NO */ 205 enum FairSchedType { disable_fair_sched, enable_fair_sched, try_fair_sched }; 206 extern enum FairSchedType VG_(clo_fair_sched); 207 /* DEBUG: print thread scheduling events? default: NO */ 208 extern Bool VG_(clo_trace_sched); 209 /* DEBUG: do heap profiling? default: NO */ 210 extern Bool VG_(clo_profile_heap); 211 // DEBUG: report progress every N seconds (1 .. 3600) 212 extern UInt VG_(clo_progress_interval); 213 #define MAX_REDZONE_SZB 128 214 // Maximum for the default values for core arenas and for client 215 // arena given by the tool. 216 // 128 is no special figure, just something not too big 217 #define MAX_CLO_REDZONE_SZB 4096 218 // We allow the user to increase the redzone size to 4Kb : 219 // This allows "off by one" in an array of pages to be detected. 220 #define CORE_REDZONE_DEFAULT_SZB 4 221 extern Int VG_(clo_core_redzone_size); 222 // VG_(clo_redzone_size) has default value -1, indicating to keep 223 // the tool provided value. 224 /* DEBUG: display gory details for the k'th most popular error. 225 default: Infinity. */ 226 extern Int VG_(clo_dump_error); 227 228 /* Engage miscellaneous weird hacks needed for some progs. */ 229 typedef 230 enum { 231 SimHint_lax_ioctls, 232 SimHint_lax_doors, 233 SimHint_fuse_compatible, 234 SimHint_enable_outer, 235 SimHint_no_inner_prefix, 236 SimHint_no_nptl_pthread_stackcache, 237 SimHint_fallback_llsc 238 } 239 SimHint; 240 241 // Build mask to check or set SimHint a membership 242 #define SimHint2S(a) (1 << (a)) 243 // SimHint h is member of the Set s ? 244 #define SimHintiS(h,s) (((s) & SimHint2S(h)) != 0) 245 extern UInt VG_(clo_sim_hints); 246 247 /* Show symbols in the form 'name+offset' ? Default: NO */ 248 extern Bool VG_(clo_sym_offsets); 249 /* Read DWARF3 inline info ? */ 250 extern Bool VG_(clo_read_inline_info); 251 /* Read DWARF3 variable info even if tool doesn't ask for it? */ 252 extern Bool VG_(clo_read_var_info); 253 /* Which prefix to strip from full source file paths, if any. */ 254 extern const HChar* VG_(clo_prefix_to_strip); 255 256 /* An array of strings harvested from --require-text-symbol= 257 flags. 258 259 Each string specifies a pair: a soname pattern and a text symbol 260 name pattern, separated by a colon. The patterns can be written 261 using the normal "?" and "*" wildcards. For example: 262 ":*libc.so*:foo?bar". 263 264 These flags take effect when reading debuginfo from objects. If an 265 object is loaded and the object's soname matches the soname 266 component of one of the specified pairs, then Valgrind will examine 267 all the text symbol names in the object. If none of them match the 268 symbol name component of that same specification, then the run is 269 aborted, with an error message. 270 271 The purpose of this is to support reliable usage of marked-up 272 libraries. For example, suppose we have a version of GCC's 273 libgomp.so which has been marked up with annotations to support 274 Helgrind. It is only too easy and confusing to load the 'wrong' 275 libgomp.so into the application. So the idea is: add a text symbol 276 in the marked-up library (eg), "annotated_for_helgrind_3_6", and 277 then give the flag 278 279 --require-text-symbol=:*libgomp*so*:annotated_for_helgrind_3_6 280 281 so that when libgomp.so is loaded, we scan the symbol table, and if 282 the symbol isn't present the run is aborted, rather than continuing 283 silently with the un-marked-up library. Note that you should put 284 the entire flag in quotes to stop shells messing up the * and ? 285 wildcards. */ 286 extern XArray *VG_(clo_req_tsyms); 287 288 /* Track open file descriptors? */ 289 extern Bool VG_(clo_track_fds); 290 291 /* Should we run __libc_freeres at exit? Sometimes causes crashes. 292 Default: YES. Note this is subservient to VG_(needs).libc_freeres; 293 if the latter says False, then the setting of VG_(clo_run_libc_freeres) 294 is ignored. Ie if a tool says no, I don't want this to run, that 295 cannot be overridden from the command line. */ 296 extern Bool VG_(clo_run_libc_freeres); 297 298 /* Should we run __gnu_cxx::__freeres at exit for C++ programs? 299 Default: YES. Note this is subservient to VG_(needs).cxx_freeres; 300 if the latter says False, then the setting of VG_(clo_run_cxx_freeres) 301 is ignored. Ie if a tool says no, I don't want this to run, that 302 cannot be overridden from the command line. */ 303 extern Bool VG_(clo_run_cxx_freeres); 304 305 /* Should we show VEX emulation warnings? Default: NO */ 306 extern Bool VG_(clo_show_emwarns); 307 308 /* How much does the stack pointer have to change before tools 309 consider a stack switch to have happened? Default: 2000000 bytes 310 NB: must be host-word-sized to be correct (hence Word). */ 311 extern Word VG_(clo_max_stackframe); 312 /* How large should Valgrind allow the primary thread's guest stack to 313 be? */ 314 extern Word VG_(clo_main_stacksize); 315 316 /* The maximum number of threads we support. */ 317 #define MAX_THREADS_DEFAULT 500 318 extern UInt VG_(clo_max_threads); 319 320 /* If the same IP is found twice in a backtrace in a sequence of max 321 VG_(clo_merge_recursive_frames) frames, then the recursive call 322 is merged in the backtrace. 323 Note also that the merge is done during unwinding, to obtain 324 an much as possible significant backtrace. 325 Note that the value is changeable by a gdbsrv command. */ 326 extern Int VG_(clo_merge_recursive_frames); 327 328 /* Max number of sectors that will be used by the translation code cache. */ 329 extern UInt VG_(clo_num_transtab_sectors); 330 331 /* Average size of a transtab code entry. 0 means to use the tool 332 provided default. */ 333 extern UInt VG_(clo_avg_transtab_entry_size); 334 335 /* Only client requested fixed mapping can be done below 336 VG_(clo_aspacem_minAddr). */ 337 extern Addr VG_(clo_aspacem_minAddr); 338 339 /* How large the Valgrind thread stacks should be. 340 Will be rounded up to a page.. */ 341 extern Word VG_(clo_valgrind_stacksize); 342 343 /* Delay startup to allow GDB to be attached? Default: NO */ 344 extern Bool VG_(clo_wait_for_gdb); 345 346 /* To what extent should self-checking translations be made? These 347 are needed to deal with self-modifying code on uncooperative 348 platforms. */ 349 typedef 350 enum { 351 Vg_SmcNone, // never generate self-checking translations 352 Vg_SmcStack, // generate s-c-t's for code found in stacks 353 // (this is the default) 354 Vg_SmcAll, // make all translations self-checking. 355 Vg_SmcAllNonFile // make all translations derived from 356 // non-file-backed memory self checking 357 } 358 VgSmc; 359 360 /* Describe extent to which self-modifying-code should be 361 auto-detected. */ 362 extern VgSmc VG_(clo_smc_check); 363 364 /* A set of minor kernel variants, 365 so they can be properly handled by m_syswrap. */ 366 typedef 367 enum { 368 KernelVariant_bproc, 369 KernelVariant_android_no_hw_tls, 370 KernelVariant_android_gpu_sgx5xx, 371 KernelVariant_android_gpu_adreno3xx 372 } 373 KernelVariant; 374 // Build mask to check or set KernelVariant a membership 375 #define KernelVariant2S(v) (1 << (v)) 376 // KernelVariant v is member of the Set s ? 377 #define KernelVariantiS(v,s) ((s) & KernelVariant2S(v)) 378 extern UInt VG_(clo_kernel_variant); 379 380 /* Darwin-specific: automatically run /usr/bin/dsymutil to update 381 .dSYM directories as necessary? */ 382 extern Bool VG_(clo_dsymutil); 383 384 /* Should we trace into this child executable (across execve etc) ? 385 This involves considering --trace-children=, 386 --trace-children-skip=, --trace-children-skip-by-arg=, and the name 387 of the executable. 'child_argv' must not include the name of the 388 executable itself; iow child_argv[0] must be the first arg, if any, 389 for the child. */ 390 extern Bool VG_(should_we_trace_this_child) ( const HChar* child_exe_name, 391 const HChar** child_argv ); 392 393 /* Whether illegal instructions should be reported/diagnosed. 394 Can be explicitly set through --sigill-diagnostics otherwise 395 depends on verbosity (False if -q). */ 396 extern Bool VG_(clo_sigill_diag); 397 398 /* Unwind using stack scanning (a nasty hack at the best of times) 399 when the normal CFI/FP-chain scan fails. If the number of 400 "normally" recovered frames is below this number, stack scanning 401 will be used (on platforms on which it is supported, currently only 402 arm-linux). The default value of zero has the effect of disabling 403 stack scanning. Default: zero*/ 404 extern UInt VG_(clo_unw_stack_scan_thresh); 405 406 /* If stack scanning is used, this is how many frames it may recover. 407 Since it tends to pick up a lot of junk, this value is set pretty 408 low by default. Default: 5 */ 409 extern UInt VG_(clo_unw_stack_scan_frames); 410 411 /* Controls the resync-filter on MacOS. Has no effect on Linux. 412 0=disabled [default on Linux] "no" 413 1=enabled [default on MacOS] "yes" 414 2=enabled and verbose. "verbose" */ 415 extern UInt VG_(clo_resync_filter); 416 417 #endif // __PUB_CORE_OPTIONS_H 418 419 /*--------------------------------------------------------------------*/ 420 /*--- end ---*/ 421 /*--------------------------------------------------------------------*/ 422