1
2 /*--------------------------------------------------------------------*/
3 /*--- Startup: the real stuff m_main.c ---*/
4 /*--------------------------------------------------------------------*/
5
6 /*
7 This file is part of Valgrind, a dynamic binary instrumentation
8 framework.
9
10 Copyright (C) 2000-2010 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 #include "pub_core_basics.h"
32 #include "pub_core_vki.h"
33 #include "pub_core_vkiscnums.h"
34 #include "pub_core_threadstate.h"
35 #include "pub_core_xarray.h"
36 #include "pub_core_clientstate.h"
37 #include "pub_core_aspacemgr.h"
38 #include "pub_core_aspacehl.h"
39 #include "pub_core_commandline.h"
40 #include "pub_core_debuglog.h"
41 #include "pub_core_errormgr.h"
42 #include "pub_core_execontext.h"
43 #include "pub_core_initimg.h"
44 #include "pub_core_libcbase.h"
45 #include "pub_core_libcassert.h"
46 #include "pub_core_libcfile.h"
47 #include "pub_core_libcprint.h"
48 #include "pub_core_libcproc.h"
49 #include "pub_core_libcsignal.h"
50 #include "pub_core_syscall.h" // VG_(strerror)
51 #include "pub_core_mach.h"
52 #include "pub_core_machine.h"
53 #include "pub_core_mallocfree.h"
54 #include "pub_core_options.h"
55 #include "pub_core_debuginfo.h"
56 #include "pub_core_redir.h"
57 #include "pub_core_scheduler.h"
58 #include "pub_core_seqmatch.h" // For VG_(string_match)
59 #include "pub_core_signals.h"
60 #include "pub_core_stacks.h" // For VG_(register_stack)
61 #include "pub_core_syswrap.h"
62 #include "pub_core_tooliface.h"
63 #include "pub_core_translate.h" // For VG_(translate)
64 #include "pub_core_trampoline.h"
65 #include "pub_core_transtab.h"
66
67 /* Stuff for reading AIX5 /proc/<pid>/sysent files */
68 #if defined(VGO_aix5)
69 /* --- !!! --- EXTERNAL HEADERS start --- !!! --- */
70 # include <sys/procfs.h> /* prsysent_t */
71 /* --- !!! --- EXTERNAL HEADERS end --- !!! --- */
72 # define VG_AIX5_SYSENT_SIZE 100000
73 static UChar aix5_sysent_buf[VG_AIX5_SYSENT_SIZE];
74 #endif
75
76
77 /*====================================================================*/
78 /*=== Counters, for profiling purposes only ===*/
79 /*====================================================================*/
80
print_all_stats(void)81 static void print_all_stats ( void )
82 {
83 VG_(print_translation_stats)();
84 VG_(print_tt_tc_stats)();
85 VG_(print_scheduler_stats)();
86 VG_(print_ExeContext_stats)();
87 VG_(print_errormgr_stats)();
88
89 // Memory stats
90 if (VG_(clo_verbosity) > 2) {
91 VG_(message)(Vg_DebugMsg, "\n");
92 VG_(message)(Vg_DebugMsg,
93 "------ Valgrind's internal memory use stats follow ------\n" );
94 VG_(sanity_check_malloc_all)();
95 VG_(message)(Vg_DebugMsg, "------\n" );
96 VG_(print_all_arena_stats)();
97 VG_(message)(Vg_DebugMsg, "\n");
98 }
99 }
100
101
102 /*====================================================================*/
103 /*=== Command-line: variables, processing, etc ===*/
104 /*====================================================================*/
105
106 // See pub_{core,tool}_options.h for explanations of all these.
107
usage_NORETURN(Bool debug_help)108 static void usage_NORETURN ( Bool debug_help )
109 {
110 /* 'usage1' contains a %s for the name of the GDB executable, which
111 must be supplied when it is VG_(printf)'d. */
112 Char* usage1 =
113 "usage: valgrind [options] prog-and-args\n"
114 "\n"
115 " tool-selection option, with default in [ ]:\n"
116 " --tool=<name> use the Valgrind tool named <name> [memcheck]\n"
117 "\n"
118 " basic user options for all Valgrind tools, with defaults in [ ]:\n"
119 " -h --help show this message\n"
120 " --help-debug show this message, plus debugging options\n"
121 " --version show version\n"
122 " -q --quiet run silently; only print error msgs\n"
123 " -v --verbose be more verbose -- show misc extra info\n"
124 " --trace-children=no|yes Valgrind-ise child processes (follow execve)? [no]\n"
125 " --trace-children-skip=patt1,patt2,... specifies a list of executables\n"
126 " that --trace-children=yes should not trace into\n"
127 " --child-silent-after-fork=no|yes omit child output between fork & exec? [no]\n"
128 " --track-fds=no|yes track open file descriptors? [no]\n"
129 " --time-stamp=no|yes add timestamps to log messages? [no]\n"
130 " --log-fd=<number> log messages to file descriptor [2=stderr]\n"
131 " --log-file=<file> log messages to <file>\n"
132 " --log-socket=ipaddr:port log messages to socket ipaddr:port\n"
133 "\n"
134 " user options for Valgrind tools that report errors:\n"
135 " --xml=yes emit error output in XML (some tools only)\n"
136 " --xml-fd=<number> XML output to file descriptor\n"
137 " --xml-file=<file> XML output to <file>\n"
138 " --xml-socket=ipaddr:port XML output to socket ipaddr:port\n"
139 " --xml-user-comment=STR copy STR verbatim into XML output\n"
140 " --demangle=no|yes automatically demangle C++ names? [yes]\n"
141 " --num-callers=<number> show <number> callers in stack traces [12]\n"
142 " --error-limit=no|yes stop showing new errors if too many? [yes]\n"
143 " --error-exitcode=<number> exit code to return if errors found [0=disable]\n"
144 " --show-below-main=no|yes continue stack traces below main() [no]\n"
145 " --suppressions=<filename> suppress errors described in <filename>\n"
146 " --gen-suppressions=no|yes|all print suppressions for errors? [no]\n"
147 " --db-attach=no|yes start debugger when errors detected? [no]\n"
148 " --db-command=<command> command to start debugger [%s -nw %%f %%p]\n"
149 " --input-fd=<number> file descriptor for input [0=stdin]\n"
150 " --dsymutil=no|yes run dsymutil on Mac OS X when helpful? [no]\n"
151 " --max-stackframe=<number> assume stack switch for SP changes larger\n"
152 " than <number> bytes [2000000]\n"
153 " --main-stacksize=<number> set size of main thread's stack (in bytes)\n"
154 " [use current 'ulimit' value]\n"
155 "\n"
156 " user options for Valgrind tools that replace malloc:\n"
157 " --alignment=<number> set minimum alignment of heap allocations [%ld]\n"
158 "\n"
159 " uncommon user options for all Valgrind tools:\n"
160 " --fullpath-after= (with nothing after the '=')\n"
161 " show full source paths in call stacks\n"
162 " --fullpath-after=string like --fullpath-after=, but only show the\n"
163 " part of the path after 'string'. Allows removal\n"
164 " of path prefixes. Use this flag multiple times\n"
165 " to specify a set of prefixes to remove.\n"
166 " --smc-check=none|stack|all checks for self-modifying code: none,\n"
167 " only for code found in stacks, or all [stack]\n"
168 " --read-var-info=yes|no read debug info on stack and global variables\n"
169 " and use it to print better error messages in\n"
170 " tools that make use of it (Memcheck, Helgrind,\n"
171 " DRD) [no]\n"
172 " --run-libc-freeres=no|yes free up glibc memory at exit on Linux? [yes]\n"
173 " --sim-hints=hint1,hint2,... known hints:\n"
174 " lax-ioctls, enable-outer [none]\n"
175 " --kernel-variant=variant1,variant2,... known variants: bproc [none]\n"
176 " handle non-standard kernel variants\n"
177 " --show-emwarns=no|yes show warnings about emulation limits? [no]\n"
178 " --require-text-symbol=:sonamepattern:symbolpattern abort run if the\n"
179 " stated shared object doesn't have the stated\n"
180 " text symbol. Patterns can contain ? and *.\n"
181 "\n";
182
183 Char* usage2 =
184 "\n"
185 " debugging options for all Valgrind tools:\n"
186 " -d show verbose debugging output\n"
187 " --stats=no|yes show tool and core statistics [no]\n"
188 " --sanity-level=<number> level of sanity checking to do [1]\n"
189 " --trace-flags=<XXXXXXXX> show generated code? (X = 0|1) [00000000]\n"
190 " --profile-flags=<XXXXXXXX> ditto, but for profiling (X = 0|1) [00000000]\n"
191 " --trace-notbelow=<number> only show BBs above <number> [999999999]\n"
192 " --trace-syscalls=no|yes show all system calls? [no]\n"
193 " --trace-signals=no|yes show signal handling details? [no]\n"
194 " --trace-symtab=no|yes show symbol table details? [no]\n"
195 " --trace-symtab-patt=<patt> limit debuginfo tracing to obj name <patt>\n"
196 " --trace-cfi=no|yes show call-frame-info details? [no]\n"
197 " --debug-dump=syms mimic /usr/bin/readelf --syms\n"
198 " --debug-dump=line mimic /usr/bin/readelf --debug-dump=line\n"
199 " --debug-dump=frames mimic /usr/bin/readelf --debug-dump=frames\n"
200 " --trace-redir=no|yes show redirection details? [no]\n"
201 " --trace-sched=no|yes show thread scheduler details? [no]\n"
202 " --profile-heap=no|yes profile Valgrind's own space use\n"
203 " --wait-for-gdb=yes|no pause on startup to wait for gdb attach\n"
204 " --sym-offsets=yes|no show syms in form 'name+offset' ? [no]\n"
205 " --command-line-only=no|yes only use command line options [no]\n"
206 "\n"
207 " Vex options for all Valgrind tools:\n"
208 " --vex-iropt-verbosity=<0..9> [0]\n"
209 " --vex-iropt-level=<0..2> [2]\n"
210 " --vex-iropt-precise-memory-exns=no|yes [no]\n"
211 " --vex-iropt-unroll-thresh=<0..400> [120]\n"
212 " --vex-guest-max-insns=<1..100> [50]\n"
213 " --vex-guest-chase-thresh=<0..99> [10]\n"
214 " --vex-guest-chase-cond=no|yes [no]\n"
215 " --trace-flags and --profile-flags values (omit the middle space):\n"
216 " 1000 0000 show conversion into IR\n"
217 " 0100 0000 show after initial opt\n"
218 " 0010 0000 show after instrumentation\n"
219 " 0001 0000 show after second opt\n"
220 " 0000 1000 show after tree building\n"
221 " 0000 0100 show selecting insns\n"
222 " 0000 0010 show after reg-alloc\n"
223 " 0000 0001 show final assembly\n"
224 " (Nb: you need --trace-notbelow with --trace-flags for full details)\n"
225 "\n"
226 " debugging options for Valgrind tools that report errors\n"
227 " --dump-error=<number> show translation for basic block associated\n"
228 " with <number>'th error context [0=show none]\n"
229 "\n"
230 " debugging options for Valgrind tools that replace malloc:\n"
231 " --trace-malloc=no|yes show client malloc details? [no]\n"
232 "\n";
233
234 Char* usage3 =
235 "\n"
236 " Extra options read from ~/.valgrindrc, $VALGRIND_OPTS, ./.valgrindrc\n"
237 "\n"
238 " %s is %s\n"
239 " Valgrind is Copyright (C) 2000-2010, and GNU GPL'd, by Julian Seward et al.\n"
240 " LibVEX is Copyright (C) 2004-2010, and GNU GPL'd, by OpenWorks LLP et al.\n"
241 "\n"
242 " Bug reports, feedback, admiration, abuse, etc, to: %s.\n"
243 "\n";
244
245 Char* gdb_path = GDB_PATH;
246
247 // Ensure the message goes to stdout
248 VG_(log_output_sink).fd = 1;
249 VG_(log_output_sink).is_socket = False;
250
251 /* 'usage1' expects one char* argument and one SizeT argument. */
252 VG_(printf)(usage1, gdb_path, VG_MIN_MALLOC_SZB);
253 if (VG_(details).name) {
254 VG_(printf)(" user options for %s:\n", VG_(details).name);
255 if (VG_(needs).command_line_options)
256 VG_TDICT_CALL(tool_print_usage);
257 else
258 VG_(printf)(" (none)\n");
259 }
260 if (debug_help) {
261 VG_(printf)("%s", usage2);
262
263 if (VG_(details).name) {
264 VG_(printf)(" debugging options for %s:\n", VG_(details).name);
265
266 if (VG_(needs).command_line_options)
267 VG_TDICT_CALL(tool_print_debug_usage);
268 else
269 VG_(printf)(" (none)\n");
270 }
271 }
272 VG_(printf)(usage3, VG_(details).name, VG_(details).copyright_author,
273 VG_BUGS_TO);
274 VG_(exit)(0);
275 }
276
277
278 /* Peer at previously set up VG_(args_for_valgrind) and do some
279 minimal command line processing that must happen early on:
280
281 - show the version string, if requested (-v)
282 - extract any request for help (--help, -h, --help-debug)
283 - get the toolname (--tool=)
284 - set VG_(clo_max_stackframe) (--max-stackframe=)
285 - set VG_(clo_main_stacksize) (--main-stacksize=)
286
287 That's all it does. The main command line processing is done below
288 by main_process_cmd_line_options. Note that
289 main_process_cmd_line_options has to handle but ignore the ones we
290 have handled here.
291 */
early_process_cmd_line_options(Int * need_help,HChar ** tool)292 static void early_process_cmd_line_options ( /*OUT*/Int* need_help,
293 /*OUT*/HChar** tool )
294 {
295 UInt i;
296 HChar* str;
297
298 vg_assert( VG_(args_for_valgrind) );
299
300 /* parse the options we have (only the options we care about now) */
301 for (i = 0; i < VG_(sizeXA)( VG_(args_for_valgrind) ); i++) {
302
303 str = * (HChar**) VG_(indexXA)( VG_(args_for_valgrind), i );
304 vg_assert(str);
305
306 // Nb: the version string goes to stdout.
307 if VG_XACT_CLO(str, "--version", VG_(log_output_sink).fd, 1) {
308 VG_(log_output_sink).is_socket = False;
309 VG_(printf)("valgrind-" VERSION "\n");
310 VG_(exit)(0);
311 }
312 else if VG_XACT_CLO(str, "--help", *need_help, *need_help+1) {}
313 else if VG_XACT_CLO(str, "-h", *need_help, *need_help+1) {}
314
315 else if VG_XACT_CLO(str, "--help-debug", *need_help, *need_help+2) {}
316
317 // The tool has already been determined, but we need to know the name
318 // here.
319 else if VG_STR_CLO(str, "--tool", *tool) {}
320
321 // Set up VG_(clo_max_stackframe) and VG_(clo_main_stacksize).
322 // These are needed by VG_(ii_create_image), which happens
323 // before main_process_cmd_line_options().
324 else if VG_INT_CLO(str, "--max-stackframe", VG_(clo_max_stackframe)) {}
325 else if VG_INT_CLO(str, "--main-stacksize", VG_(clo_main_stacksize)) {}
326 }
327 }
328
reopen_output_fd(Bool xml)329 Int reopen_output_fd(Bool xml) {
330 // Returns FD
331 Char *filename = NULL;
332 Char *fsname_unexpanded = xml ? VG_(clo_xml_fname_unexpanded) :
333 VG_(clo_log_fname_unexpanded);
334 const Char *output_type = xml ? "xml" : "log";
335 Int ret = -1;
336 SysRes sres;
337
338 vg_assert(fsname_unexpanded != NULL);
339 vg_assert(VG_(strlen)(fsname_unexpanded) <= 900); /* paranoia */
340
341 // Nb: we overwrite an existing file of this name without asking
342 // any questions.
343 filename = VG_(expand_file_name)(xml ? "--xml-file" : "--log-file",
344 fsname_unexpanded);
345 sres = VG_(open)(filename,
346 VKI_O_CREAT|VKI_O_WRONLY|VKI_O_TRUNC,
347 VKI_S_IRUSR|VKI_S_IWUSR);
348 if (!sr_isError(sres)) {
349 ret = sr_Res(sres);
350 if (xml)
351 VG_(clo_xml_fname_expanded) = filename;
352 else
353 VG_(clo_log_fname_expanded) = filename;
354
355 /* strdup here is probably paranoid overkill, but ... */
356 // TODO: do we need to do anything with it?
357 /* *fsname_unexpanded = VG_(strdup)( "main.mpclo.2",
358 xml_fsname_unexpanded ); */
359 } else {
360 VG_(message)(Vg_UserMsg,
361 "Can't create %s file '%s' (%s); giving up!\n",
362 output_type, filename, VG_(strerror)(sr_Err(sres)));
363 VG_(fmsg_bad_option)("--[xml|log]-file=<file>",
364 "--[xml|log]-file=<file> (didn't work out for some reason.)");
365 /*NOTREACHED*/
366 }
367
368 return ret;
369 }
370
move_fd_into_safe_range(Int fd,Bool xml)371 static Int move_fd_into_safe_range(Int fd, Bool xml) {
372 OutputSink *sink = xml ? &(VG_(xml_output_sink)) : &(VG_(log_output_sink));
373 // Move fd into the safe range, so it doesn't conflict with any app fds.
374 fd = VG_(fcntl)(fd, VKI_F_DUPFD, VG_(fd_hard_limit));
375 if (fd < 0) {
376 VG_(printf)("valgrind: failed to move %s file fd "
377 "into safe range, using stderr\n", xml ? "XML" : "log");
378 sink->fd = 2; // stderr
379 sink->is_socket = False;
380 } else {
381 sink->fd = fd;
382 VG_(fcntl)(fd, VKI_F_SETFD, VKI_FD_CLOEXEC);
383 }
384 return fd;
385 }
386
387 /* The main processing for command line options. See comments above
388 on early_process_cmd_line_options.
389
390 Comments on how the logging options are handled:
391
392 User can specify:
393 --log-fd= for a fd to write to (default setting, fd = 2)
394 --log-file= for a file name to write to
395 --log-socket= for a socket to write to
396
397 As a result of examining these and doing relevant socket/file
398 opening, a final fd is established. This is stored in
399 VG_(log_output_sink) in m_libcprint. Also, if --log-file=STR was
400 specified, then STR, after expansion of %p and %q templates within
401 it, is stored in VG_(clo_log_fname_expanded), in m_options, just in
402 case anybody wants to know what it is.
403
404 When printing, VG_(log_output_sink) is consulted to find the
405 fd to send output to.
406
407 Exactly analogous actions are undertaken for the XML output
408 channel, with the one difference that the default fd is -1, meaning
409 the channel is disabled by default.
410 */
411 static
main_process_cmd_line_options(Bool * logging_to_fd,const HChar * toolname)412 void main_process_cmd_line_options ( /*OUT*/Bool* logging_to_fd,
413 const HChar* toolname )
414 {
415 // VG_(clo_log_fd) is used by all the messaging. It starts as 2 (stderr)
416 // and we cannot change it until we know what we are changing it to is
417 // ok. So we have tmp_log_fd to hold the tmp fd prior to that point.
418 Int i, tmp_log_fd, tmp_xml_fd;
419 Int toolname_len = VG_(strlen)(toolname);
420 Char* tmp_str; // Used in a couple of places.
421 enum {
422 VgLogTo_Fd,
423 VgLogTo_File,
424 VgLogTo_Socket
425 } log_to = VgLogTo_Fd, // Where is logging output to be sent?
426 xml_to = VgLogTo_Fd; // Where is XML output to be sent?
427
428 /* Temporarily holds the string STR specified with
429 --{log,xml}-{name,socket}=STR. 'fs' stands for
430 file-or-socket. */
431 Char* log_fsname_unexpanded = NULL;
432 Char* xml_fsname_unexpanded = NULL;
433
434 /* Log to stderr by default, but usage message goes to stdout. XML
435 output is initially disabled. */
436 tmp_log_fd = 2;
437 tmp_xml_fd = -1;
438
439 /* Check for sane path in ./configure --prefix=... */
440 if (VG_LIBDIR[0] != '/')
441 VG_(err_config_error)("Please use absolute paths in "
442 "./configure --prefix=... or --libdir=...");
443
444 vg_assert( VG_(args_for_valgrind) );
445
446 /* BEGIN command-line processing loop */
447
448 for (i = 0; i < VG_(sizeXA)( VG_(args_for_valgrind) ); i++) {
449
450 HChar* arg = * (HChar**) VG_(indexXA)( VG_(args_for_valgrind), i );
451 HChar* colon = arg;
452
453 // Look for a colon in the option name.
454 while (*colon && *colon != ':' && *colon != '=')
455 colon++;
456
457 // Does it have the form "--toolname:foo"? We have to do it at the start
458 // in case someone has combined a prefix with a core-specific option,
459 // eg. "--memcheck:verbose".
460 if (*colon == ':') {
461 if (VG_STREQN(2, arg, "--") &&
462 VG_STREQN(toolname_len, arg+2, toolname) &&
463 VG_STREQN(1, arg+2+toolname_len, ":"))
464 {
465 // Prefix matches, convert "--toolname:foo" to "--foo".
466 // Two things to note:
467 // - We cannot modify the option in-place. If we did, and then
468 // a child was spawned with --trace-children=yes, the
469 // now-non-prefixed option would be passed and could screw up
470 // the child.
471 // - We create copies, and never free them. Why? Non-prefixed
472 // options hang around forever, so tools need not make copies
473 // of strings within them. We need to have the same behaviour
474 // for prefixed options. The pointer to the copy will be lost
475 // once we leave this function (although a tool may keep a
476 // pointer into it), but the space wasted is insignificant.
477 // (In bug #142197, the copies were being freed, which caused
478 // problems for tools that reasonably assumed that arguments
479 // wouldn't disappear on them.)
480 if (0)
481 VG_(printf)("tool-specific arg: %s\n", arg);
482 arg = VG_(strdup)("main.mpclo.1", arg + toolname_len + 1);
483 arg[0] = '-';
484 arg[1] = '-';
485
486 } else {
487 // prefix doesn't match, skip to next arg
488 continue;
489 }
490 }
491
492 /* Ignore these options - they've already been handled */
493 if VG_STREQN( 7, arg, "--tool=") {}
494 else if VG_STREQN(20, arg, "--command-line-only=") {}
495 else if VG_STREQ( arg, "--") {}
496 else if VG_STREQ( arg, "-d") {}
497 else if VG_STREQN(16, arg, "--max-stackframe") {}
498 else if VG_STREQN(16, arg, "--main-stacksize") {}
499 else if VG_STREQN(14, arg, "--profile-heap") {}
500
501 // These options are new.
502 else if (VG_STREQ(arg, "-v") ||
503 VG_STREQ(arg, "--verbose"))
504 VG_(clo_verbosity)++;
505
506 else if (VG_STREQ(arg, "-q") ||
507 VG_STREQ(arg, "--quiet"))
508 VG_(clo_verbosity)--;
509
510 else if VG_BOOL_CLO(arg, "--stats", VG_(clo_stats)) {}
511 else if VG_BOOL_CLO(arg, "--xml", VG_(clo_xml)) {}
512 else if VG_BOOL_CLO(arg, "--db-attach", VG_(clo_db_attach)) {}
513 else if VG_BOOL_CLO(arg, "--demangle", VG_(clo_demangle)) {}
514 else if VG_BOOL_CLO(arg, "--error-limit", VG_(clo_error_limit)) {}
515 else if VG_INT_CLO (arg, "--error-exitcode", VG_(clo_error_exitcode)) {}
516 else if VG_BOOL_CLO(arg, "--show-emwarns", VG_(clo_show_emwarns)) {}
517
518 else if VG_BOOL_CLO(arg, "--run-libc-freeres", VG_(clo_run_libc_freeres)) {}
519 else if VG_BOOL_CLO(arg, "--show-below-main", VG_(clo_show_below_main)) {}
520 else if VG_BOOL_CLO(arg, "--time-stamp", VG_(clo_time_stamp)) {}
521 else if VG_BOOL_CLO(arg, "--track-fds", VG_(clo_track_fds)) {}
522 else if VG_BOOL_CLO(arg, "--trace-children", VG_(clo_trace_children)) {}
523 else if VG_BOOL_CLO(arg, "--child-silent-after-fork",
524 VG_(clo_child_silent_after_fork)) {}
525 else if VG_BOOL_CLO(arg, "--trace-sched", VG_(clo_trace_sched)) {}
526 else if VG_BOOL_CLO(arg, "--trace-signals", VG_(clo_trace_signals)) {}
527 else if VG_BOOL_CLO(arg, "--trace-symtab", VG_(clo_trace_symtab)) {}
528 else if VG_STR_CLO (arg, "--trace-symtab-patt", VG_(clo_trace_symtab_patt)) {}
529 else if VG_BOOL_CLO(arg, "--trace-cfi", VG_(clo_trace_cfi)) {}
530 else if VG_XACT_CLO(arg, "--debug-dump=syms", VG_(clo_debug_dump_syms),
531 True) {}
532 else if VG_XACT_CLO(arg, "--debug-dump=line", VG_(clo_debug_dump_line),
533 True) {}
534 else if VG_XACT_CLO(arg, "--debug-dump=frames",
535 VG_(clo_debug_dump_frames), True) {}
536 else if VG_BOOL_CLO(arg, "--trace-redir", VG_(clo_trace_redir)) {}
537
538 else if VG_BOOL_CLO(arg, "--trace-syscalls", VG_(clo_trace_syscalls)) {}
539 else if VG_BOOL_CLO(arg, "--wait-for-gdb", VG_(clo_wait_for_gdb)) {}
540 else if VG_STR_CLO (arg, "--db-command", VG_(clo_db_command)) {}
541 else if VG_STR_CLO (arg, "--sim-hints", VG_(clo_sim_hints)) {}
542 else if VG_BOOL_CLO(arg, "--sym-offsets", VG_(clo_sym_offsets)) {}
543 else if VG_BOOL_CLO(arg, "--read-var-info", VG_(clo_read_var_info)) {}
544
545 else if VG_INT_CLO (arg, "--dump-error", VG_(clo_dump_error)) {}
546 else if VG_INT_CLO (arg, "--input-fd", VG_(clo_input_fd)) {}
547 else if VG_INT_CLO (arg, "--sanity-level", VG_(clo_sanity_level)) {}
548 else if VG_BINT_CLO(arg, "--num-callers", VG_(clo_backtrace_size), 1,
549 VG_DEEPEST_BACKTRACE) {}
550
551 else if VG_XACT_CLO(arg, "--smc-check=none", VG_(clo_smc_check),
552 Vg_SmcNone);
553 else if VG_XACT_CLO(arg, "--smc-check=stack", VG_(clo_smc_check),
554 Vg_SmcStack);
555 else if VG_XACT_CLO(arg, "--smc-check=all", VG_(clo_smc_check),
556 Vg_SmcAll);
557
558 else if VG_STR_CLO (arg, "--memfs-malloc-path", VG_(clo_memfs_malloc_path)) {}
559 else if VG_INT_CLO (arg, "--memfs-page-size", VG_(clo_memfs_page_size)) {}
560 else if VG_STR_CLO (arg, "--kernel-variant", VG_(clo_kernel_variant)) {}
561
562 else if VG_BOOL_CLO(arg, "--dsymutil", VG_(clo_dsymutil)) {}
563
564 else if VG_STR_CLO (arg, "--trace-children-skip", VG_(clo_trace_children_skip)) {}
565
566 else if VG_BINT_CLO(arg, "--vex-iropt-verbosity",
567 VG_(clo_vex_control).iropt_verbosity, 0, 10) {}
568 else if VG_BINT_CLO(arg, "--vex-iropt-level",
569 VG_(clo_vex_control).iropt_level, 0, 2) {}
570 else if VG_BOOL_CLO(arg, "--vex-iropt-precise-memory-exns",
571 VG_(clo_vex_control).iropt_precise_memory_exns) {}
572 else if VG_BINT_CLO(arg, "--vex-iropt-unroll-thresh",
573 VG_(clo_vex_control).iropt_unroll_thresh, 0, 400) {}
574 else if VG_BINT_CLO(arg, "--vex-guest-max-insns",
575 VG_(clo_vex_control).guest_max_insns, 1, 100) {}
576 else if VG_BINT_CLO(arg, "--vex-guest-chase-thresh",
577 VG_(clo_vex_control).guest_chase_thresh, 0, 99) {}
578 else if VG_BOOL_CLO(arg, "--vex-guest-chase-cond",
579 VG_(clo_vex_control).guest_chase_cond) {}
580
581 else if VG_INT_CLO(arg, "--log-fd", tmp_log_fd) {
582 log_to = VgLogTo_Fd;
583 log_fsname_unexpanded = NULL;
584 }
585 else if VG_INT_CLO(arg, "--xml-fd", tmp_xml_fd) {
586 xml_to = VgLogTo_Fd;
587 xml_fsname_unexpanded = NULL;
588 }
589
590 else if VG_STR_CLO(arg, "--log-file", log_fsname_unexpanded) {
591 log_to = VgLogTo_File;
592 VG_(clo_log_fname_unexpanded) =
593 VG_(strdup)("", log_fsname_unexpanded);
594 }
595 else if VG_STR_CLO(arg, "--xml-file", xml_fsname_unexpanded) {
596 xml_to = VgLogTo_File;
597 VG_(clo_xml_fname_unexpanded) =
598 VG_(strdup)("", xml_fsname_unexpanded);
599 }
600
601 else if VG_STR_CLO(arg, "--log-socket", log_fsname_unexpanded) {
602 log_to = VgLogTo_Socket;
603 }
604 else if VG_STR_CLO(arg, "--xml-socket", xml_fsname_unexpanded) {
605 xml_to = VgLogTo_Socket;
606 }
607
608 else if VG_STR_CLO(arg, "--xml-user-comment",
609 VG_(clo_xml_user_comment)) {}
610
611 else if VG_STR_CLO(arg, "--suppressions", tmp_str) {
612 if (VG_(clo_n_suppressions) >= VG_CLO_MAX_SFILES) {
613 VG_(fmsg_bad_option)(arg,
614 "Too many suppression files specified.\n"
615 "Increase VG_CLO_MAX_SFILES and recompile.\n");
616 }
617 VG_(clo_suppressions)[VG_(clo_n_suppressions)] = tmp_str;
618 VG_(clo_n_suppressions)++;
619 }
620
621 else if VG_STR_CLO (arg, "--fullpath-after", tmp_str) {
622 if (VG_(clo_n_fullpath_after) >= VG_CLO_MAX_FULLPATH_AFTER) {
623 VG_(fmsg_bad_option)(arg,
624 "Too many --fullpath-after= specifications.\n"
625 "Increase VG_CLO_MAX_FULLPATH_AFTER and recompile.\n");
626 }
627 VG_(clo_fullpath_after)[VG_(clo_n_fullpath_after)] = tmp_str;
628 VG_(clo_n_fullpath_after)++;
629 }
630
631 else if VG_STR_CLO(arg, "--require-text-symbol", tmp_str) {
632 if (VG_(clo_n_req_tsyms) >= VG_CLO_MAX_REQ_TSYMS) {
633 VG_(fmsg_bad_option)(arg,
634 "Too many --require-text-symbol= specifications.\n"
635 "Increase VG_CLO_MAX_REQ_TSYMS and recompile.\n");
636 }
637 /* String needs to be of the form C?*C?*, where C is any
638 character, but is the same both times. Having it in this
639 form facilitates finding the boundary between the sopatt
640 and the fnpatt just by looking for the second occurrence
641 of C, without hardwiring any assumption about what C
642 is. */
643 Char patt[7];
644 Bool ok = True;
645 ok = tmp_str && VG_(strlen)(tmp_str) > 0;
646 if (ok) {
647 patt[0] = patt[3] = tmp_str[0];
648 patt[1] = patt[4] = '?';
649 patt[2] = patt[5] = '*';
650 patt[6] = 0;
651 ok = VG_(string_match)(patt, tmp_str);
652 }
653 if (!ok) {
654 VG_(fmsg_bad_option)(arg,
655 "Invalid --require-text-symbol= specification.\n");
656 }
657 VG_(clo_req_tsyms)[VG_(clo_n_req_tsyms)] = tmp_str;
658 VG_(clo_n_req_tsyms)++;
659 }
660
661 /* "stuvwxyz" --> stuvwxyz (binary) */
662 else if VG_STR_CLO(arg, "--trace-flags", tmp_str) {
663 Int j;
664
665 if (8 != VG_(strlen)(tmp_str)) {
666 VG_(fmsg_bad_option)(arg,
667 "--trace-flags argument must have 8 digits\n");
668 }
669 for (j = 0; j < 8; j++) {
670 if ('0' == tmp_str[j]) { /* do nothing */ }
671 else if ('1' == tmp_str[j]) VG_(clo_trace_flags) |= (1 << (7-j));
672 else {
673 VG_(fmsg_bad_option)(arg,
674 "--trace-flags argument can only contain 0s and 1s\n");
675 }
676 }
677 }
678
679 /* "stuvwxyz" --> stuvwxyz (binary) */
680 else if VG_STR_CLO(arg, "--profile-flags", tmp_str) {
681 Int j;
682
683 if (8 != VG_(strlen)(tmp_str)) {
684 VG_(fmsg_bad_option)(arg,
685 "--profile-flags argument must have 8 digits\n");
686 }
687 for (j = 0; j < 8; j++) {
688 if ('0' == tmp_str[j]) { /* do nothing */ }
689 else if ('1' == tmp_str[j]) VG_(clo_profile_flags) |= (1 << (7-j));
690 else {
691 VG_(fmsg_bad_option)(arg,
692 "--profile-flags argument can only contain 0s and 1s\n");
693 }
694 }
695 }
696
697 else if VG_INT_CLO (arg, "--trace-notbelow", VG_(clo_trace_notbelow)) {}
698
699 else if VG_XACT_CLO(arg, "--gen-suppressions=no",
700 VG_(clo_gen_suppressions), 0) {}
701 else if VG_XACT_CLO(arg, "--gen-suppressions=yes",
702 VG_(clo_gen_suppressions), 1) {}
703 else if VG_XACT_CLO(arg, "--gen-suppressions=all",
704 VG_(clo_gen_suppressions), 2) {}
705
706 else if ( ! VG_(needs).command_line_options
707 || ! VG_TDICT_CALL(tool_process_cmd_line_option, arg) ) {
708 VG_(fmsg_bad_option)(arg, "");
709 }
710 }
711
712 /* END command-line processing loop */
713
714 /* Make VEX control parameters sane */
715
716 if (VG_(clo_vex_control).guest_chase_thresh
717 >= VG_(clo_vex_control).guest_max_insns)
718 VG_(clo_vex_control).guest_chase_thresh
719 = VG_(clo_vex_control).guest_max_insns - 1;
720
721 if (VG_(clo_vex_control).guest_chase_thresh < 0)
722 VG_(clo_vex_control).guest_chase_thresh = 0;
723
724 /* Check various option values */
725
726 if (VG_(clo_verbosity) < 0)
727 VG_(clo_verbosity) = 0;
728
729 /* If XML output is requested, check that the tool actually
730 supports it. */
731 if (VG_(clo_xml) && !VG_(needs).xml_output) {
732 VG_(clo_xml) = False;
733 VG_(message)(Vg_UserMsg,
734 "%s does not support XML output.\n", VG_(details).name);
735 VG_(fmsg_bad_option)("--xml=yes", "\n");
736 /*NOTREACHED*/
737 }
738
739 vg_assert( VG_(clo_gen_suppressions) >= 0 );
740 vg_assert( VG_(clo_gen_suppressions) <= 2 );
741
742 /* If we've been asked to emit XML, mash around various other
743 options so as to constrain the output somewhat, and to remove
744 any need for user input during the run.
745 */
746 if (VG_(clo_xml)) {
747
748 /* We can't allow --gen-suppressions=yes, since that requires us
749 to print the error and then ask the user if she wants a
750 suppression for it, but in XML mode we won't print it until
751 we know whether we also need to print a suppression. Hence a
752 circular dependency. So disallow this.
753 (--gen-suppressions=all is still OK since we don't need any
754 user interaction in this case.) */
755 if (VG_(clo_gen_suppressions) == 1) {
756 VG_(fmsg_bad_option)(
757 "--xml=yes together with --gen-suppressions=yes",
758 "When --xml=yes is specified, --gen-suppressions=no\n"
759 "or --gen-suppressions=all is allowed, but not "
760 "--gen-suppressions=yes.\n");
761 }
762
763 /* We can't allow DB attaching (or we maybe could, but results
764 could be chaotic ..) since it requires user input. Hence
765 disallow. */
766 if (VG_(clo_db_attach)) {
767 VG_(fmsg_bad_option)(
768 "--xml=yes together with --db-attach=yes",
769 "--db-attach=yes is not allowed with --xml=yes\n"
770 "because it would require user input.\n");
771 }
772
773 /* Disallow dump_error in XML mode; sounds like a recipe for
774 chaos. No big deal; dump_error is a flag for debugging V
775 itself. */
776 if (VG_(clo_dump_error) > 0) {
777 VG_(fmsg_bad_option)("--xml=yes together with --dump-error", "");
778 }
779
780 /* Disable error limits (this might be a bad idea!) */
781 VG_(clo_error_limit) = False;
782 /* Disable emulation warnings */
783
784 /* Also, we want to set options for the leak checker, but that
785 will have to be done in Memcheck's flag-handling code, not
786 here. */
787 }
788
789 /* All non-logging-related options have been checked. If the logging
790 option specified is ok, we can switch to it, as we know we won't
791 have to generate any other command-line-related error messages.
792 (So far we should be still attached to stderr, so we can show on
793 the terminal any problems to do with processing command line
794 opts.)
795
796 So set up logging now. After this is done, VG_(log_output_sink)
797 and (if relevant) VG_(xml_output_sink) should be connected to
798 whatever sink has been selected, and we indiscriminately chuck
799 stuff into it without worrying what the nature of it is. Oh the
800 wonder of Unix streams. */
801
802 vg_assert(VG_(log_output_sink).fd == 2 /* stderr */);
803 vg_assert(VG_(log_output_sink).is_socket == False);
804 vg_assert(VG_(clo_log_fname_expanded) == NULL);
805
806 vg_assert(VG_(xml_output_sink).fd == -1 /* disabled */);
807 vg_assert(VG_(xml_output_sink).is_socket == False);
808 vg_assert(VG_(clo_xml_fname_expanded) == NULL);
809
810 /* --- set up the normal text output channel --- */
811
812 switch (log_to) {
813
814 case VgLogTo_Fd:
815 vg_assert(log_fsname_unexpanded == NULL);
816 break;
817
818 case VgLogTo_File: {
819 tmp_log_fd = reopen_output_fd(False);
820 break;
821 }
822
823 case VgLogTo_Socket: {
824 vg_assert(log_fsname_unexpanded != NULL);
825 vg_assert(VG_(strlen)(log_fsname_unexpanded) <= 900); /* paranoia */
826 tmp_log_fd = VG_(connect_via_socket)( log_fsname_unexpanded );
827 if (tmp_log_fd == -1) {
828 VG_(fmsg)("Invalid --log-socket spec of '%s'\n",
829 log_fsname_unexpanded);
830 VG_(exit)(1);
831 /*NOTREACHED*/
832 }
833 if (tmp_log_fd == -2) {
834 VG_(umsg)("failed to connect to logging server '%s'.\n"
835 "Log messages will sent to stderr instead.\n",
836 log_fsname_unexpanded );
837
838 /* We don't change anything here. */
839 vg_assert(VG_(log_output_sink).fd == 2);
840 tmp_log_fd = 2;
841 } else {
842 vg_assert(tmp_log_fd > 0);
843 VG_(log_output_sink).is_socket = True;
844 }
845 break;
846 }
847 }
848
849 /* --- set up the XML output channel --- */
850
851 switch (xml_to) {
852
853 case VgLogTo_Fd:
854 vg_assert(xml_fsname_unexpanded == NULL);
855 break;
856
857 case VgLogTo_File: {
858 tmp_xml_fd = reopen_output_fd(True);
859 break;
860 }
861
862 case VgLogTo_Socket: {
863 vg_assert(xml_fsname_unexpanded != NULL);
864 vg_assert(VG_(strlen)(xml_fsname_unexpanded) <= 900); /* paranoia */
865 tmp_xml_fd = VG_(connect_via_socket)( xml_fsname_unexpanded );
866 if (tmp_xml_fd == -1) {
867 VG_(fmsg)("Invalid --xml-socket spec of '%s'\n",
868 xml_fsname_unexpanded );
869 VG_(exit)(1);
870 /*NOTREACHED*/
871 }
872 if (tmp_xml_fd == -2) {
873 VG_(umsg)("failed to connect to XML logging server '%s'.\n"
874 "XML output will sent to stderr instead.\n",
875 xml_fsname_unexpanded);
876 /* We don't change anything here. */
877 vg_assert(VG_(xml_output_sink).fd == 2);
878 tmp_xml_fd = 2;
879 } else {
880 vg_assert(tmp_xml_fd > 0);
881 VG_(xml_output_sink).is_socket = True;
882 }
883 break;
884 }
885 }
886
887 /* If we've got this far, and XML mode was requested, but no XML
888 output channel appears to have been specified, just stop. We
889 could continue, and XML output will simply vanish into nowhere,
890 but that is likely to confuse the hell out of users, which is
891 distinctly Ungood. */
892 if (VG_(clo_xml) && tmp_xml_fd == -1) {
893 VG_(fmsg_bad_option)(
894 "--xml=yes, but no XML destination specified",
895 "--xml=yes has been specified, but there is no XML output\n"
896 "destination. You must specify an XML output destination\n"
897 "using --xml-fd, --xml-file or --xml-socket.\n"
898 );
899 }
900
901 // Finalise the output fds: the log fd ..
902
903 if (tmp_log_fd >= 0) {
904 tmp_log_fd = move_fd_into_safe_range(tmp_log_fd, False);
905 } else {
906 // If they said --log-fd=-1, don't print anything. Plausible for use in
907 // regression testing suites that use client requests to count errors.
908 VG_(log_output_sink).fd = -1;
909 VG_(log_output_sink).is_socket = False;
910 }
911
912 // Finalise the output fds: and the XML fd ..
913
914 if (tmp_xml_fd >= 0) {
915 tmp_xml_fd = move_fd_into_safe_range(tmp_xml_fd, True);
916 } else {
917 // If they said --xml-fd=-1, don't print anything. Plausible for use in
918 // regression testing suites that use client requests to count errors.
919 VG_(xml_output_sink).fd = -1;
920 VG_(xml_output_sink).is_socket = False;
921 }
922
923 // Suppressions related stuff
924
925 if (VG_(clo_n_suppressions) < VG_CLO_MAX_SFILES-1 &&
926 (VG_(needs).core_errors || VG_(needs).tool_errors)) {
927 /* If we haven't reached the max number of suppressions, load
928 the default one. */
929 static const Char default_supp[] = "default.supp";
930 Int len = VG_(strlen)(VG_(libdir)) + 1 + sizeof(default_supp);
931 Char *buf = VG_(arena_malloc)(VG_AR_CORE, "main.mpclo.3", len);
932 VG_(sprintf)(buf, "%s/%s", VG_(libdir), default_supp);
933 VG_(clo_suppressions)[VG_(clo_n_suppressions)] = buf;
934 VG_(clo_n_suppressions)++;
935 }
936
937 *logging_to_fd = log_to == VgLogTo_Fd || log_to == VgLogTo_Socket;
938 }
939
940 // Write the name and value of log file qualifiers to the xml file.
print_file_vars(Char * format)941 static void print_file_vars(Char* format)
942 {
943 Int i = 0;
944
945 while (format[i]) {
946 if (format[i] == '%') {
947 // We saw a '%'. What's next...
948 i++;
949 if ('q' == format[i]) {
950 i++;
951 if ('{' == format[i]) {
952 // Get the env var name, print its contents.
953 Char* qualname;
954 Char* qual;
955 i++;
956 qualname = &format[i];
957 while (True) {
958 if ('}' == format[i]) {
959 // Temporarily replace the '}' with NUL to extract var
960 // name.
961 format[i] = 0;
962 qual = VG_(getenv)(qualname);
963 break;
964 }
965 i++;
966 }
967
968 VG_(printf_xml_no_f_c)(
969 "<logfilequalifier> <var>%t</var> "
970 "<value>%t</value> </logfilequalifier>\n",
971 qualname,qual
972 );
973 format[i] = '}';
974 i++;
975 }
976 }
977 } else {
978 i++;
979 }
980 }
981 }
982
983
984 /*====================================================================*/
985 /*=== Printing the preamble ===*/
986 /*====================================================================*/
987
988 // Print the command, escaping any chars that require it.
umsg_or_xml_arg(const Char * arg,UInt (* umsg_or_xml)(const HChar *,...))989 static void umsg_or_xml_arg(const Char* arg,
990 UInt (*umsg_or_xml)( const HChar*, ... ) )
991 {
992 SizeT len = VG_(strlen)(arg);
993 Char* special = " \\<>";
994 Int i;
995 for (i = 0; i < len; i++) {
996 if (VG_(strchr)(special, arg[i])) {
997 umsg_or_xml("\\"); // escape with a backslash if necessary
998 }
999 umsg_or_xml("%c", arg[i]);
1000 }
1001 }
1002
1003 /* Ok, the logging sink is running now. Print a suitable preamble.
1004 If logging to file or a socket, write details of parent PID and
1005 command line args, to help people trying to interpret the
1006 results of a run which encompasses multiple processes. */
1007 // TODO(timurrrr): we add a non-static declaration of this function since
1008 // we need it in coregrind/m_libcproc.c
1009 // NOTE: Keep this definition in sync with coregrind/m_libcproc.c
1010 // in case of merge conflict.
1011 // Should we move it to some header file?
1012 void print_preamble ( Bool logging_to_fd, const HChar* toolname );
1013
print_preamble(Bool logging_to_fd,const HChar * toolname)1014 void print_preamble ( Bool logging_to_fd, const HChar* toolname )
1015 {
1016 Int i;
1017 HChar* xpre = VG_(clo_xml) ? " <line>" : "";
1018 HChar* xpost = VG_(clo_xml) ? "</line>" : "";
1019 UInt (*umsg_or_xml)( const HChar*, ... )
1020 = VG_(clo_xml) ? VG_(printf_xml) : VG_(umsg);
1021
1022 static const char* last_toolname = NULL;
1023 vg_assert( VG_(args_for_client) );
1024 vg_assert( VG_(args_for_valgrind) );
1025
1026 // This way you may pass toolname == NULL provided the first invocation
1027 // with toolname != NULL takes place in valgrind_main().
1028 toolname = (toolname == NULL ? last_toolname : toolname);
1029 vg_assert( toolname );
1030 last_toolname = toolname;
1031
1032 if (VG_(clo_xml)) {
1033 VG_(printf_xml)("<?xml version=\"1.0\"?>\n");
1034 VG_(printf_xml)("\n");
1035 VG_(printf_xml)("<valgrindoutput>\n");
1036 VG_(printf_xml)("\n");
1037 VG_(printf_xml)("<protocolversion>4</protocolversion>\n");
1038 VG_(printf_xml)("<protocoltool>%s</protocoltool>\n", toolname);
1039 VG_(printf_xml)("\n");
1040 }
1041
1042 if (VG_(clo_xml) || VG_(clo_verbosity) > 0) {
1043
1044 if (VG_(clo_xml))
1045 VG_(printf_xml)("<preamble>\n");
1046
1047 /* Tool details */
1048 umsg_or_xml( VG_(clo_xml) ? "%s%t%t%t, %t%s\n" : "%s%s%s%s, %s%s\n",
1049 xpre,
1050 VG_(details).name,
1051 NULL == VG_(details).version ? "" : "-",
1052 NULL == VG_(details).version
1053 ? (Char*)"" : VG_(details).version,
1054 VG_(details).description,
1055 xpost );
1056
1057 if (VG_(strlen)(toolname) >= 4 && VG_STREQN(4, toolname, "exp-")) {
1058 umsg_or_xml(
1059 "%sNOTE: This is an Experimental-Class Valgrind Tool%s\n",
1060 xpre, xpost
1061 );
1062 }
1063
1064 umsg_or_xml( VG_(clo_xml) ? "%s%t%s\n" : "%s%s%s\n",
1065 xpre, VG_(details).copyright_author, xpost );
1066
1067 /* Core details */
1068 umsg_or_xml(
1069 "%sUsing Valgrind-%s and LibVEX; rerun with -h for copyright info%s\n",
1070 xpre, VERSION, xpost
1071 );
1072
1073 // Print the command line. At one point we wrapped at 80 chars and
1074 // printed a '\' as a line joiner, but that makes it hard to cut and
1075 // paste the command line (because of the "==pid==" prefixes), so we now
1076 // favour utility and simplicity over aesthetics.
1077 umsg_or_xml("%sCommand: ", xpre);
1078 if (VG_(args_the_exename))
1079 umsg_or_xml_arg(VG_(args_the_exename), umsg_or_xml);
1080 for (i = 0; i < VG_(sizeXA)( VG_(args_for_client) ); i++) {
1081 HChar* s = *(HChar**)VG_(indexXA)( VG_(args_for_client), i );
1082 umsg_or_xml(" ");
1083 umsg_or_xml_arg(s, umsg_or_xml);
1084 }
1085 umsg_or_xml("%s\n", xpost);
1086
1087 if (VG_(clo_xml))
1088 VG_(printf_xml)("</preamble>\n");
1089 }
1090
1091 // Print the parent PID, and other stuff, if necessary.
1092 if (!VG_(clo_xml) && VG_(clo_verbosity) > 0 && !logging_to_fd) {
1093 VG_(umsg)("Parent PID: %d\n", VG_(getppid)());
1094 }
1095 else
1096 if (VG_(clo_xml)) {
1097 Char *xml_fname_unexpanded = VG_(clo_xml_fname_unexpanded);
1098 VG_(printf_xml)("\n");
1099 VG_(printf_xml)("<pid>%d</pid>\n", VG_(getpid)());
1100 VG_(printf_xml)("<ppid>%d</ppid>\n", VG_(getppid)());
1101 VG_(printf_xml_no_f_c)("<tool>%t</tool>\n", toolname);
1102 if (xml_fname_unexpanded)
1103 print_file_vars(xml_fname_unexpanded);
1104 if (VG_(clo_xml_user_comment)) {
1105 /* Note: the user comment itself is XML and is therefore to
1106 be passed through verbatim (%s) rather than escaped
1107 (%t). */
1108 VG_(printf_xml)("<usercomment>%s</usercomment>\n",
1109 VG_(clo_xml_user_comment));
1110 }
1111 VG_(printf_xml)("\n");
1112 VG_(printf_xml)("<args>\n");
1113
1114 VG_(printf_xml)(" <vargv>\n");
1115 if (VG_(name_of_launcher))
1116 VG_(printf_xml_no_f_c)(" <exe>%t</exe>\n",
1117 VG_(name_of_launcher));
1118 else
1119 VG_(printf_xml_no_f_c)(" <exe>%t</exe>\n",
1120 "(launcher name unknown)");
1121 for (i = 0; i < VG_(sizeXA)( VG_(args_for_valgrind) ); i++) {
1122 VG_(printf_xml_no_f_c)(
1123 " <arg>%t</arg>\n",
1124 * (HChar**) VG_(indexXA)( VG_(args_for_valgrind), i )
1125 );
1126 }
1127 VG_(printf_xml)(" </vargv>\n");
1128
1129 VG_(printf_xml)(" <argv>\n");
1130 if (VG_(args_the_exename))
1131 VG_(printf_xml_no_f_c)(" <exe>%t</exe>\n",
1132 VG_(args_the_exename));
1133 for (i = 0; i < VG_(sizeXA)( VG_(args_for_client) ); i++) {
1134 VG_(printf_xml_no_f_c)(
1135 " <arg>%t</arg>\n",
1136 * (HChar**) VG_(indexXA)( VG_(args_for_client), i )
1137 );
1138 }
1139 VG_(printf_xml)(" </argv>\n");
1140
1141 VG_(printf_xml)("</args>\n");
1142 }
1143
1144 // Last thing in the preamble is a blank line.
1145 if (VG_(clo_xml))
1146 VG_(printf_xml)("\n");
1147 else if (VG_(clo_verbosity) > 0)
1148 VG_(umsg)("\n");
1149
1150 if (VG_(clo_verbosity) > 1) {
1151 SysRes fd;
1152 VexArch vex_arch;
1153 VexArchInfo vex_archinfo;
1154 if (!logging_to_fd)
1155 VG_(message)(Vg_DebugMsg, "\n");
1156 VG_(message)(Vg_DebugMsg, "Valgrind options:\n");
1157 for (i = 0; i < VG_(sizeXA)( VG_(args_for_valgrind) ); i++) {
1158 VG_(message)(Vg_DebugMsg,
1159 " %s\n",
1160 * (HChar**) VG_(indexXA)( VG_(args_for_valgrind), i ));
1161 }
1162
1163 VG_(message)(Vg_DebugMsg, "Contents of /proc/version:\n");
1164 fd = VG_(open) ( "/proc/version", VKI_O_RDONLY, 0 );
1165 if (sr_isError(fd)) {
1166 VG_(message)(Vg_DebugMsg, " can't open /proc/version\n");
1167 } else {
1168 # define BUF_LEN 256
1169 Char version_buf[BUF_LEN];
1170 Int n = VG_(read) ( sr_Res(fd), version_buf, BUF_LEN );
1171 vg_assert(n <= BUF_LEN);
1172 if (n > 0) {
1173 version_buf[n-1] = '\0';
1174 VG_(message)(Vg_DebugMsg, " %s\n", version_buf);
1175 } else {
1176 VG_(message)(Vg_DebugMsg, " (empty?)\n");
1177 }
1178 VG_(close)(sr_Res(fd));
1179 # undef BUF_LEN
1180 }
1181
1182 VG_(machine_get_VexArchInfo)( &vex_arch, &vex_archinfo );
1183 VG_(message)(
1184 Vg_DebugMsg,
1185 "Arch and hwcaps: %s, %s\n",
1186 LibVEX_ppVexArch ( vex_arch ),
1187 LibVEX_ppVexHwCaps ( vex_arch, vex_archinfo.hwcaps )
1188 );
1189 VG_(message)(
1190 Vg_DebugMsg,
1191 "Page sizes: currently %d, max supported %d\n",
1192 (Int)VKI_PAGE_SIZE, (Int)VKI_MAX_PAGE_SIZE
1193 );
1194 VG_(message)(Vg_DebugMsg,
1195 "Valgrind library directory: %s\n", VG_(libdir));
1196 }
1197 }
1198
1199
1200 /*====================================================================*/
1201 /*=== File descriptor setup ===*/
1202 /*====================================================================*/
1203
1204 /* Number of file descriptors that Valgrind tries to reserve for
1205 it's own use - just a small constant. */
1206 #define N_RESERVED_FDS (10)
1207
setup_file_descriptors(void)1208 static void setup_file_descriptors(void)
1209 {
1210 struct vki_rlimit rl;
1211 Bool show = False;
1212
1213 /* Get the current file descriptor limits. */
1214 if (VG_(getrlimit)(VKI_RLIMIT_NOFILE, &rl) < 0) {
1215 rl.rlim_cur = 1024;
1216 rl.rlim_max = 1024;
1217 }
1218
1219 # if defined(VGO_darwin)
1220 /* Darwin lies. It reports file max as RLIM_INFINITY but
1221 silently disallows anything bigger than 10240. */
1222 if (rl.rlim_cur >= 10240 && rl.rlim_max == 0x7fffffffffffffffULL) {
1223 rl.rlim_max = 10240;
1224 }
1225 # endif
1226
1227 if (show)
1228 VG_(printf)("fd limits: host, before: cur %lu max %lu\n",
1229 (UWord)rl.rlim_cur, (UWord)rl.rlim_max);
1230
1231 # if defined(VGP_ppc32_aix5) || defined(VGP_ppc64_aix5)
1232 /* I don't know why this kludge is needed; however if rl.rlim_cur
1233 is RLIM_INFINITY, then VG_(safe_fd)'s attempts using VG_(fcntl)
1234 to lift V's file descriptors above the threshold RLIM_INFINITY -
1235 N_RESERVED_FDS fail. So just use a relatively conservative
1236 value in this case. */
1237 if (rl.rlim_cur > 1024)
1238 rl.rlim_cur = 1024;
1239 # endif
1240
1241 /* Work out where to move the soft limit to. */
1242 if (rl.rlim_cur + N_RESERVED_FDS <= rl.rlim_max) {
1243 rl.rlim_cur = rl.rlim_cur + N_RESERVED_FDS;
1244 } else {
1245 rl.rlim_cur = rl.rlim_max;
1246 }
1247
1248 /* Reserve some file descriptors for our use. */
1249 VG_(fd_soft_limit) = rl.rlim_cur - N_RESERVED_FDS;
1250 VG_(fd_hard_limit) = rl.rlim_cur - N_RESERVED_FDS;
1251
1252 /* Update the soft limit. */
1253 VG_(setrlimit)(VKI_RLIMIT_NOFILE, &rl);
1254
1255 if (show) {
1256 VG_(printf)("fd limits: host, after: cur %lu max %lu\n",
1257 (UWord)rl.rlim_cur, (UWord)rl.rlim_max);
1258 VG_(printf)("fd limits: guest : cur %u max %u\n",
1259 VG_(fd_soft_limit), VG_(fd_hard_limit));
1260 }
1261
1262 if (VG_(cl_exec_fd) != -1)
1263 VG_(cl_exec_fd) = VG_(safe_fd)( VG_(cl_exec_fd) );
1264 }
1265
1266
1267 /*====================================================================*/
1268 /*=== BB profiling ===*/
1269 /*====================================================================*/
1270
1271 static
show_BB_profile(BBProfEntry tops[],UInt n_tops,ULong score_total)1272 void show_BB_profile ( BBProfEntry tops[], UInt n_tops, ULong score_total )
1273 {
1274 ULong score_cumul, score_here;
1275 Char buf_cumul[10], buf_here[10];
1276 Char name[64];
1277 Int r;
1278
1279 VG_(printf)("\n");
1280 VG_(printf)("-----------------------------------------------------------\n");
1281 VG_(printf)("--- BEGIN BB Profile (summary of scores) ---\n");
1282 VG_(printf)("-----------------------------------------------------------\n");
1283 VG_(printf)("\n");
1284
1285 VG_(printf)("Total score = %lld\n\n", score_total);
1286
1287 score_cumul = 0;
1288 for (r = 0; r < n_tops; r++) {
1289 if (tops[r].addr == 0)
1290 continue;
1291 name[0] = 0;
1292 VG_(get_fnname_w_offset)(tops[r].addr, name, 64);
1293 name[63] = 0;
1294 score_here = tops[r].score;
1295 score_cumul += score_here;
1296 VG_(percentify)(score_cumul, score_total, 2, 6, buf_cumul);
1297 VG_(percentify)(score_here, score_total, 2, 6, buf_here);
1298 VG_(printf)("%3d: (%9lld %s) %9lld %s 0x%llx %s\n",
1299 r,
1300 score_cumul, buf_cumul,
1301 score_here, buf_here, tops[r].addr, name );
1302 }
1303
1304 VG_(printf)("\n");
1305 VG_(printf)("-----------------------------------------------------------\n");
1306 VG_(printf)("--- BB Profile (BB details) ---\n");
1307 VG_(printf)("-----------------------------------------------------------\n");
1308 VG_(printf)("\n");
1309
1310 score_cumul = 0;
1311 for (r = 0; r < n_tops; r++) {
1312 if (tops[r].addr == 0)
1313 continue;
1314 name[0] = 0;
1315 VG_(get_fnname_w_offset)(tops[r].addr, name, 64);
1316 name[63] = 0;
1317 score_here = tops[r].score;
1318 score_cumul += score_here;
1319 VG_(percentify)(score_cumul, score_total, 2, 6, buf_cumul);
1320 VG_(percentify)(score_here, score_total, 2, 6, buf_here);
1321 VG_(printf)("\n");
1322 VG_(printf)("=-=-=-=-=-=-=-=-=-=-=-=-=-= begin BB rank %d "
1323 "=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n", r);
1324 VG_(printf)("%3d: (%9lld %s) %9lld %s 0x%llx %s\n",
1325 r,
1326 score_cumul, buf_cumul,
1327 score_here, buf_here, tops[r].addr, name );
1328 VG_(printf)("\n");
1329 VG_(discard_translations)(tops[r].addr, 1, "bb profile");
1330 VG_(translate)(0, tops[r].addr, True, VG_(clo_profile_flags), 0, True);
1331 VG_(printf)("=-=-=-=-=-=-=-=-=-=-=-=-=-= end BB rank %d "
1332 "=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n", r);
1333 }
1334
1335 VG_(printf)("\n");
1336 VG_(printf)("-----------------------------------------------------------\n");
1337 VG_(printf)("--- END BB Profile ---\n");
1338 VG_(printf)("-----------------------------------------------------------\n");
1339 VG_(printf)("\n");
1340 }
1341
1342
1343 /*====================================================================*/
1344 /*=== main() ===*/
1345 /*====================================================================*/
1346
1347 /* When main() is entered, we should be on the following stack, not
1348 the one the kernel gave us. We will run on this stack until
1349 simulation of the root thread is started, at which point a transfer
1350 is made to a dynamically allocated stack. This is for the sake of
1351 uniform overflow detection for all Valgrind threads. This is
1352 marked global even though it isn't, because assembly code below
1353 needs to reference the name. */
1354
1355 /*static*/ VgStack VG_(interim_stack);
1356
1357 /* These are the structures used to hold info for creating the initial
1358 client image.
1359
1360 'iicii' mostly holds important register state present at system
1361 startup (_start_valgrind). valgrind_main() then fills in the rest
1362 of it and passes it to VG_(ii_create_image)(). That produces
1363 'iifii', which is later handed to VG_(ii_finalise_image). */
1364
1365 /* In all OS-instantiations, the_iicii has a field .sp_at_startup.
1366 This should get some address inside the stack on which we gained
1367 control (eg, it could be the SP at startup). It doesn't matter
1368 exactly where in the stack it is. This value is passed to the
1369 address space manager at startup. On Linux, aspacem then uses it
1370 to identify the initial stack segment and hence the upper end of
1371 the usable address space. */
1372
1373 static IICreateImageInfo the_iicii;
1374 static IIFinaliseImageInfo the_iifii;
1375
1376
1377 /* A simple pair structure, used for conveying debuginfo handles to
1378 calls to VG_TRACK(new_mem_startup, ...). */
1379 typedef struct { Addr a; ULong ull; } Addr_n_ULong;
1380
1381
1382 /* --- Forwards decls to do with shutdown --- */
1383
1384 static void final_tidyup(ThreadId tid);
1385
1386 /* Do everything which needs doing when the last thread exits */
1387 static
1388 void shutdown_actions_NORETURN( ThreadId tid,
1389 VgSchedReturnCode tids_schedretcode );
1390
1391 /* --- end of Forwards decls to do with shutdown --- */
1392
1393
1394 /* By the time we get to valgrind_main, the_iicii should already have
1395 been filled in with any important details as required by whatever
1396 OS we have been built for.
1397 */
1398 static
valgrind_main(Int argc,HChar ** argv,HChar ** envp)1399 Int valgrind_main ( Int argc, HChar **argv, HChar **envp )
1400 {
1401 HChar* toolname = "memcheck"; // default to Memcheck
1402 Int need_help = 0; // 0 = no, 1 = --help, 2 = --help-debug
1403 ThreadId tid_main = VG_INVALID_THREADID;
1404 Bool logging_to_fd = False;
1405 Int loglevel, i;
1406 struct vki_rlimit zero = { 0, 0 };
1407 XArray* addr2dihandle = NULL;
1408
1409 //============================================================
1410 //
1411 // Nb: startup is complex. Prerequisites are shown at every step.
1412 // *** Be very careful when messing with the order ***
1413 //
1414 // The first order of business is to get debug logging, the address
1415 // space manager and the dynamic memory manager up and running.
1416 // Once that's done, we can relax a bit.
1417 //
1418 //============================================================
1419
1420 /* This is needed to make VG_(getenv) usable early. */
1421 VG_(client_envp) = (Char**)envp;
1422
1423 //--------------------------------------------------------------
1424 // Start up Mach kernel interface, if any
1425 // p: none
1426 //--------------------------------------------------------------
1427 # if defined(VGO_darwin)
1428 VG_(mach_init)();
1429 # endif
1430
1431 //--------------------------------------------------------------
1432 // Start up the logging mechanism
1433 // p: none
1434 //--------------------------------------------------------------
1435 /* Start the debugging-log system ASAP. First find out how many
1436 "-d"s were specified. This is a pre-scan of the command line. Also
1437 get --profile-heap=yes which is needed by the time we start up dynamic
1438 memory management. */
1439 loglevel = 0;
1440 for (i = 1; i < argc; i++) {
1441 if (argv[i][0] != '-') break;
1442 if VG_STREQ(argv[i], "--") break;
1443 if VG_STREQ(argv[i], "-d") loglevel++;
1444 if VG_BOOL_CLO(argv[i], "--profile-heap", VG_(clo_profile_heap)) {}
1445 }
1446
1447 /* ... and start the debug logger. Now we can safely emit logging
1448 messages all through startup. */
1449 VG_(debugLog_startup)(loglevel, "Stage 2 (main)");
1450 VG_(debugLog)(1, "main", "Welcome to Valgrind version "
1451 VERSION " debug logging\n");
1452
1453 //--------------------------------------------------------------
1454 // AIX5 only: register the system call numbers
1455 // p: logging
1456 // p: that the initial few syscall numbers stated in the
1457 // bootblock have been installed (else we can't
1458 // open/read/close).
1459 //--------------------------------------------------------------
1460 # if defined(VGO_aix5)
1461 VG_(debugLog)(1, "main", "aix5: registering syscalls ..\n");
1462 { UChar sysent_name[50];
1463 SysRes fd;
1464 Bool ok;
1465 Int n_unregd, sysent_used = 0;
1466 prsysent_t* sysent_hdr;
1467
1468 VG_(sprintf)(sysent_name, "/proc/%d/sysent", VG_(getpid)());
1469 fd = VG_(open)(sysent_name, VKI_O_RDONLY, 0);
1470 if (fd.isError)
1471 VG_(err_config_error)("aix5: can't open /proc/<pid>/sysent");
1472
1473 sysent_used = VG_(read)(fd.res, aix5_sysent_buf, VG_AIX5_SYSENT_SIZE);
1474 if (sysent_used < 0)
1475 VG_(err_config_error)("aix5: error reading /proc/<pid>/sysent");
1476 if (sysent_used >= VG_AIX5_SYSENT_SIZE)
1477 VG_(err_config_error)("aix5: VG_AIX5_SYSENT_SIZE is too low; "
1478 "increase and recompile");
1479 VG_(close)(fd.res);
1480
1481 vg_assert(sysent_used > 0 && sysent_used < VG_AIX5_SYSENT_SIZE);
1482
1483 sysent_hdr = (prsysent_t*)&aix5_sysent_buf[0];
1484
1485 n_unregd = 0;
1486 for (i = 0; i < sysent_hdr->pr_nsyscalls; i++) {
1487 UChar* name = &aix5_sysent_buf[ sysent_hdr
1488 ->pr_syscall[i].pr_nameoff ];
1489 UInt nmbr = sysent_hdr->pr_syscall[i].pr_number;
1490 VG_(debugLog)(3, "main", "aix5: bind syscall %d to \"%s\"\n",
1491 nmbr, name);
1492 ok = VG_(aix5_register_syscall)(nmbr, name);
1493 if (!ok)
1494 n_unregd++;
1495 if (!ok)
1496 VG_(debugLog)(3, "main",
1497 "aix5: bind FAILED: %d to \"%s\"\n",
1498 nmbr, name);
1499 }
1500 VG_(debugLog)(1, "main", "aix5: .. %d syscalls known, %d unknown\n",
1501 sysent_hdr->pr_nsyscalls - n_unregd, n_unregd );
1502 VG_(debugLog)(1, "main", "aix5: __NR_AIX5_FAKE_SIGRETURN = %d\n",
1503 __NR_AIX5_FAKE_SIGRETURN );
1504 }
1505 # endif
1506
1507 //--------------------------------------------------------------
1508 // Ensure we're on a plausible stack.
1509 // p: logging
1510 //--------------------------------------------------------------
1511 VG_(debugLog)(1, "main", "Checking current stack is plausible\n");
1512 { HChar* limLo = (HChar*)(&VG_(interim_stack).bytes[0]);
1513 HChar* limHi = limLo + sizeof(VG_(interim_stack));
1514 HChar* aLocal = (HChar*)&zero; /* any auto local will do */
1515 if (aLocal < limLo || aLocal >= limHi) {
1516 /* something's wrong. Stop. */
1517 VG_(debugLog)(0, "main", "Root stack %p to %p, a local %p\n",
1518 limLo, limHi, aLocal );
1519 VG_(debugLog)(0, "main", "Valgrind: FATAL: "
1520 "Initial stack switched failed.\n");
1521 VG_(debugLog)(0, "main", " Cannot continue. Sorry.\n");
1522 VG_(exit)(1);
1523 }
1524 }
1525
1526 //--------------------------------------------------------------
1527 // Ensure we have a plausible pointer to the stack on which
1528 // we gained control (not the current stack!)
1529 // p: logging
1530 //--------------------------------------------------------------
1531 VG_(debugLog)(1, "main", "Checking initial stack was noted\n");
1532 if (the_iicii.sp_at_startup == 0) {
1533 VG_(debugLog)(0, "main", "Valgrind: FATAL: "
1534 "Initial stack was not noted.\n");
1535 VG_(debugLog)(0, "main", " Cannot continue. Sorry.\n");
1536 VG_(exit)(1);
1537 }
1538
1539 //--------------------------------------------------------------
1540 // Start up the address space manager, and determine the
1541 // approximate location of the client's stack
1542 // p: logging, plausible-stack
1543 //--------------------------------------------------------------
1544 VG_(debugLog)(1, "main", "Starting the address space manager\n");
1545 vg_assert(VKI_PAGE_SIZE == 4096 || VKI_PAGE_SIZE == 65536);
1546 vg_assert(VKI_MAX_PAGE_SIZE == 4096 || VKI_MAX_PAGE_SIZE == 65536);
1547 vg_assert(VKI_PAGE_SIZE <= VKI_MAX_PAGE_SIZE);
1548 vg_assert(VKI_PAGE_SIZE == (1 << VKI_PAGE_SHIFT));
1549 vg_assert(VKI_MAX_PAGE_SIZE == (1 << VKI_MAX_PAGE_SHIFT));
1550 the_iicii.clstack_top = VG_(am_startup)( the_iicii.sp_at_startup );
1551 VG_(debugLog)(1, "main", "Address space manager is running\n");
1552
1553 //--------------------------------------------------------------
1554 // Start up the dynamic memory manager
1555 // p: address space management
1556 // p: getting --profile-heap
1557 // In fact m_mallocfree is self-initialising, so there's no
1558 // initialisation call to do. Instead, try a simple malloc/
1559 // free pair right now to check that nothing is broken.
1560 //--------------------------------------------------------------
1561 VG_(debugLog)(1, "main", "Starting the dynamic memory manager\n");
1562 { void* p = VG_(malloc)( "main.vm.1", 12345 );
1563 if (p) VG_(free)( p );
1564 }
1565 VG_(debugLog)(1, "main", "Dynamic memory manager is running\n");
1566
1567 //============================================================
1568 //
1569 // Dynamic memory management is now available.
1570 //
1571 //============================================================
1572
1573 //--------------------------------------------------------------
1574 // Initialise m_debuginfo
1575 // p: dynamic memory allocation
1576 VG_(debugLog)(1, "main", "Initialise m_debuginfo\n");
1577 VG_(di_initialise)();
1578
1579 //--------------------------------------------------------------
1580 // Look for alternative libdir
1581 { HChar *cp = VG_(getenv)(VALGRIND_LIB);
1582 if (cp != NULL)
1583 VG_(libdir) = cp;
1584 VG_(debugLog)(1, "main", "VG_(libdir) = %s\n", VG_(libdir));
1585 }
1586
1587 //--------------------------------------------------------------
1588 // Extract the launcher name from the environment.
1589 VG_(debugLog)(1, "main", "Getting launcher's name ...\n");
1590 VG_(name_of_launcher) = VG_(getenv)(VALGRIND_LAUNCHER);
1591 if (VG_(name_of_launcher) == NULL) {
1592 VG_(printf)("valgrind: You cannot run '%s' directly.\n", argv[0]);
1593 VG_(printf)("valgrind: You should use $prefix/bin/valgrind.\n");
1594 VG_(exit)(1);
1595 }
1596 VG_(debugLog)(1, "main", "... %s\n", VG_(name_of_launcher));
1597
1598 //--------------------------------------------------------------
1599 // Get the current process datasize rlimit, and set it to zero.
1600 // This prevents any internal uses of brk() from having any effect.
1601 // We remember the old value so we can restore it on exec, so that
1602 // child processes will have a reasonable brk value.
1603 VG_(getrlimit)(VKI_RLIMIT_DATA, &VG_(client_rlimit_data));
1604 zero.rlim_max = VG_(client_rlimit_data).rlim_max;
1605 VG_(setrlimit)(VKI_RLIMIT_DATA, &zero);
1606
1607 // Get the current process stack rlimit.
1608 VG_(getrlimit)(VKI_RLIMIT_STACK, &VG_(client_rlimit_stack));
1609
1610 //--------------------------------------------------------------
1611 // Figure out what sort of CPU we're on, and whether it is
1612 // able to run V.
1613 VG_(debugLog)(1, "main", "Get hardware capabilities ...\n");
1614 { VexArch vex_arch;
1615 VexArchInfo vex_archinfo;
1616 Bool ok = VG_(machine_get_hwcaps)();
1617 if (!ok) {
1618 VG_(printf)("\n");
1619 VG_(printf)("valgrind: fatal error: unsupported CPU.\n");
1620 VG_(printf)(" Supported CPUs are:\n");
1621 VG_(printf)(" * x86 (practically any; Pentium-I or above), "
1622 "AMD Athlon or above)\n");
1623 VG_(printf)(" * AMD Athlon64/Opteron\n");
1624 VG_(printf)(" * PowerPC (most; ppc405 and above)\n");
1625 VG_(printf)("\n");
1626 VG_(exit)(1);
1627 }
1628 VG_(machine_get_VexArchInfo)( &vex_arch, &vex_archinfo );
1629 VG_(debugLog)(
1630 1, "main", "... arch = %s, hwcaps = %s\n",
1631 LibVEX_ppVexArch ( vex_arch ),
1632 LibVEX_ppVexHwCaps ( vex_arch, vex_archinfo.hwcaps )
1633 );
1634 }
1635
1636 //--------------------------------------------------------------
1637 // Record the working directory at startup
1638 // p: none (Linux), getenv and sys_getpid work (AIX)
1639 VG_(debugLog)(1, "main", "Getting the working directory at startup\n");
1640 { Bool ok = VG_(record_startup_wd)();
1641 if (!ok)
1642 VG_(err_config_error)( "Can't establish current working "
1643 "directory at startup");
1644 }
1645 { Char buf[VKI_PATH_MAX+1];
1646 Bool ok = VG_(get_startup_wd)( buf, sizeof(buf) );
1647 vg_assert(ok);
1648 buf[VKI_PATH_MAX] = 0;
1649 VG_(debugLog)(1, "main", "... %s\n", buf );
1650 }
1651
1652 //============================================================
1653 // Command line argument handling order:
1654 // * If --help/--help-debug are present, show usage message
1655 // (including the tool-specific usage)
1656 // * (If no --tool option given, default to Memcheck)
1657 // * Then, if client is missing, abort with error msg
1658 // * Then, if any cmdline args are bad, abort with error msg
1659 //============================================================
1660
1661 //--------------------------------------------------------------
1662 // Split up argv into: C args, V args, V extra args, and exename.
1663 // p: dynamic memory allocation
1664 //--------------------------------------------------------------
1665 VG_(debugLog)(1, "main", "Split up command line\n");
1666 VG_(split_up_argv)( argc, argv );
1667 vg_assert( VG_(args_for_valgrind) );
1668 vg_assert( VG_(args_for_client) );
1669 if (0) {
1670 for (i = 0; i < VG_(sizeXA)( VG_(args_for_valgrind) ); i++)
1671 VG_(printf)(
1672 "varg %s\n",
1673 * (HChar**) VG_(indexXA)( VG_(args_for_valgrind), i )
1674 );
1675 VG_(printf)(" exe %s\n", VG_(args_the_exename));
1676 for (i = 0; i < VG_(sizeXA)( VG_(args_for_client) ); i++)
1677 VG_(printf)(
1678 "carg %s\n",
1679 * (HChar**) VG_(indexXA)( VG_(args_for_client), i )
1680 );
1681 }
1682
1683 # if defined(VGO_aix5)
1684 /* Tolerate ptraced-based launchers. They can't run 'no program'
1685 if the user types "valgrind --help", so they run a do-nothing
1686 program $prefix/bin/no_op_client_for_valgrind, and we catch that
1687 here and turn it the exe name back into NULL. Then --help,
1688 --version etc work as they should. */
1689 if (VG_(args_the_exename)
1690 && VG_(strstr)( VG_(args_the_exename), "/no_op_client_for_valgrind" )) {
1691 VG_(args_the_exename) = NULL;
1692 }
1693 # endif
1694
1695 //--------------------------------------------------------------
1696 // Extract tool name and whether help has been requested.
1697 // Note we can't print the help message yet, even if requested,
1698 // because the tool has not been initialised.
1699 // p: split_up_argv [for VG_(args_for_valgrind)]
1700 //--------------------------------------------------------------
1701 VG_(debugLog)(1, "main",
1702 "(early_) Process Valgrind's command line options\n");
1703 early_process_cmd_line_options(&need_help, &toolname);
1704
1705 // Set default vex control params
1706 LibVEX_default_VexControl(& VG_(clo_vex_control));
1707
1708 //--------------------------------------------------------------
1709 // Load client executable, finding in $PATH if necessary
1710 // p: early_process_cmd_line_options() [for 'exec', 'need_help',
1711 // clo_max_stackframe,
1712 // clo_main_stacksize]
1713 // p: layout_remaining_space [so there's space]
1714 //
1715 // Set up client's environment
1716 // p: set-libdir [for VG_(libdir)]
1717 // p: early_process_cmd_line_options [for toolname]
1718 //
1719 // Setup client stack, eip, and VG_(client_arg[cv])
1720 // p: load_client() [for 'info']
1721 // p: fix_environment() [for 'env']
1722 //
1723 // Setup client data (brk) segment. Initially a 1-page segment
1724 // which abuts a shrinkable reservation.
1725 // p: load_client() [for 'info' and hence VG_(brk_base)]
1726 //
1727 // p: _start_in_C (for zeroing out the_iicii and putting some
1728 // initial values into it)
1729 //--------------------------------------------------------------
1730 if (!need_help) {
1731 VG_(debugLog)(1, "main", "Create initial image\n");
1732
1733 # if defined(VGO_linux) || defined(VGO_darwin)
1734 the_iicii.argv = argv;
1735 the_iicii.envp = envp;
1736 the_iicii.toolname = toolname;
1737 # elif defined(VGO_aix5)
1738 /* the_iicii.intregs37 already set up */
1739 /* the_iicii.bootblock already set up */
1740 /* the_iicii.adler32_exp already set up */
1741 /* the_iicii.sp_at_startup is irrelevant */
1742 /* the_iicii.clstack_top is irrelevant */
1743 the_iicii.toolname = toolname;
1744 # else
1745 # error "Unknown platform"
1746 # endif
1747
1748 /* NOTE: this call reads VG_(clo_main_stacksize). */
1749 the_iifii = VG_(ii_create_image)( the_iicii );
1750
1751 # if defined(VGO_aix5)
1752 /* Tell aspacem where the initial client stack is, so that it
1753 can later produce a faked-up NSegment in response to
1754 VG_(am_find_nsegment) for that address range, if asked. */
1755 /* NOTE: this call reads VG_(clo_main_stacksize). */
1756 VG_(am_aix5_set_initial_client_sp)( the_iifii.initial_client_SP );
1757 /* Now have a look at said fake segment, so we can find out
1758 the size of it. */
1759 { SizeT sz;
1760 NSegment const* seg
1761 = VG_(am_find_nsegment)( the_iifii.initial_client_SP );
1762 vg_assert(seg);
1763 sz = seg->end - seg->start + 1;
1764 vg_assert(sz >= 0 && sz <= (256+1)*1024*1024); /* stay sane */
1765 the_iifii.clstack_max_size = sz;
1766 }
1767 # endif
1768 }
1769
1770 //==============================================================
1771 //
1772 // Finished loading/setting up the client address space.
1773 //
1774 //==============================================================
1775
1776 //--------------------------------------------------------------
1777 // setup file descriptors
1778 // p: n/a
1779 //--------------------------------------------------------------
1780 VG_(debugLog)(1, "main", "Setup file descriptors\n");
1781 setup_file_descriptors();
1782
1783 //--------------------------------------------------------------
1784 // create the fake /proc/<pid>/cmdline file and then unlink it,
1785 // but hold onto the fd, so we can hand it out to the client
1786 // when it tries to open /proc/<pid>/cmdline for itself.
1787 // p: setup file descriptors
1788 //--------------------------------------------------------------
1789 #if !defined(VGO_linux)
1790 // client shouldn't be using /proc!
1791 VG_(cl_cmdline_fd) = -1;
1792 #else
1793 if (!need_help) {
1794 HChar buf[50], buf2[50+64];
1795 HChar nul[1];
1796 Int fd, r;
1797 const HChar* exename;
1798
1799 VG_(debugLog)(1, "main", "Create fake /proc/<pid>/cmdline\n");
1800
1801 VG_(sprintf)(buf, "proc_%d_cmdline", VG_(getpid)());
1802 fd = VG_(mkstemp)( buf, buf2 );
1803 if (fd == -1)
1804 VG_(err_config_error)("Can't create client cmdline file in " VG_TMPDIR);
1805
1806 nul[0] = 0;
1807 exename = VG_(args_the_exename) ? VG_(args_the_exename)
1808 : "unknown_exename";
1809 VG_(write)(fd, VG_(args_the_exename),
1810 VG_(strlen)( VG_(args_the_exename) ));
1811 VG_(write)(fd, nul, 1);
1812
1813 for (i = 0; i < VG_(sizeXA)( VG_(args_for_client) ); i++) {
1814 HChar* arg = * (HChar**) VG_(indexXA)( VG_(args_for_client), i );
1815 VG_(write)(fd, arg, VG_(strlen)( arg ));
1816 VG_(write)(fd, nul, 1);
1817 }
1818
1819 /* Don't bother to seek the file back to the start; instead do
1820 it every time a copy of it is given out (by PRE(sys_open)).
1821 That is probably more robust across fork() etc. */
1822
1823 /* Now delete it, but hang on to the fd. */
1824 r = VG_(unlink)( buf2 );
1825 if (r)
1826 VG_(err_config_error)("Can't delete client cmdline file in " VG_TMPDIR);
1827
1828 VG_(cl_cmdline_fd) = fd;
1829 }
1830 #endif
1831
1832 //--------------------------------------------------------------
1833 // Init tool part 1: pre_clo_init
1834 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
1835 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
1836 //--------------------------------------------------------------
1837 VG_(debugLog)(1, "main", "Initialise the tool part 1 (pre_clo_init)\n");
1838 VG_(tl_pre_clo_init)();
1839
1840 //--------------------------------------------------------------
1841 // If --tool and --help/--help-debug was given, now give the core+tool
1842 // help message
1843 // p: early_process_cmd_line_options() [for 'need_help']
1844 // p: tl_pre_clo_init [for 'VG_(tdict).usage']
1845 //--------------------------------------------------------------
1846 VG_(debugLog)(1, "main", "Print help and quit, if requested\n");
1847 if (need_help) {
1848 usage_NORETURN(/*--help-debug?*/need_help >= 2);
1849 }
1850
1851 //--------------------------------------------------------------
1852 // Process command line options to Valgrind + tool
1853 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
1854 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
1855 //--------------------------------------------------------------
1856 VG_(debugLog)(1, "main",
1857 "(main_) Process Valgrind's command line options, "
1858 "setup logging\n");
1859 main_process_cmd_line_options ( &logging_to_fd, toolname );
1860
1861 //--------------------------------------------------------------
1862 // Zeroise the millisecond counter by doing a first read of it.
1863 // p: none
1864 //--------------------------------------------------------------
1865 (void) VG_(read_millisecond_timer)();
1866
1867 //--------------------------------------------------------------
1868 // Print the preamble
1869 // p: tl_pre_clo_init [for 'VG_(details).name' and friends]
1870 // p: main_process_cmd_line_options()
1871 // [for VG_(clo_verbosity), VG_(clo_xml),
1872 // logging_to_fd]
1873 //--------------------------------------------------------------
1874 VG_(debugLog)(1, "main", "Print the preamble...\n");
1875 print_preamble(logging_to_fd, toolname);
1876 VG_(debugLog)(1, "main", "...finished the preamble\n");
1877
1878 //--------------------------------------------------------------
1879 // Init tool part 2: post_clo_init
1880 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
1881 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
1882 // p: print_preamble() [so any warnings printed in post_clo_init
1883 // are shown after the preamble]
1884 //--------------------------------------------------------------
1885 VG_(debugLog)(1, "main", "Initialise the tool part 2 (post_clo_init)\n");
1886 VG_TDICT_CALL(tool_post_clo_init);
1887 {
1888 /* The tool's "needs" will by now be finalised, since it has no
1889 further opportunity to specify them. So now sanity check
1890 them. */
1891 Char* s;
1892 Bool ok;
1893 ok = VG_(sanity_check_needs)( &s );
1894 if (!ok) {
1895 VG_(tool_panic)(s);
1896 }
1897 }
1898
1899 //--------------------------------------------------------------
1900 // Initialise translation table and translation cache
1901 // p: aspacem [??]
1902 // p: tl_pre_clo_init [for 'VG_(details).avg_translation_sizeB']
1903 //--------------------------------------------------------------
1904 VG_(debugLog)(1, "main", "Initialise TT/TC\n");
1905 VG_(init_tt_tc)();
1906
1907 //--------------------------------------------------------------
1908 // Initialise the redirect table.
1909 // p: init_tt_tc [so it can call VG_(search_transtab) safely]
1910 // p: aspacem [so can change ownership of sysinfo pages]
1911 //--------------------------------------------------------------
1912 VG_(debugLog)(1, "main", "Initialise redirects\n");
1913 VG_(redir_initialise)();
1914
1915 //--------------------------------------------------------------
1916 // Allow GDB attach
1917 // p: main_process_cmd_line_options() [for VG_(clo_wait_for_gdb)]
1918 //--------------------------------------------------------------
1919 /* Hook to delay things long enough so we can get the pid and
1920 attach GDB in another shell. */
1921 if (VG_(clo_wait_for_gdb)) {
1922 Long iters;
1923 volatile Long q;
1924 VG_(debugLog)(1, "main", "Wait for GDB\n");
1925 VG_(printf)("pid=%d, entering delay loop\n", VG_(getpid)());
1926
1927 # if defined(VGP_x86_linux)
1928 iters = 5;
1929 # elif defined(VGP_amd64_linux) || defined(VGP_ppc64_linux)
1930 iters = 10;
1931 # elif defined(VGP_ppc32_linux)
1932 iters = 5;
1933 # elif defined(VGP_arm_linux)
1934 iters = 1;
1935 # elif defined(VGP_ppc32_aix5) || defined(VGP_ppc64_aix5)
1936 iters = 4;
1937 # elif defined(VGO_darwin)
1938 iters = 3;
1939 # else
1940 # error "Unknown plat"
1941 # endif
1942
1943 iters *= 1000*1000*1000;
1944 for (q = 0; q < iters; q++)
1945 ;
1946 }
1947
1948 //--------------------------------------------------------------
1949 // Search for file descriptors that are inherited from our parent
1950 // p: main_process_cmd_line_options [for VG_(clo_track_fds)]
1951 //--------------------------------------------------------------
1952 if (VG_(clo_track_fds)) {
1953 VG_(debugLog)(1, "main", "Init preopened fds\n");
1954 VG_(init_preopened_fds)();
1955 }
1956
1957 //--------------------------------------------------------------
1958 // Load debug info for the existing segments.
1959 // p: setup_code_redirect_table [so that redirs can be recorded]
1960 // p: mallocfree
1961 // p: probably: setup fds and process CLOs, so that logging works
1962 // p: initialise m_debuginfo
1963 //
1964 // While doing this, make a note of the debuginfo-handles that
1965 // come back from VG_(di_notify_mmap)/VG_(di_aix5_notify_segchange).
1966 // Later, in "Tell the tool about the initial client memory permissions"
1967 // (just below) we can then hand these handles off to the tool in
1968 // calls to VG_TRACK(new_mem_startup, ...). This gives the tool the
1969 // opportunity to make further queries to m_debuginfo before the
1970 // client is started, if it wants. We put this information into an
1971 // XArray, each handle along with the associated segment start address,
1972 // and search the XArray for the handles later, when calling
1973 // VG_TRACK(new_mem_startup, ...).
1974 //--------------------------------------------------------------
1975 VG_(debugLog)(1, "main", "Load initial debug info\n");
1976
1977 tl_assert(!addr2dihandle);
1978 addr2dihandle = VG_(newXA)( VG_(malloc), "main.vm.2",
1979 VG_(free), sizeof(Addr_n_ULong) );
1980 tl_assert(addr2dihandle);
1981
1982 # if defined(VGO_linux)
1983 { Addr* seg_starts;
1984 Int n_seg_starts;
1985 Addr_n_ULong anu;
1986
1987 seg_starts = VG_(get_segment_starts)( &n_seg_starts );
1988 vg_assert(seg_starts && n_seg_starts >= 0);
1989
1990 /* show them all to the debug info reader. allow_SkFileV has to
1991 be True here so that we read info from the valgrind executable
1992 itself. */
1993 for (i = 0; i < n_seg_starts; i++) {
1994 anu.ull = VG_(di_notify_mmap)( seg_starts[i], True/*allow_SkFileV*/ );
1995 /* anu.ull holds the debuginfo handle returned by di_notify_mmap,
1996 if any. */
1997 if (anu.ull > 0) {
1998 anu.a = seg_starts[i];
1999 VG_(addToXA)( addr2dihandle, &anu );
2000 }
2001 }
2002
2003 VG_(free)( seg_starts );
2004 }
2005 # elif defined(VGO_aix5)
2006 { AixCodeSegChange* changes;
2007 Int changes_size, changes_used;
2008 Addr_n_ULong anu;
2009
2010 /* Find out how many AixCodeSegChange records we will need,
2011 and acquire them. */
2012 changes_size = VG_(am_aix5_reread_procmap_howmany_directives)();
2013 changes = VG_(malloc)("main.vm.3", changes_size * sizeof(AixCodeSegChange));
2014 vg_assert(changes);
2015
2016 /* Now re-read /proc/<pid>/map and acquire a change set */
2017 VG_(am_aix5_reread_procmap)( changes, &changes_used );
2018 vg_assert(changes_used >= 0 && changes_used <= changes_size);
2019
2020 /* And notify m_debuginfo of the changes. */
2021 for (i = 0; i < changes_used; i++) {
2022 anu.ull = VG_(di_aix5_notify_segchange)(
2023 changes[i].code_start,
2024 changes[i].code_len,
2025 changes[i].data_start,
2026 changes[i].data_len,
2027 changes[i].file_name,
2028 changes[i].mem_name,
2029 changes[i].is_mainexe,
2030 changes[i].acquire
2031 );
2032 if (anu.ull > 0) {
2033 tl_assert(changes[i].acquire);
2034 anu.a = changes[i].code_start; /* is this correct? */
2035 VG_(addToXA)( addr2dihandle, &anu );
2036 }
2037 }
2038
2039 VG_(free)(changes);
2040 }
2041 # elif defined(VGO_darwin)
2042 { Addr* seg_starts;
2043 Int n_seg_starts;
2044 seg_starts = VG_(get_segment_starts)( &n_seg_starts );
2045 vg_assert(seg_starts && n_seg_starts >= 0);
2046
2047 /* show them all to the debug info reader.
2048 Don't read from V segments (unlike Linux) */
2049 // GrP fixme really?
2050 for (i = 0; i < n_seg_starts; i++)
2051 VG_(di_notify_mmap)( seg_starts[i], False/*don't allow_SkFileV*/ );
2052
2053 VG_(free)( seg_starts );
2054 }
2055 # else
2056 # error Unknown OS
2057 # endif
2058
2059 //--------------------------------------------------------------
2060 // Tell aspacem of ownership change of the asm helpers, so that
2061 // m_translate allows them to be translated. However, only do this
2062 // after the initial debug info read, since making a hole in the
2063 // address range for the stage2 binary confuses the debug info reader.
2064 // p: aspacem
2065 //--------------------------------------------------------------
2066 { Bool change_ownership_v_c_OK;
2067 Addr co_start = VG_PGROUNDDN( (Addr)&VG_(trampoline_stuff_start) );
2068 Addr co_endPlus = VG_PGROUNDUP( (Addr)&VG_(trampoline_stuff_end) );
2069 VG_(debugLog)(1,"redir",
2070 "transfer ownership V -> C of 0x%llx .. 0x%llx\n",
2071 (ULong)co_start, (ULong)co_endPlus-1 );
2072
2073 change_ownership_v_c_OK
2074 = VG_(am_change_ownership_v_to_c)( co_start, co_endPlus - co_start );
2075 vg_assert(change_ownership_v_c_OK);
2076 }
2077
2078 //--------------------------------------------------------------
2079 // Initialise the scheduler (phase 1) [generates tid_main]
2080 // p: none, afaics
2081 //--------------------------------------------------------------
2082 VG_(debugLog)(1, "main", "Initialise scheduler (phase 1)\n");
2083 tid_main = VG_(scheduler_init_phase1)();
2084 vg_assert(tid_main >= 0 && tid_main < VG_N_THREADS
2085 && tid_main != VG_INVALID_THREADID);
2086 /* Tell the tool about tid_main */
2087 VG_TRACK( pre_thread_ll_create, VG_INVALID_THREADID, tid_main );
2088
2089 //--------------------------------------------------------------
2090 // Tell the tool about the initial client memory permissions
2091 // p: aspacem
2092 // p: mallocfree
2093 // p: setup_client_stack
2094 // p: setup_client_dataseg
2095 //
2096 // For each segment we tell the client about, look up in
2097 // addr2dihandle as created above, to see if there's a debuginfo
2098 // handle associated with the segment, that we can hand along
2099 // to the tool, to be helpful.
2100 //--------------------------------------------------------------
2101 VG_(debugLog)(1, "main", "Tell tool about initial permissions\n");
2102 { Addr* seg_starts;
2103 Int n_seg_starts;
2104
2105 tl_assert(addr2dihandle);
2106
2107 /* Mark the main thread as running while we tell the tool about
2108 the client memory so that the tool can associate that memory
2109 with the main thread. */
2110 tl_assert(VG_(running_tid) == VG_INVALID_THREADID);
2111 VG_(running_tid) = tid_main;
2112
2113 seg_starts = VG_(get_segment_starts)( &n_seg_starts );
2114 vg_assert(seg_starts && n_seg_starts >= 0);
2115
2116 /* show interesting ones to the tool */
2117 for (i = 0; i < n_seg_starts; i++) {
2118 Word j, n;
2119 NSegment const* seg
2120 = VG_(am_find_nsegment)( seg_starts[i] );
2121 vg_assert(seg);
2122 if (seg->kind == SkFileC || seg->kind == SkAnonC) {
2123 /* This next assertion is tricky. If it is placed
2124 immediately before this 'if', it very occasionally fails.
2125 Why? Because previous iterations of the loop may have
2126 caused tools (via the new_mem_startup calls) to do
2127 dynamic memory allocation, and that may affect the mapped
2128 segments; in particular it may cause segment merging to
2129 happen. Hence we cannot assume that seg_starts[i], which
2130 reflects the state of the world before we started this
2131 loop, is the same as seg->start, as the latter reflects
2132 the state of the world (viz, mappings) at this particular
2133 iteration of the loop.
2134
2135 Why does moving it inside the 'if' make it safe? Because
2136 any dynamic memory allocation done by the tools will
2137 affect only the state of Valgrind-owned segments, not of
2138 Client-owned segments. And the 'if' guards against that
2139 -- we only get in here for Client-owned segments.
2140
2141 In other words: the loop may change the state of
2142 Valgrind-owned segments as it proceeds. But it should
2143 not cause the Client-owned segments to change. */
2144 vg_assert(seg->start == seg_starts[i]);
2145 VG_(debugLog)(2, "main",
2146 "tell tool about %010lx-%010lx %c%c%c\n",
2147 seg->start, seg->end,
2148 seg->hasR ? 'r' : '-',
2149 seg->hasW ? 'w' : '-',
2150 seg->hasX ? 'x' : '-' );
2151 /* search addr2dihandle to see if we have an entry
2152 matching seg->start. */
2153 n = VG_(sizeXA)( addr2dihandle );
2154 for (j = 0; j < n; j++) {
2155 Addr_n_ULong* anl = VG_(indexXA)( addr2dihandle, j );
2156 if (anl->a == seg->start) {
2157 tl_assert(anl->ull > 0); /* check it's a valid handle */
2158 break;
2159 }
2160 }
2161 vg_assert(j >= 0 && j <= n);
2162 VG_TRACK( new_mem_startup, seg->start, seg->end+1-seg->start,
2163 seg->hasR, seg->hasW, seg->hasX,
2164 /* and the retrieved debuginfo handle, if any */
2165 j < n
2166 ? ((Addr_n_ULong*)VG_(indexXA)( addr2dihandle, j ))->ull
2167 : 0 );
2168 }
2169 }
2170
2171 VG_(free)( seg_starts );
2172 VG_(deleteXA)( addr2dihandle );
2173
2174 /* Also do the initial stack permissions. */
2175 {
2176 SSizeT inaccessible_len;
2177 NSegment const* seg
2178 = VG_(am_find_nsegment)( the_iifii.initial_client_SP );
2179 vg_assert(seg);
2180 vg_assert(seg->kind == SkAnonC);
2181 vg_assert(the_iifii.initial_client_SP >= seg->start);
2182 vg_assert(the_iifii.initial_client_SP <= seg->end);
2183 # if defined(VGO_aix5)
2184 VG_(clstk_base) = seg->start;
2185 VG_(clstk_end) = seg->end;
2186 # endif
2187
2188 /* Stuff below the initial SP is unaddressable. Take into
2189 account any ABI-mandated space below the stack pointer that
2190 is required (VG_STACK_REDZONE_SZB). setup_client_stack()
2191 will have allocated an extra page if a red zone is required,
2192 to be on the safe side. */
2193 inaccessible_len = the_iifii.initial_client_SP - VG_STACK_REDZONE_SZB
2194 - seg->start;
2195 vg_assert(inaccessible_len >= 0);
2196 if (inaccessible_len > 0)
2197 VG_TRACK( die_mem_stack,
2198 seg->start,
2199 inaccessible_len );
2200 VG_(debugLog)(2, "main", "mark stack inaccessible %010lx-%010lx\n",
2201 seg->start,
2202 the_iifii.initial_client_SP-1 - VG_STACK_REDZONE_SZB);
2203 }
2204
2205 /* Also the assembly helpers. */
2206 VG_TRACK( new_mem_startup,
2207 (Addr)&VG_(trampoline_stuff_start),
2208 (Addr)&VG_(trampoline_stuff_end)
2209 - (Addr)&VG_(trampoline_stuff_start),
2210 False, /* readable? */
2211 False, /* writable? */
2212 True /* executable? */,
2213 0 /* di_handle: no associated debug info */ );
2214
2215 /* Clear the running thread indicator */
2216 VG_(running_tid) = VG_INVALID_THREADID;
2217 tl_assert(VG_(running_tid) == VG_INVALID_THREADID);
2218 }
2219
2220 //--------------------------------------------------------------
2221 // Initialise the scheduler (phase 2)
2222 // p: Initialise the scheduler (phase 1) [for tid_main]
2223 // p: setup_file_descriptors() [else VG_(safe_fd)() breaks]
2224 // p: setup_client_stack
2225 //--------------------------------------------------------------
2226 VG_(debugLog)(1, "main", "Initialise scheduler (phase 2)\n");
2227 { NSegment const* seg
2228 = VG_(am_find_nsegment)( the_iifii.initial_client_SP );
2229 vg_assert(seg);
2230 vg_assert(seg->kind == SkAnonC);
2231 vg_assert(the_iifii.initial_client_SP >= seg->start);
2232 vg_assert(the_iifii.initial_client_SP <= seg->end);
2233 VG_(scheduler_init_phase2)( tid_main,
2234 seg->end, the_iifii.clstack_max_size );
2235 }
2236
2237 //--------------------------------------------------------------
2238 // Set up state for the root thread
2239 // p: ?
2240 // setup_scheduler() [for sched-specific thread 1 stuff]
2241 // VG_(ii_create_image) [for 'the_iicii' initial info]
2242 //--------------------------------------------------------------
2243 VG_(debugLog)(1, "main", "Finalise initial image\n");
2244 VG_(ii_finalise_image)( the_iifii );
2245
2246 //--------------------------------------------------------------
2247 // Initialise the signal handling subsystem
2248 // p: n/a
2249 //--------------------------------------------------------------
2250 // Nb: temporarily parks the saved blocking-mask in saved_sigmask.
2251 VG_(debugLog)(1, "main", "Initialise signal management\n");
2252 /* Check that the kernel-interface signal definitions look sane */
2253 VG_(vki_do_initial_consistency_checks)();
2254 /* .. and go on to use them. */
2255 VG_(sigstartup_actions)();
2256
2257 //--------------------------------------------------------------
2258 // Read suppression file
2259 // p: main_process_cmd_line_options() [for VG_(clo_suppressions)]
2260 //--------------------------------------------------------------
2261 if (VG_(needs).core_errors || VG_(needs).tool_errors) {
2262 VG_(debugLog)(1, "main", "Load suppressions\n");
2263 VG_(load_suppressions)();
2264 }
2265
2266 //--------------------------------------------------------------
2267 // register client stack
2268 //--------------------------------------------------------------
2269 VG_(clstk_id) = VG_(register_stack)(VG_(clstk_base), VG_(clstk_end));
2270
2271 //--------------------------------------------------------------
2272 // Show the address space state so far
2273 //--------------------------------------------------------------
2274 VG_(debugLog)(1, "main", "\n");
2275 VG_(debugLog)(1, "main", "\n");
2276 VG_(am_show_nsegments)(1,"Memory layout at client startup");
2277 VG_(debugLog)(1, "main", "\n");
2278 VG_(debugLog)(1, "main", "\n");
2279
2280 //--------------------------------------------------------------
2281 // Run!
2282 //--------------------------------------------------------------
2283 if (VG_(clo_xml)) {
2284 HChar buf[50];
2285 VG_(elapsed_wallclock_time)(buf);
2286 VG_(printf_xml_no_f_c)( "<status>\n"
2287 " <state>RUNNING</state>\n"
2288 " <time>%t</time>\n"
2289 "</status>\n",
2290 buf );
2291 VG_(printf_xml_no_f_c)( "\n" );
2292 }
2293
2294 VG_(debugLog)(1, "main", "Running thread 1\n");
2295
2296 /* As a result of the following call, the last thread standing
2297 eventually winds up running shutdown_actions_NORETURN
2298 just below. Unfortunately, simply exporting said function
2299 causes m_main to be part of a module cycle, which is pretty
2300 nonsensical. So instead of doing that, the address of said
2301 function is stored in a global variable 'owned' by m_syswrap,
2302 and it uses that function pointer to get back here when it needs
2303 to. */
2304
2305 /* Set continuation address. */
2306 VG_(address_of_m_main_shutdown_actions_NORETURN)
2307 = & shutdown_actions_NORETURN;
2308
2309 /* Run the first thread, eventually ending up at the continuation
2310 address. */
2311 VG_(main_thread_wrapper_NORETURN)(1);
2312
2313 /*NOTREACHED*/
2314 vg_assert(0);
2315 }
2316
2317 /* Do everything which needs doing when the last thread exits or when
2318 a thread exits requesting a complete process exit (exit on AIX).
2319
2320 We enter here holding The Lock. For the case VgSrc_ExitProcess we
2321 must never release it, because to do so would allow other threads
2322 to continue after the system is ostensibly shut down. So we must
2323 go to our grave, so to speak, holding the lock.
2324
2325 In fact, there is never any point in releasing the lock at this
2326 point - we have it, we're shutting down the entire system, and
2327 for the case VgSrc_ExitProcess doing so positively causes trouble.
2328 So don't.
2329
2330 The final_tidyup call makes a bit of a nonsense of the ExitProcess
2331 case, since it will run the libc_freeres function, thus allowing
2332 other lurking threads to run again. Hmm. */
2333
2334 static
shutdown_actions_NORETURN(ThreadId tid,VgSchedReturnCode tids_schedretcode)2335 void shutdown_actions_NORETURN( ThreadId tid,
2336 VgSchedReturnCode tids_schedretcode )
2337 {
2338 VG_(debugLog)(1, "main", "entering VG_(shutdown_actions_NORETURN)\n");
2339 VG_(am_show_nsegments)(1,"Memory layout at client shutdown");
2340
2341 vg_assert(VG_(is_running_thread)(tid));
2342
2343 vg_assert(tids_schedretcode == VgSrc_ExitThread
2344 || tids_schedretcode == VgSrc_ExitProcess
2345 || tids_schedretcode == VgSrc_FatalSig );
2346
2347 if (tids_schedretcode == VgSrc_ExitThread) {
2348
2349 // We are the last surviving thread. Right?
2350 vg_assert( VG_(count_living_threads)() == 1 );
2351
2352 // Wait for all other threads to exit.
2353 // jrs: Huh? but they surely are already gone
2354 VG_(reap_threads)(tid);
2355
2356 // Clean the client up before the final report
2357 // this causes the libc_freeres function to run
2358 final_tidyup(tid);
2359
2360 /* be paranoid */
2361 vg_assert(VG_(is_running_thread)(tid));
2362 vg_assert(VG_(count_living_threads)() == 1);
2363
2364 } else {
2365
2366 // We may not be the last surviving thread. However, we
2367 // want to shut down the entire process. We hold the lock
2368 // and we need to keep hold of it all the way out, in order
2369 // that none of the other threads ever run again.
2370 vg_assert( VG_(count_living_threads)() >= 1 );
2371
2372 // Clean the client up before the final report
2373 // this causes the libc_freeres function to run
2374 // perhaps this is unsafe, as per comment above
2375 final_tidyup(tid);
2376
2377 /* be paranoid */
2378 vg_assert(VG_(is_running_thread)(tid));
2379 vg_assert(VG_(count_living_threads)() >= 1);
2380 }
2381
2382 VG_(threads)[tid].status = VgTs_Empty;
2383 //--------------------------------------------------------------
2384 // Finalisation: cleanup, messages, etc. Order not so important, only
2385 // affects what order the messages come.
2386 //--------------------------------------------------------------
2387 // First thing in the post-amble is a blank line.
2388 if (VG_(clo_xml))
2389 VG_(printf_xml)("\n");
2390 else if (VG_(clo_verbosity) > 0)
2391 VG_(message)(Vg_UserMsg, "\n");
2392
2393 if (VG_(clo_xml)) {
2394 HChar buf[50];
2395 VG_(elapsed_wallclock_time)(buf);
2396 VG_(printf_xml_no_f_c)( "<status>\n"
2397 " <state>FINISHED</state>\n"
2398 " <time>%t</time>\n"
2399 "</status>\n"
2400 "\n",
2401 buf);
2402 }
2403
2404 /* Print out file descriptor summary and stats. */
2405 if (VG_(clo_track_fds))
2406 VG_(show_open_fds)();
2407
2408 /* Call the tool's finalisation function. This makes Memcheck's
2409 leak checker run, and possibly chuck a bunch of leak errors into
2410 the error management machinery. */
2411 VG_TDICT_CALL(tool_fini, 0/*exitcode*/);
2412
2413 /* Show the error counts. */
2414 if (VG_(clo_xml)
2415 && (VG_(needs).core_errors || VG_(needs).tool_errors)) {
2416 VG_(show_error_counts_as_XML)();
2417 }
2418
2419 /* In XML mode, this merely prints the used suppressions. */
2420 if (VG_(needs).core_errors || VG_(needs).tool_errors)
2421 VG_(show_all_errors)();
2422
2423 if (VG_(clo_xml)) {
2424 VG_(printf_xml)("\n");
2425 VG_(printf_xml)("</valgrindoutput>\n");
2426 VG_(printf_xml)("\n");
2427 }
2428
2429 VG_(sanity_check_general)( True /*include expensive checks*/ );
2430
2431 if (VG_(clo_stats))
2432 print_all_stats();
2433
2434 /* Show a profile of the heap(s) at shutdown. Optionally, first
2435 throw away all the debug info, as that makes it easy to spot
2436 leaks in the debuginfo reader. */
2437 if (VG_(clo_profile_heap)) {
2438 if (0) VG_(di_discard_ALL_debuginfo)();
2439 VG_(print_arena_cc_analysis)();
2440 }
2441
2442 if (VG_(clo_profile_flags) > 0) {
2443 #define N_MAX 200
2444 BBProfEntry tops[N_MAX];
2445 ULong score_total = VG_(get_BB_profile) (tops, N_MAX);
2446 show_BB_profile(tops, N_MAX, score_total);
2447 }
2448
2449 /* Print Vex storage stats */
2450 if (0)
2451 LibVEX_ShowAllocStats();
2452
2453 /* Flush any output cached by previous calls to VG_(message). */
2454 VG_(message_flush)();
2455
2456 /* Ok, finally exit in the os-specific way, according to the scheduler's
2457 return code. In short, if the (last) thread exited by calling
2458 sys_exit, do likewise; if the (last) thread stopped due to a fatal
2459 signal, terminate the entire system with that same fatal signal. */
2460 VG_(debugLog)(1, "core_os",
2461 "VG_(terminate_NORETURN)(tid=%lld)\n", (ULong)tid);
2462
2463 switch (tids_schedretcode) {
2464 case VgSrc_ExitThread: /* the normal way out (Linux) */
2465 case VgSrc_ExitProcess: /* the normal way out (AIX) */
2466 /* Change the application return code to user's return code,
2467 if an error was found */
2468 if (VG_(clo_error_exitcode) > 0
2469 && VG_(get_n_errs_found)() > 0) {
2470 VG_(exit)( VG_(clo_error_exitcode) );
2471 } else {
2472 /* otherwise, return the client's exit code, in the normal
2473 way. */
2474 VG_(exit)( VG_(threads)[tid].os_state.exitcode );
2475 }
2476 /* NOT ALIVE HERE! */
2477 VG_(core_panic)("entered the afterlife in main() -- ExitT/P");
2478 break; /* what the hell :) */
2479
2480 case VgSrc_FatalSig:
2481 /* We were killed by a fatal signal, so replicate the effect */
2482 vg_assert(VG_(threads)[tid].os_state.fatalsig != 0);
2483 VG_(kill_self)(VG_(threads)[tid].os_state.fatalsig);
2484 /* we shouldn't be alive at this point. But VG_(kill_self)
2485 sometimes fails with EPERM on Darwin, for unclear reasons. */
2486 # if defined(VGO_darwin)
2487 VG_(debugLog)(0, "main", "VG_(kill_self) failed. Exiting normally.\n");
2488 VG_(exit)(0); /* bogus, but we really need to exit now */
2489 /* fall through .. */
2490 # endif
2491 VG_(core_panic)("main(): signal was supposed to be fatal");
2492 break;
2493
2494 default:
2495 VG_(core_panic)("main(): unexpected scheduler return code");
2496 }
2497 }
2498
2499 /* -------------------- */
2500
2501 /* Final clean-up before terminating the process.
2502 Clean up the client by calling __libc_freeres() (if requested)
2503 This is Linux-specific?
2504 GrP fixme glibc-specific, anyway
2505 */
final_tidyup(ThreadId tid)2506 static void final_tidyup(ThreadId tid)
2507 {
2508 #if !defined(VGO_darwin)
2509 # if defined(VGP_ppc64_linux)
2510 Addr r2;
2511 # endif
2512 Addr __libc_freeres_wrapper = VG_(client___libc_freeres_wrapper);
2513
2514 vg_assert(VG_(is_running_thread)(tid));
2515
2516 if ( !VG_(needs).libc_freeres ||
2517 !VG_(clo_run_libc_freeres) ||
2518 0 == __libc_freeres_wrapper )
2519 return; /* can't/won't do it */
2520 # if defined(VGO_aix5)
2521 return; /* inapplicable on non-Linux platforms */
2522 # endif
2523
2524 # if defined(VGP_ppc64_linux)
2525 r2 = VG_(get_tocptr)( __libc_freeres_wrapper );
2526 if (r2 == 0) {
2527 VG_(message)(Vg_UserMsg,
2528 "Caught __NR_exit, but can't run __libc_freeres()\n");
2529 VG_(message)(Vg_UserMsg,
2530 " since cannot establish TOC pointer for it.\n");
2531 return;
2532 }
2533 # endif
2534
2535 if (VG_(clo_verbosity) > 2 ||
2536 VG_(clo_trace_syscalls) ||
2537 VG_(clo_trace_sched))
2538 VG_(message)(Vg_DebugMsg,
2539 "Caught __NR_exit; running __libc_freeres()\n");
2540
2541 /* set thread context to point to libc_freeres_wrapper */
2542 /* ppc64-linux note: __libc_freeres_wrapper gives us the real
2543 function entry point, not a fn descriptor, so can use it
2544 directly. However, we need to set R2 (the toc pointer)
2545 appropriately. */
2546 VG_(set_IP)(tid, __libc_freeres_wrapper);
2547 # if defined(VGP_ppc64_linux)
2548 VG_(threads)[tid].arch.vex.guest_GPR2 = r2;
2549 # endif
2550
2551 /* Block all blockable signals by copying the real block state into
2552 the thread's block state*/
2553 VG_(sigprocmask)(VKI_SIG_BLOCK, NULL, &VG_(threads)[tid].sig_mask);
2554 VG_(threads)[tid].tmp_sig_mask = VG_(threads)[tid].sig_mask;
2555
2556 /* and restore handlers to default */
2557 VG_(set_default_handler)(VKI_SIGSEGV);
2558 VG_(set_default_handler)(VKI_SIGBUS);
2559 VG_(set_default_handler)(VKI_SIGILL);
2560 VG_(set_default_handler)(VKI_SIGFPE);
2561
2562 // We were exiting, so assert that...
2563 vg_assert(VG_(is_exiting)(tid));
2564 // ...but now we're not again
2565 VG_(threads)[tid].exitreason = VgSrc_None;
2566
2567 // run until client thread exits - ideally with LIBC_FREERES_DONE,
2568 // but exit/exitgroup/signal will do
2569 VG_(scheduler)(tid);
2570
2571 vg_assert(VG_(is_exiting)(tid));
2572 #endif
2573 }
2574
2575
2576 /*====================================================================*/
2577 /*=== Getting to main() alive: LINUX ===*/
2578 /*====================================================================*/
2579
2580 #if defined(VGO_linux)
2581
2582 /* If linking of the final executables is done with glibc present,
2583 then Valgrind starts at main() above as usual, and all of the
2584 following code is irrelevant.
2585
2586 However, this is not the intended mode of use. The plan is to
2587 avoid linking against glibc, by giving gcc the flags
2588 -nodefaultlibs -lgcc -nostartfiles at startup.
2589
2590 From this derive two requirements:
2591
2592 1. gcc may emit calls to memcpy and memset to deal with structure
2593 assignments etc. Since we have chosen to ignore all the
2594 "normal" supporting libraries, we have to provide our own
2595 implementations of them. No problem.
2596
2597 2. We have to provide a symbol "_start", to which the kernel
2598 hands control at startup. Hence the code below.
2599 */
2600
2601 /* ---------------- Requirement 1 ---------------- */
2602
2603 void* memcpy(void *dest, const void *src, SizeT n);
memcpy(void * dest,const void * src,SizeT n)2604 void* memcpy(void *dest, const void *src, SizeT n) {
2605 return VG_(memcpy)(dest,src,n);
2606 }
2607 void* memset(void *s, int c, SizeT n);
memset(void * s,int c,SizeT n)2608 void* memset(void *s, int c, SizeT n) {
2609 return VG_(memset)(s,c,n);
2610 }
2611
2612 /* BVA: abort() for those platforms that need it (PPC and ARM). */
2613 void abort(void);
abort(void)2614 void abort(void){
2615 VG_(printf)("Something called raise().\n");
2616 vg_assert(0);
2617 }
2618
2619 /* EAZG: ARM's EABI will call floating point exception handlers in
2620 libgcc which boil down to an abort or raise, that's usually defined
2621 in libc. Instead, define them here. */
2622 #if defined(VGP_arm_linux)
2623 void raise(void);
raise(void)2624 void raise(void){
2625 VG_(printf)("Something called raise().\n");
2626 vg_assert(0);
2627 }
2628
2629 void __aeabi_unwind_cpp_pr0(void);
__aeabi_unwind_cpp_pr0(void)2630 void __aeabi_unwind_cpp_pr0(void){
2631 VG_(printf)("Something called __aeabi_unwind_cpp_pr0()\n");
2632 vg_assert(0);
2633 }
2634
2635 void __aeabi_unwind_cpp_pr1(void);
__aeabi_unwind_cpp_pr1(void)2636 void __aeabi_unwind_cpp_pr1(void){
2637 VG_(printf)("Something called __aeabi_unwind_cpp_pr1()\n");
2638 vg_assert(0);
2639 }
2640 #endif
2641
2642 /* ---------------- Requirement 2 ---------------- */
2643
2644 /* Glibc's sysdeps/i386/elf/start.S has the following gem of a
2645 comment, which explains how the stack looks right at process start
2646 (when _start is jumped to). Hence _start passes %esp to
2647 _start_in_C_linux, which extracts argc/argv/envp and starts up
2648 correctly. */
2649
2650 /* This is the canonical entry point, usually the first thing in the text
2651 segment. The SVR4/i386 ABI (pages 3-31, 3-32) says that when the entry
2652 point runs, most registers' values are unspecified, except for:
2653
2654 %edx Contains a function pointer to be registered with `atexit'.
2655 This is how the dynamic linker arranges to have DT_FINI
2656 functions called for shared libraries that have been loaded
2657 before this code runs.
2658
2659 %esp The stack contains the arguments and environment:
2660 0(%esp) argc
2661 4(%esp) argv[0]
2662 ...
2663 (4*argc)(%esp) NULL
2664 (4*(argc+1))(%esp) envp[0]
2665 ...
2666 NULL
2667 */
2668
2669 /* The kernel hands control to _start, which extracts the initial
2670 stack pointer and calls onwards to _start_in_C_linux. This also switches
2671 the new stack. */
2672 #if defined(VGP_x86_linux)
2673 asm("\n"
2674 ".text\n"
2675 "\t.globl _start\n"
2676 "\t.type _start,@function\n"
2677 "_start:\n"
2678 /* set up the new stack in %eax */
2679 "\tmovl $vgPlain_interim_stack, %eax\n"
2680 "\taddl $"VG_STRINGIFY(VG_STACK_GUARD_SZB)", %eax\n"
2681 "\taddl $"VG_STRINGIFY(VG_STACK_ACTIVE_SZB)", %eax\n"
2682 "\tsubl $16, %eax\n"
2683 "\tandl $~15, %eax\n"
2684 /* install it, and collect the original one */
2685 "\txchgl %eax, %esp\n"
2686 /* call _start_in_C_linux, passing it the startup %esp */
2687 "\tpushl %eax\n"
2688 "\tcall _start_in_C_linux\n"
2689 "\thlt\n"
2690 ".previous\n"
2691 );
2692 #elif defined(VGP_amd64_linux)
2693 asm("\n"
2694 ".text\n"
2695 "\t.globl _start\n"
2696 "\t.type _start,@function\n"
2697 "_start:\n"
2698 /* set up the new stack in %rdi */
2699 "\tmovq $vgPlain_interim_stack, %rdi\n"
2700 "\taddq $"VG_STRINGIFY(VG_STACK_GUARD_SZB)", %rdi\n"
2701 "\taddq $"VG_STRINGIFY(VG_STACK_ACTIVE_SZB)", %rdi\n"
2702 "\tandq $~15, %rdi\n"
2703 /* install it, and collect the original one */
2704 "\txchgq %rdi, %rsp\n"
2705 /* call _start_in_C_linux, passing it the startup %rsp */
2706 "\tcall _start_in_C_linux\n"
2707 "\thlt\n"
2708 ".previous\n"
2709 );
2710 #elif defined(VGP_ppc32_linux)
2711 asm("\n"
2712 ".text\n"
2713 "\t.globl _start\n"
2714 "\t.type _start,@function\n"
2715 "_start:\n"
2716 /* set up the new stack in r16 */
2717 "\tlis 16,vgPlain_interim_stack@ha\n"
2718 "\tla 16,vgPlain_interim_stack@l(16)\n"
2719 "\tlis 17,("VG_STRINGIFY(VG_STACK_GUARD_SZB)" >> 16)\n"
2720 "\tori 17,17,("VG_STRINGIFY(VG_STACK_GUARD_SZB)" & 0xFFFF)\n"
2721 "\tlis 18,("VG_STRINGIFY(VG_STACK_ACTIVE_SZB)" >> 16)\n"
2722 "\tori 18,18,("VG_STRINGIFY(VG_STACK_ACTIVE_SZB)" & 0xFFFF)\n"
2723 "\tadd 16,17,16\n"
2724 "\tadd 16,18,16\n"
2725 "\trlwinm 16,16,0,0,27\n"
2726 /* now r16 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2727 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2728 boundary. And r1 is the original SP. Set the SP to r16 and
2729 call _start_in_C_linux, passing it the initial SP. */
2730 "\tmr 3,1\n"
2731 "\tmr 1,16\n"
2732 "\tbl _start_in_C_linux\n"
2733 "\ttrap\n"
2734 ".previous\n"
2735 );
2736 #elif defined(VGP_ppc64_linux)
2737 asm("\n"
2738 /* PPC64 ELF ABI says '_start' points to a function descriptor.
2739 So we must have one, and that is what goes into the .opd section. */
2740 "\t.align 2\n"
2741 "\t.global _start\n"
2742 "\t.section \".opd\",\"aw\"\n"
2743 "\t.align 3\n"
2744 "_start:\n"
2745 "\t.quad ._start,.TOC.@tocbase,0\n"
2746 "\t.previous\n"
2747 "\t.type ._start,@function\n"
2748 "\t.global ._start\n"
2749 "._start:\n"
2750 /* set up the new stack in r16 */
2751 "\tlis 16, vgPlain_interim_stack@highest\n"
2752 "\tori 16,16,vgPlain_interim_stack@higher\n"
2753 "\tsldi 16,16,32\n"
2754 "\toris 16,16,vgPlain_interim_stack@h\n"
2755 "\tori 16,16,vgPlain_interim_stack@l\n"
2756 "\txor 17,17,17\n"
2757 "\tlis 17,("VG_STRINGIFY(VG_STACK_GUARD_SZB)" >> 16)\n"
2758 "\tori 17,17,("VG_STRINGIFY(VG_STACK_GUARD_SZB)" & 0xFFFF)\n"
2759 "\txor 18,18,18\n"
2760 "\tlis 18,("VG_STRINGIFY(VG_STACK_ACTIVE_SZB)" >> 16)\n"
2761 "\tori 18,18,("VG_STRINGIFY(VG_STACK_ACTIVE_SZB)" & 0xFFFF)\n"
2762 "\tadd 16,17,16\n"
2763 "\tadd 16,18,16\n"
2764 "\trldicr 16,16,0,59\n"
2765 /* now r16 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2766 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2767 boundary. And r1 is the original SP. Set the SP to r16 and
2768 call _start_in_C_linux, passing it the initial SP. */
2769 "\tmr 3,1\n"
2770 "\tmr 1,16\n"
2771 "\tbl ._start_in_C_linux\n"
2772 "\tnop\n"
2773 "\ttrap\n"
2774 );
2775 #elif defined(VGP_arm_linux)
2776 asm("\n"
2777 "\t.text\n"
2778 "\t.align 4\n"
2779 "\t.type _start,#function\n"
2780 "\t.global _start\n"
2781 "_start:\n"
2782 "\tldr r0, [pc, #36]\n"
2783 "\tldr r1, [pc, #36]\n"
2784 "\tadd r0, r1, r0\n"
2785 "\tldr r1, [pc, #32]\n"
2786 "\tadd r0, r1, r0\n"
2787 "\tmvn r1, #15\n"
2788 "\tand r0, r0, r1\n"
2789 "\tmov r1, sp\n"
2790 "\tmov sp, r0\n"
2791 "\tmov r0, r1\n"
2792 "\tb _start_in_C_linux\n"
2793 "\t.word vgPlain_interim_stack\n"
2794 "\t.word "VG_STRINGIFY(VG_STACK_GUARD_SZB)"\n"
2795 "\t.word "VG_STRINGIFY(VG_STACK_ACTIVE_SZB)"\n"
2796 );
2797 #else
2798 # error "Unknown linux platform"
2799 #endif
2800
2801 /* --- !!! --- EXTERNAL HEADERS start --- !!! --- */
2802 #define _GNU_SOURCE
2803 #define _FILE_OFFSET_BITS 64
2804 /* This is in order to get AT_NULL and AT_PAGESIZE. */
2805 #include <elf.h>
2806 /* --- !!! --- EXTERNAL HEADERS end --- !!! --- */
2807
2808 /* Avoid compiler warnings: this fn _is_ used, but labelling it
2809 'static' causes gcc to complain it isn't. */
2810 void _start_in_C_linux ( UWord* pArgc );
_start_in_C_linux(UWord * pArgc)2811 void _start_in_C_linux ( UWord* pArgc )
2812 {
2813 Int r;
2814 Word argc = pArgc[0];
2815 HChar** argv = (HChar**)&pArgc[1];
2816 HChar** envp = (HChar**)&pArgc[1+argc+1];
2817
2818 VG_(memset)( &the_iicii, 0, sizeof(the_iicii) );
2819 VG_(memset)( &the_iifii, 0, sizeof(the_iifii) );
2820
2821 the_iicii.sp_at_startup = (Addr)pArgc;
2822
2823 # if defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux)
2824 {
2825 /* ppc/ppc64 can be configured with different page sizes.
2826 Determine this early. This is an ugly hack and really should
2827 be moved into valgrind_main. */
2828 UWord *sp = &pArgc[1+argc+1];
2829 while (*sp++ != 0)
2830 ;
2831 for (; *sp != AT_NULL && *sp != AT_PAGESZ; sp += 2);
2832 if (*sp == AT_PAGESZ) {
2833 VKI_PAGE_SIZE = sp[1];
2834 for (VKI_PAGE_SHIFT = 12;
2835 VKI_PAGE_SHIFT <= VKI_MAX_PAGE_SHIFT; VKI_PAGE_SHIFT++)
2836 if (VKI_PAGE_SIZE == (1UL << VKI_PAGE_SHIFT))
2837 break;
2838 }
2839 }
2840 # endif
2841
2842 r = valgrind_main( (Int)argc, argv, envp );
2843 /* NOTREACHED */
2844 VG_(exit)(r);
2845 }
2846
2847
2848 /*====================================================================*/
2849 /*=== Getting to main() alive: AIX5 ===*/
2850 /*====================================================================*/
2851
2852 #elif defined(VGO_aix5)
2853
2854 /* This is somewhat simpler than the Linux case. _start_valgrind
2855 receives control from the magic piece of code created in this
2856 process' address space by the launcher, via use of ptrace(). At
2857 the point of entry:
2858
2859 - the initial client process image is in memory and ready to roll,
2860 except that we've partially trashed its integer register state
2861 in order to get this far. So ..
2862
2863 - intregs37 holds the client's initial integer register state, so
2864 we can restore it before starting the client on the VCPU.
2865
2866 - we're on the client's stack. This is not good; therefore the
2867 first order of business is to switch to our temporary stack.
2868
2869 - the client's initial argc/v/envp is in r3/r4/r5 (32 bit mode) or
2870 r14/r15/r16 (64 bit mode). They are pulled out of the stashed
2871 integer register state and passed to our main().
2872
2873 The launcher will have played some games with argv. If the launcher
2874 ($prefix/bin/valgrind) was started like this
2875
2876 valgrind [args-for-V] app [args-for-app]
2877
2878 then the launcher will have started the client as
2879
2880 app [args-for-V] app [args-for-app]
2881
2882 m_initimg will have to mess with the client's initial r4/r5
2883 (32-bit) or r15/r16 (64-bit) so that it believes it was execd as
2884 "app [args-for-app]". Well, that's no big deal.
2885 */
2886
2887 #include "launcher-aix5-bootblock.h"
2888
2889 void _start_in_C_aix5 ( AIX5Bootblock* bootblock );
_start_in_C_aix5(AIX5Bootblock * bootblock)2890 void _start_in_C_aix5 ( AIX5Bootblock* bootblock )
2891 {
2892 Int r;
2893 ULong* intregs37;
2894 UWord argc, argv, envp;
2895 __NR_getpid = bootblock->__NR_getpid;
2896 __NR_write = bootblock->__NR_write;
2897 __NR_exit = bootblock->__NR_exit;
2898 __NR_open = bootblock->__NR_open;
2899 __NR_read = bootblock->__NR_read;
2900 __NR_close = bootblock->__NR_close;
2901
2902 VG_(memset)( &the_iicii, 0, sizeof(the_iicii) );
2903 VG_(memset)( &the_iifii, 0, sizeof(the_iifii) );
2904
2905 intregs37 = &bootblock->iregs_pc_cr_lr_ctr_xer[0];
2906 the_iicii.intregs37 = intregs37;
2907 the_iicii.bootblock = (void*)bootblock;
2908 the_iicii.adler32_exp = bootblock->adler32;
2909
2910 /* Not important on AIX. */
2911 the_iicii.sp_at_startup = (Addr)0x31415927ULL;
2912
2913 # if defined(VGP_ppc32_aix5)
2914 argc = (UWord)intregs37[3]; /* client's r3 == argc */
2915 argv = (UWord)intregs37[4];
2916 envp = (UWord)intregs37[5];
2917 # else /* defined(VGP_ppc64_aix5) */
2918 argc = (UWord)intregs37[14]; /* client's r14 == argc */
2919 argv = (UWord)intregs37[15];
2920 envp = (UWord)intregs37[16];
2921 # endif
2922
2923 r = valgrind_main( (Int)argc, (HChar**)argv, (HChar**)envp );
2924
2925 /* NOTREACHED */
2926 VG_(exit)(r);
2927 }
2928
2929 /* THE ENTRY POINT */
2930 void _start_valgrind ( AIX5Bootblock* bootblock );
_start_valgrind(AIX5Bootblock * bootblock)2931 void _start_valgrind ( AIX5Bootblock* bootblock )
2932 {
2933 /* Switch immediately to our temporary stack, and continue. This
2934 is pretty dodgy in that it assumes that gcc does not place on
2935 the stack, anything needed to form the _start_in_C_aix5 call,
2936 since it will be on the old stack. */
2937 register UWord new_r1;
2938 new_r1 = (UWord)&VG_(interim_stack);
2939 new_r1 += VG_STACK_GUARD_SZB; /* step over lower guard page */
2940 new_r1 += VG_STACK_ACTIVE_SZB; /* step to top of active area */
2941 new_r1 -= 512; /* paranoia */
2942 __asm__ __volatile__("mr 1,%0" :/*wr*/
2943 :/*rd*/ "b"(new_r1)
2944 :/*trash*/"r1","memory");
2945 _start_in_C_aix5(bootblock);
2946 /*NOTREACHED*/
2947 VG_(exit)(0);
2948 }
2949
2950 /* At some point in Oct 2008, static linking appeared to stop working
2951 on AIX 5.3. This breaks the build since we link statically. The
2952 linking fails citing absence of the following five symbols as the
2953 reason. In the absence of a better solution, here are stand-ins
2954 for them. Kludge appears to work; presumably said functions,
2955 assuming they are indeed functions, are never called. */
encrypted_pw_passlen(void)2956 void encrypted_pw_passlen ( void ) { vg_assert(0); }
crypt_r(void)2957 void crypt_r ( void ) { vg_assert(0); }
max_history_size(void)2958 void max_history_size ( void ) { vg_assert(0); }
getpass_auto(void)2959 void getpass_auto ( void ) { vg_assert(0); }
max_pw_passlen(void)2960 void max_pw_passlen ( void ) { vg_assert(0); }
2961
2962
2963 /*====================================================================*/
2964 /*=== Getting to main() alive: darwin ===*/
2965 /*====================================================================*/
2966
2967 #elif defined(VGO_darwin)
2968
2969 /*
2970 Memory layout established by kernel:
2971
2972 0(%esp) argc
2973 4(%esp) argv[0]
2974 ...
2975 argv[argc-1]
2976 NULL
2977 envp[0]
2978 ...
2979 envp[n]
2980 NULL
2981 executable name (presumably, a pointer to it)
2982 NULL
2983
2984 Ditto in the 64-bit case, except all offsets from SP are obviously
2985 twice as large.
2986 */
2987
2988 /* The kernel hands control to _start, which extracts the initial
2989 stack pointer and calls onwards to _start_in_C_darwin. This also
2990 switches to the new stack. */
2991 #if defined(VGP_x86_darwin)
2992 asm("\n"
2993 ".text\n"
2994 ".align 2,0x90\n"
2995 "\t.globl __start\n"
2996 "__start:\n"
2997 /* set up the new stack in %eax */
2998 "\tmovl $_vgPlain_interim_stack, %eax\n"
2999 "\taddl $"VG_STRINGIFY(VG_STACK_GUARD_SZB)", %eax\n"
3000 "\taddl $"VG_STRINGIFY(VG_STACK_ACTIVE_SZB)", %eax\n"
3001 "\tsubl $16, %eax\n"
3002 "\tandl $~15, %eax\n"
3003 /* install it, and collect the original one */
3004 "\txchgl %eax, %esp\n"
3005 /* call _start_in_C_darwin, passing it the startup %esp */
3006 "\tpushl %eax\n"
3007 "\tcall __start_in_C_darwin\n"
3008 "\tint $3\n"
3009 "\tint $3\n"
3010 );
3011 #elif defined(VGP_amd64_darwin)
3012 asm("\n"
3013 ".text\n"
3014 "\t.globl __start\n"
3015 ".align 3,0x90\n"
3016 "__start:\n"
3017 /* set up the new stack in %rdi */
3018 "\tmovabsq $_vgPlain_interim_stack, %rdi\n"
3019 "\taddq $"VG_STRINGIFY(VG_STACK_GUARD_SZB)", %rdi\n"
3020 "\taddq $"VG_STRINGIFY(VG_STACK_ACTIVE_SZB)", %rdi\n"
3021 "\tandq $~15, %rdi\n"
3022 /* install it, and collect the original one */
3023 "\txchgq %rdi, %rsp\n"
3024 /* call _start_in_C_darwin, passing it the startup %rsp */
3025 "\tcall __start_in_C_darwin\n"
3026 "\tint $3\n"
3027 "\tint $3\n"
3028 );
3029 #endif
3030
3031 void* __memcpy_chk(void *dest, const void *src, SizeT n, SizeT n2);
__memcpy_chk(void * dest,const void * src,SizeT n,SizeT n2)3032 void* __memcpy_chk(void *dest, const void *src, SizeT n, SizeT n2) {
3033 // skip check
3034 return VG_(memcpy)(dest,src,n);
3035 }
3036 void* __memset_chk(void *s, int c, SizeT n, SizeT n2);
__memset_chk(void * s,int c,SizeT n,SizeT n2)3037 void* __memset_chk(void *s, int c, SizeT n, SizeT n2) {
3038 // skip check
3039 return VG_(memset)(s,c,n);
3040 }
3041 void bzero(void *s, SizeT n);
bzero(void * s,SizeT n)3042 void bzero(void *s, SizeT n) {
3043 VG_(memset)(s,0,n);
3044 }
3045
3046 void* memcpy(void *dest, const void *src, SizeT n);
memcpy(void * dest,const void * src,SizeT n)3047 void* memcpy(void *dest, const void *src, SizeT n) {
3048 return VG_(memcpy)(dest,src,n);
3049 }
3050 void* memset(void *s, int c, SizeT n);
memset(void * s,int c,SizeT n)3051 void* memset(void *s, int c, SizeT n) {
3052 return VG_(memset)(s,c,n);
3053 }
3054
3055 /* Avoid compiler warnings: this fn _is_ used, but labelling it
3056 'static' causes gcc to complain it isn't. */
3057 void _start_in_C_darwin ( UWord* pArgc );
_start_in_C_darwin(UWord * pArgc)3058 void _start_in_C_darwin ( UWord* pArgc )
3059 {
3060 Int r;
3061 Int argc = *(Int *)pArgc; // not pArgc[0] on LP64
3062 HChar** argv = (HChar**)&pArgc[1];
3063 HChar** envp = (HChar**)&pArgc[1+argc+1];
3064
3065 VG_(memset)( &the_iicii, 0, sizeof(the_iicii) );
3066 VG_(memset)( &the_iifii, 0, sizeof(the_iifii) );
3067
3068 the_iicii.sp_at_startup = (Addr)pArgc;
3069
3070 r = valgrind_main( (Int)argc, argv, envp );
3071 /* NOTREACHED */
3072 VG_(exit)(r);
3073 }
3074
3075
3076 #else
3077
3078 # error "Unknown OS"
3079 #endif
3080
3081
3082 /*====================================================================*/
3083 /*=== {u,}{div,mod}di3 replacements ===*/
3084 /*====================================================================*/
3085
3086 /* For static linking on x86-darwin, we need to supply our own 64-bit
3087 integer division code, else the link dies thusly:
3088
3089 ld_classic: Undefined symbols:
3090 ___udivdi3
3091 ___umoddi3
3092 */
3093 #if defined(VGP_x86_darwin)
3094
3095 /* Routines for doing signed/unsigned 64 x 64 ==> 64 div and mod
3096 (udivdi3, umoddi3, divdi3, moddi3) using only 32 x 32 ==> 32
3097 division. Cobbled together from
3098
3099 http://www.hackersdelight.org/HDcode/divlu.c
3100 http://www.hackersdelight.org/HDcode/divls.c
3101 http://www.hackersdelight.org/HDcode/newCode/divDouble.c
3102
3103 The code from those three files is covered by the following license,
3104 as it appears at:
3105
3106 http://www.hackersdelight.org/permissions.htm
3107
3108 You are free to use, copy, and distribute any of the code on
3109 this web site, whether modified by you or not. You need not give
3110 attribution. This includes the algorithms (some of which appear
3111 in Hacker's Delight), the Hacker's Assistant, and any code
3112 submitted by readers. Submitters implicitly agree to this.
3113 */
3114
3115 /* Long division, unsigned (64/32 ==> 32).
3116 This procedure performs unsigned "long division" i.e., division of a
3117 64-bit unsigned dividend by a 32-bit unsigned divisor, producing a
3118 32-bit quotient. In the overflow cases (divide by 0, or quotient
3119 exceeds 32 bits), it returns a remainder of 0xFFFFFFFF (an impossible
3120 value).
3121 The dividend is u1 and u0, with u1 being the most significant word.
3122 The divisor is parameter v. The value returned is the quotient.
3123 Max line length is 57, to fit in hacker.book. */
3124
nlz32(UInt x)3125 static Int nlz32(UInt x)
3126 {
3127 Int n;
3128 if (x == 0) return(32);
3129 n = 0;
3130 if (x <= 0x0000FFFF) {n = n +16; x = x <<16;}
3131 if (x <= 0x00FFFFFF) {n = n + 8; x = x << 8;}
3132 if (x <= 0x0FFFFFFF) {n = n + 4; x = x << 4;}
3133 if (x <= 0x3FFFFFFF) {n = n + 2; x = x << 2;}
3134 if (x <= 0x7FFFFFFF) {n = n + 1;}
3135 return n;
3136 }
3137
3138 /* 64 x 32 ==> 32 unsigned division, using only 32 x 32 ==> 32
3139 division as a primitive. */
divlu2(UInt u1,UInt u0,UInt v,UInt * r)3140 static UInt divlu2(UInt u1, UInt u0, UInt v, UInt *r)
3141 {
3142 const UInt b = 65536; // Number base (16 bits).
3143 UInt un1, un0, // Norm. dividend LSD's.
3144 vn1, vn0, // Norm. divisor digits.
3145 q1, q0, // Quotient digits.
3146 un32, un21, un10, // Dividend digit pairs.
3147 rhat; // A remainder.
3148 Int s; // Shift amount for norm.
3149
3150 if (u1 >= v) { // If overflow, set rem.
3151 if (r != NULL) // to an impossible value,
3152 *r = 0xFFFFFFFF; // and return the largest
3153 return 0xFFFFFFFF;} // possible quotient.
3154
3155 s = nlz32(v); // 0 <= s <= 31.
3156 v = v << s; // Normalize divisor.
3157 vn1 = v >> 16; // Break divisor up into
3158 vn0 = v & 0xFFFF; // two 16-bit digits.
3159
3160 un32 = (u1 << s) | ((u0 >> (32 - s)) & (-s >> 31));
3161 un10 = u0 << s; // Shift dividend left.
3162
3163 un1 = un10 >> 16; // Break right half of
3164 un0 = un10 & 0xFFFF; // dividend into two digits.
3165
3166 q1 = un32/vn1; // Compute the first
3167 rhat = un32 - q1*vn1; // quotient digit, q1.
3168 again1:
3169 if (q1 >= b || q1*vn0 > b*rhat + un1) {
3170 q1 = q1 - 1;
3171 rhat = rhat + vn1;
3172 if (rhat < b) goto again1;}
3173
3174 un21 = un32*b + un1 - q1*v; // Multiply and subtract.
3175
3176 q0 = un21/vn1; // Compute the second
3177 rhat = un21 - q0*vn1; // quotient digit, q0.
3178 again2:
3179 if (q0 >= b || q0*vn0 > b*rhat + un0) {
3180 q0 = q0 - 1;
3181 rhat = rhat + vn1;
3182 if (rhat < b) goto again2;}
3183
3184 if (r != NULL) // If remainder is wanted,
3185 *r = (un21*b + un0 - q0*v) >> s; // return it.
3186 return q1*b + q0;
3187 }
3188
3189
3190 /* 64 x 32 ==> 32 signed division, using only 32 x 32 ==> 32 division
3191 as a primitive. */
divls(Int u1,UInt u0,Int v,Int * r)3192 static Int divls(Int u1, UInt u0, Int v, Int *r)
3193 {
3194 Int q, uneg, vneg, diff, borrow;
3195
3196 uneg = u1 >> 31; // -1 if u < 0.
3197 if (uneg) { // Compute the absolute
3198 u0 = -u0; // value of the dividend u.
3199 borrow = (u0 != 0);
3200 u1 = -u1 - borrow;}
3201
3202 vneg = v >> 31; // -1 if v < 0.
3203 v = (v ^ vneg) - vneg; // Absolute value of v.
3204
3205 if ((UInt)u1 >= (UInt)v) goto overflow;
3206
3207 q = divlu2(u1, u0, v, (UInt *)r);
3208
3209 diff = uneg ^ vneg; // Negate q if signs of
3210 q = (q ^ diff) - diff; // u and v differed.
3211 if (uneg && r != NULL)
3212 *r = -*r;
3213
3214 if ((diff ^ q) < 0 && q != 0) { // If overflow,
3215 overflow: // set remainder
3216 if (r != NULL) // to an impossible value,
3217 *r = 0x80000000; // and return the largest
3218 q = 0x80000000;} // possible neg. quotient.
3219 return q;
3220 }
3221
3222
3223
3224 /* This file contains a program for doing 64/64 ==> 64 division, on a
3225 machine that does not have that instruction but that does have
3226 instructions for "long division" (64/32 ==> 32). Code for unsigned
3227 division is given first, followed by a simple program for doing the
3228 signed version by using the unsigned version.
3229 These programs are useful in implementing "long long" (64-bit)
3230 arithmetic on a machine that has the long division instruction. It will
3231 work on 64- and 32-bit machines, provided the compiler implements long
3232 long's (64-bit integers). It is desirable that the machine have the
3233 Count Leading Zeros instruction.
3234 In the GNU world, these programs are known as __divdi3 and __udivdi3,
3235 and similar names are used here.
3236 This material is not in HD, but may be in a future edition.
3237 Max line length is 57, to fit in hacker.book. */
3238
3239
nlz64(ULong x)3240 static Int nlz64(ULong x)
3241 {
3242 Int n;
3243 if (x == 0) return(64);
3244 n = 0;
3245 if (x <= 0x00000000FFFFFFFFULL) {n = n + 32; x = x << 32;}
3246 if (x <= 0x0000FFFFFFFFFFFFULL) {n = n + 16; x = x << 16;}
3247 if (x <= 0x00FFFFFFFFFFFFFFULL) {n = n + 8; x = x << 8;}
3248 if (x <= 0x0FFFFFFFFFFFFFFFULL) {n = n + 4; x = x << 4;}
3249 if (x <= 0x3FFFFFFFFFFFFFFFULL) {n = n + 2; x = x << 2;}
3250 if (x <= 0x7FFFFFFFFFFFFFFFULL) {n = n + 1;}
3251 return n;
3252 }
3253
3254 // ---------------------------- udivdi3 --------------------------------
3255
3256 /* The variables u0, u1, etc. take on only 32-bit values, but they
3257 are declared long long to avoid some compiler warning messages and to
3258 avoid some unnecessary EXTRs that the compiler would put in, to
3259 convert long longs to ints.
3260
3261 First the procedure takes care of the case in which the divisor is a
3262 32-bit quantity. There are two subcases: (1) If the left half of the
3263 dividend is less than the divisor, one execution of DIVU is all that
3264 is required (overflow is not possible). (2) Otherwise it does two
3265 divisions, using the grade school method, with variables used as
3266 suggested below.
3267
3268 q1 q0
3269 ________
3270 v) u1 u0
3271 q1*v
3272 ____
3273 k u0 */
3274
3275 /* These macros must be used with arguments of the appropriate type
3276 (unsigned long long for DIVU and long long for DIVS. They are
3277 simulations of the presumed machines ops. I.e., they look at only the
3278 low-order 32 bits of the divisor, they return garbage if the division
3279 overflows, and they return garbage in the high-order half of the
3280 quotient doubleword.
3281 In practice, these would be replaced with uses of the machine's DIVU
3282 and DIVS instructions (e.g., by using the GNU "asm" facility). */
3283
DIVU(ULong u,UInt v)3284 static UInt DIVU ( ULong u, UInt v )
3285 {
3286 UInt uHi = (UInt)(u >> 32);
3287 UInt uLo = (UInt)u;
3288 return divlu2(uHi, uLo, v, NULL);
3289 }
3290
DIVS(Long u,Int v)3291 static Int DIVS ( Long u, Int v )
3292 {
3293 Int uHi = (Int)(u >> 32);
3294 UInt uLo = (UInt)u;
3295 return divls(uHi, uLo, v, NULL);
3296 }
3297
3298 /* 64 x 64 ==> 64 unsigned division, using only 32 x 32 ==> 32
3299 division as a primitive. */
udivdi3(ULong u,ULong v)3300 static ULong udivdi3(ULong u, ULong v)
3301 {
3302 ULong u0, u1, v1, q0, q1, k, n;
3303
3304 if (v >> 32 == 0) { // If v < 2**32:
3305 if (u >> 32 < v) // If u/v cannot overflow,
3306 return DIVU(u, v) // just do one division.
3307 & 0xFFFFFFFF;
3308 else { // If u/v would overflow:
3309 u1 = u >> 32; // Break u up into two
3310 u0 = u & 0xFFFFFFFF; // halves.
3311 q1 = DIVU(u1, v) // First quotient digit.
3312 & 0xFFFFFFFF;
3313 k = u1 - q1*v; // First remainder, < v.
3314 q0 = DIVU((k << 32) + u0, v) // 2nd quot. digit.
3315 & 0xFFFFFFFF;
3316 return (q1 << 32) + q0;
3317 }
3318 }
3319 // Here v >= 2**32.
3320 n = nlz64(v); // 0 <= n <= 31.
3321 v1 = (v << n) >> 32; // Normalize the divisor
3322 // so its MSB is 1.
3323 u1 = u >> 1; // To ensure no overflow.
3324 q1 = DIVU(u1, v1) // Get quotient from
3325 & 0xFFFFFFFF; // divide unsigned insn.
3326 q0 = (q1 << n) >> 31; // Undo normalization and
3327 // division of u by 2.
3328 if (q0 != 0) // Make q0 correct or
3329 q0 = q0 - 1; // too small by 1.
3330 if ((u - q0*v) >= v)
3331 q0 = q0 + 1; // Now q0 is correct.
3332 return q0;
3333 }
3334
3335
3336 // ----------------------------- divdi3 --------------------------------
3337
3338 /* This routine presumes that smallish cases (those which can be done in
3339 one execution of DIVS) are common. If this is not the case, the test for
3340 this case should be deleted.
3341 Note that the test for when DIVS can be used is not entirely
3342 accurate. For example, DIVS is not used if v = 0xFFFFFFFF8000000,
3343 whereas if could be (if u is sufficiently small in magnitude). */
3344
3345 // ------------------------------ cut ----------------------------------
3346
my_llabs(Long x)3347 static ULong my_llabs ( Long x )
3348 {
3349 ULong t = x >> 63;
3350 return (x ^ t) - t;
3351 }
3352
3353 /* 64 x 64 ==> 64 signed division, using only 32 x 32 ==> 32 division
3354 as a primitive. */
divdi3(Long u,Long v)3355 static Long divdi3(Long u, Long v)
3356 {
3357 ULong au, av;
3358 Long q, t;
3359 au = my_llabs(u);
3360 av = my_llabs(v);
3361 if (av >> 31 == 0) { // If |v| < 2**31 and
3362 // if (v << 32 >> 32 == v) { // If v is in range and
3363 if (au < av << 31) { // |u|/|v| cannot
3364 q = DIVS(u, v); // overflow, use DIVS.
3365 return (q << 32) >> 32;
3366 }
3367 }
3368 q = udivdi3(au,av); // Invoke udivdi3.
3369 t = (u ^ v) >> 63; // If u, v have different
3370 return (q ^ t) - t; // signs, negate q.
3371 }
3372
3373 // ---------------------------- end cut --------------------------------
3374
3375 ULong __udivdi3 (ULong u, ULong v);
__udivdi3(ULong u,ULong v)3376 ULong __udivdi3 (ULong u, ULong v)
3377 {
3378 return udivdi3(u,v);
3379 }
3380
3381 Long __divdi3 (Long u, Long v);
__divdi3(Long u,Long v)3382 Long __divdi3 (Long u, Long v)
3383 {
3384 return divdi3(u,v);
3385 }
3386
3387 ULong __umoddi3 (ULong u, ULong v);
__umoddi3(ULong u,ULong v)3388 ULong __umoddi3 (ULong u, ULong v)
3389 {
3390 ULong q = __udivdi3(u, v);
3391 ULong r = u - q * v;
3392 return r;
3393 }
3394
3395 Long __moddi3 (Long u, Long v);
__moddi3(Long u,Long v)3396 Long __moddi3 (Long u, Long v)
3397 {
3398 Long q = __divdi3(u, v);
3399 Long r = u - q * v;
3400 return r;
3401 }
3402
3403 #endif
3404
3405
3406 /*--------------------------------------------------------------------*/
3407 /*--- end ---*/
3408 /*--------------------------------------------------------------------*/
3409