| blob | d0093f1c31dc794b13f099a81f560a83b8e2f769 |
2 /*--------------------------------------------------------------------*/
3 /*--- Startup: the real stuff m_main.c ---*/
4 /*--------------------------------------------------------------------*/
6 /*
7 This file is part of Valgrind, a dynamic binary instrumentation
8 framework.
10 Copyright (C) 2000-2013 Julian Seward
11 jseward@acm.org
13 This program is free software; you can redistribute it and/or
14 modify it under the terms of the GNU General Public License as
15 published by the Free Software Foundation; either version 2 of the
16 License, or (at your option) any later version.
18 This program is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26 02111-1307, USA.
28 The GNU General Public License is contained in the file COPYING.
29 */
70 #if defined(ENABLE_INNER_CLIENT_REQUEST)
72 #endif
75 /*====================================================================*/
76 /*=== Command-line: variables, processing, etc ===*/
77 /*====================================================================*/
79 // See pub_{core,tool}_options.h for explanations of all these.
82 {
83 /* 'usage1' contains a %s
84 - for the name of the GDB executable
85 - for the name of vgdb's path prefix
86 which must be supplied when they are VG_(printf)'d. */
181 " --kernel-variant=variant1,variant2,... handle non-standard kernel"
282 // Ensure the message goes to stdout
292 }
293 /* 'usage1' a type as described after each arg. */
301 N_SECTORS_DEFAULT /* int */
302 );
307 else
309 }
318 else
320 }
321 }
323 VG_BUGS_TO);
325 }
328 /* Peer at previously set up VG_(args_for_valgrind) and do some
329 minimal command line processing that must happen early on:
331 - show the version string, if requested (-v)
332 - extract any request for help (--help, -h, --help-debug)
333 - get the toolname (--tool=)
334 - set VG_(clo_max_stackframe) (--max-stackframe=)
335 - set VG_(clo_main_stacksize) (--main-stacksize=)
336 - set VG_(clo_sim_hints) (--sim-hints=)
338 That's all it does. The main command line processing is done below
339 by main_process_cmd_line_options. Note that
340 main_process_cmd_line_options has to handle but ignore the ones we
341 have handled here.
342 */
345 {
346 UInt i;
351 /* parse the options we have (only the options we care about now) */
357 // Nb: the version string goes to stdout.
362 }
368 // The tool has already been determined, but we need to know the name
369 // here.
372 // Set up VG_(clo_max_stackframe) and VG_(clo_main_stacksize).
373 // These are needed by VG_(ii_create_image), which happens
374 // before main_process_cmd_line_options().
378 // Set up VG_(clo_sim_hints). This is needed a.o. for an inner
379 // running in an outer, to have "no-inner-prefix" enabled
380 // as early as possible.
382 "no-inner-prefix,fuse-compatible,"
383 "lax-ioctls,enable-outer,"
386 }
387 }
389 /* The main processing for command line options. See comments above
390 on early_process_cmd_line_options.
392 Comments on how the logging options are handled:
394 User can specify:
395 --log-fd= for a fd to write to (default setting, fd = 2)
396 --log-file= for a file name to write to
397 --log-socket= for a socket to write to
399 As a result of examining these and doing relevant socket/file
400 opening, a final fd is established. This is stored in
401 VG_(log_output_sink) in m_libcprint. Also, if --log-file=STR was
402 specified, then STR, after expansion of %p and %q templates within
403 it, is stored in VG_(clo_log_fname_expanded), in m_options, just in
404 case anybody wants to know what it is.
406 When printing, VG_(log_output_sink) is consulted to find the
407 fd to send output to.
409 Exactly analogous actions are undertaken for the XML output
410 channel, with the one difference that the default fd is -1, meaning
411 the channel is disabled by default.
412 */
413 static
417 {
418 // VG_(clo_log_fd) is used by all the messaging. It starts as 2 (stderr)
419 // and we cannot change it until we know what we are changing it to is
420 // ok. So we have tmp_log_fd to hold the tmp fd prior to that point.
421 SysRes sres;
426 VgLogTo_Fd,
427 VgLogTo_File,
428 VgLogTo_Socket
432 /* Temporarily holds the string STR specified with
433 --{log,xml}-{name,socket}=STR. 'fs' stands for
434 file-or-socket. */
438 /* Whether the user has explicitly provided --sigill-diagnostics.
439 If not explicitly given depends on general verbosity setting. */
442 /* Log to stderr by default, but usage message goes to stdout. XML
443 output is initially disabled. */
447 /* Check for sane path in ./configure --prefix=... */
454 /* BEGIN command-line processing loop */
461 // Look for a colon in the option name.
463 colon++;
465 // Does it have the form "--toolname:foo"? We have to do it at the start
466 // in case someone has combined a prefix with a core-specific option,
467 // eg. "--memcheck:verbose".
472 {
473 // Prefix matches, convert "--toolname:foo" to "--foo".
474 // Two things to note:
475 // - We cannot modify the option in-place. If we did, and then
476 // a child was spawned with --trace-children=yes, the
477 // now-non-prefixed option would be passed and could screw up
478 // the child.
479 // - We create copies, and never free them. Why? Non-prefixed
480 // options hang around forever, so tools need not make copies
481 // of strings within them. We need to have the same behaviour
482 // for prefixed options. The pointer to the copy will be lost
483 // once we leave this function (although a tool may keep a
484 // pointer into it), but the space wasted is insignificant.
485 // (In bug #142197, the copies were being freed, which caused
486 // problems for tools that reasonably assumed that arguments
487 // wouldn't disappear on them.)
495 // prefix doesn't match, skip to next arg
497 }
498 }
500 /* Ignore these options - they've already been handled */
513 /* Obsolete options. Report an error and exit */
519 }
526 }
528 // These options are new.
547 /* automatically updates register values at each insn
548 with --vgdb=full */
551 }
559 }
583 else
586 }
593 True) {}
595 True) {}
611 VG_DEEPEST_BACKTRACE) {}
617 VG_DEEPEST_BACKTRACE) {}
620 Vg_SmcNone);
622 Vg_SmcStack);
624 Vg_SmcAll);
627 Vg_SmcAllNonFile);
646 VexRegUpdSpAtMemAccess);
650 VexRegUpdUnwindregsAtMemAccess);
654 VexRegUpdAllregsAtMemAccess);
658 VexRegUpdAllregsAtEachInsn);
671 }
675 }
679 }
682 }
686 }
689 }
708 }
711 }
718 }
721 }
731 }
732 /* String needs to be of the form C?*C?*, where C is any
733 character, but is the same both times. Having it in this
734 form facilitates finding the boundary between the sopatt
735 and the fnpatt just by looking for the second occurrence
736 of C, without hardwiring any assumption about what C
737 is. */
747 }
751 }
754 }
756 /* "stuvwxyz" --> stuvwxyz (binary) */
758 Int j;
762 }
769 }
770 }
771 }
777 /* "stuvwxyz" --> stuvwxyz (binary) */
779 Int j;
783 }
790 }
791 }
793 }
813 }
814 }
816 /* END command-line processing loop */
818 /* Determine the path prefix for vgdb */
822 /* Make VEX control parameters sane */
832 /* Check various option values */
842 /* [] */
846 /* [0 .. notabove] */
848 }
851 /* [notbelow .. ] */
854 /* [notbelow .. notabove] */
855 }
856 }
865 }
867 /* If XML output is requested, check that the tool actually
868 supports it. */
873 /*NOTREACHED*/
874 }
879 /* If we've been asked to emit XML, mash around various other
880 options so as to constrain the output somewhat, and to remove
881 any need for user input during the run.
882 */
885 /* We can't allow --gen-suppressions=yes, since that requires us
886 to print the error and then ask the user if she wants a
887 suppression for it, but in XML mode we won't print it until
888 we know whether we also need to print a suppression. Hence a
889 circular dependency. So disallow this.
890 (--gen-suppressions=all is still OK since we don't need any
891 user interaction in this case.) */
896 "or --gen-suppressions=all is allowed, but not "
898 }
900 /* We can't allow DB attaching (or we maybe could, but results
901 could be chaotic ..) since it requires user input. Hence
902 disallow. */
908 }
910 /* Disallow dump_error in XML mode; sounds like a recipe for
911 chaos. No big deal; dump_error is a flag for debugging V
912 itself. */
915 }
917 /* Disable error limits (this might be a bad idea!) */
919 /* Disable emulation warnings */
921 /* Also, we want to set options for the leak checker, but that
922 will have to be done in Memcheck's flag-handling code, not
923 here. */
924 }
926 /* All non-logging-related options have been checked. If the logging
927 option specified is ok, we can switch to it, as we know we won't
928 have to generate any other command-line-related error messages.
929 (So far we should be still attached to stderr, so we can show on
930 the terminal any problems to do with processing command line
931 opts.)
933 So set up logging now. After this is done, VG_(log_output_sink)
934 and (if relevant) VG_(xml_output_sink) should be connected to
935 whatever sink has been selected, and we indiscriminately chuck
936 stuff into it without worrying what the nature of it is. Oh the
937 wonder of Unix streams. */
947 /* --- set up the normal text output channel --- */
961 // Nb: we overwrite an existing file of this name without asking
962 // any questions.
964 log_fsname_unexpanded);
975 /*NOTREACHED*/
976 }
978 }
986 log_fsname_unexpanded);
988 /*NOTREACHED*/
989 }
993 log_fsname_unexpanded );
995 /* We don't change anything here. */
1001 }
1003 }
1004 }
1006 /* --- set up the XML output channel --- */
1020 // Nb: we overwrite an existing file of this name without asking
1021 // any questions.
1023 xml_fsname_unexpanded);
1030 /* strdup here is probably paranoid overkill, but ... */
1032 xml_fsname_unexpanded );
1037 /*NOTREACHED*/
1038 }
1040 }
1048 xml_fsname_unexpanded );
1050 /*NOTREACHED*/
1051 }
1055 xml_fsname_unexpanded);
1056 /* We don't change anything here. */
1062 }
1064 }
1065 }
1067 /* If we've got this far, and XML mode was requested, but no XML
1068 output channel appears to have been specified, just stop. We
1069 could continue, and XML output will simply vanish into nowhere,
1070 but that is likely to confuse the hell out of users, which is
1071 distinctly Ungood. */
1078 );
1079 }
1081 // Finalise the output fds: the log fd ..
1084 // Move log_fd into the safe range, so it doesn't conflict with
1085 // any app fds.
1095 }
1097 // If they said --log-fd=-1, don't print anything. Plausible for use in
1098 // regression testing suites that use client requests to count errors.
1101 }
1103 // Finalise the output fds: and the XML fd ..
1106 // Move xml_fd into the safe range, so it doesn't conflict with
1107 // any app fds.
1117 }
1119 // If they said --xml-fd=-1, don't print anything. Plausible for use in
1120 // regression testing suites that use client requests to count errors.
1123 }
1125 // Suppressions related stuff
1130 /* If we haven't reached the max number of suppressions, load
1131 the default one. */
1138 }
1141 }
1143 // Write the name and value of log file qualifiers to the xml file.
1145 {
1150 // We saw a '%'. What's next...
1151 i++;
1153 i++;
1155 // Get the env var name, print its contents.
1158 i++;
1162 // Temporarily replace the '}' with NUL to extract var
1163 // name.
1167 }
1168 i++;
1169 }
1172 "<logfilequalifier> <var>%pS</var> "
1174 qualname,qual
1175 );
1177 i++;
1178 }
1179 }
1181 i++;
1182 }
1183 }
1184 }
1187 /*====================================================================*/
1188 /*=== Printing the preamble ===*/
1189 /*====================================================================*/
1191 // Print the argument, escaping any chars that require it.
1193 {
1196 Int i;
1200 }
1202 }
1203 }
1205 // Send output to the XML-stream and escape any XML meta-characters.
1207 {
1209 }
1211 /* Ok, the logging sink is running now. Print a suitable preamble.
1212 If logging to file or a socket, write details of parent PID and
1213 command line args, to help people trying to interpret the
1214 results of a run which encompasses multiple processes. */
1218 {
1219 Int i;
1240 }
1247 /* Tool details */
1249 xpre,
1255 xpost );
1260 xpre, xpost
1261 );
1262 }
1267 /* Core details */
1271 );
1273 // Print the command line. At one point we wrapped at 80 chars and
1274 // printed a '\' as a line joiner, but that makes it hard to cut and
1275 // paste the command line (because of the "==pid==" prefixes), so we now
1276 // favour utility and simplicity over aesthetics.
1284 }
1289 }
1291 // Print the parent PID, and other stuff, if necessary.
1294 }
1295 else
1304 /* Note: the user comment itself is XML and is therefore to
1305 be passed through verbatim (%s) rather than escaped
1306 (%pS). */
1309 }
1317 else
1324 );
1325 }
1335 );
1336 }
1340 }
1342 // Last thing in the preamble is a blank line.
1349 SysRes fd;
1350 VexArch vex_arch;
1351 VexArchInfo vex_archinfo;
1359 }
1366 # define BUF_LEN 256
1375 }
1377 # undef BUF_LEN
1378 }
1382 Vg_DebugMsg,
1387 );
1389 Vg_DebugMsg,
1392 );
1395 }
1396 }
1399 /*====================================================================*/
1400 /*=== File descriptor setup ===*/
1401 /*====================================================================*/
1403 /* Number of file descriptors that Valgrind tries to reserve for
1404 it's own use - just a small constant. */
1405 #define N_RESERVED_FDS (10)
1408 {
1412 /* Get the current file descriptor limits. */
1416 }
1418 # if defined(VGO_darwin)
1419 /* Darwin lies. It reports file max as RLIM_INFINITY but
1420 silently disallows anything bigger than 10240. */
1423 }
1424 # endif
1430 /* Work out where to move the soft limit to. */
1435 }
1437 /* Reserve some file descriptors for our use. */
1441 /* Update the soft limit. */
1449 }
1453 }
1456 /*====================================================================*/
1457 /*=== main() ===*/
1458 /*====================================================================*/
1460 /* When main() is entered, we should be on the following stack, not
1461 the one the kernel gave us. We will run on this stack until
1462 simulation of the root thread is started, at which point a transfer
1463 is made to a dynamically allocated stack. This is for the sake of
1464 uniform overflow detection for all Valgrind threads. This is
1465 marked global even though it isn't, because assembly code below
1466 needs to reference the name. */
1470 /* These are the structures used to hold info for creating the initial
1471 client image.
1473 'iicii' mostly holds important register state present at system
1474 startup (_start_valgrind). valgrind_main() then fills in the rest
1475 of it and passes it to VG_(ii_create_image)(). That produces
1476 'iifii', which is later handed to VG_(ii_finalise_image). */
1478 /* In all OS-instantiations, the_iicii has a field .sp_at_startup.
1479 This should get some address inside the stack on which we gained
1480 control (eg, it could be the SP at startup). It doesn't matter
1481 exactly where in the stack it is. This value is passed to the
1482 address space manager at startup. On Linux, aspacem then uses it
1483 to identify the initial stack segment and hence the upper end of
1484 the usable address space. */
1490 /* A simple pair structure, used for conveying debuginfo handles to
1491 calls to VG_TRACK(new_mem_startup, ...). */
1495 /* --- Forwards decls to do with shutdown --- */
1499 /* Do everything which needs doing when the last thread exits */
1500 static
1502 VgSchedReturnCode tids_schedretcode );
1504 /* --- end of Forwards decls to do with shutdown --- */
1507 /* By the time we get to valgrind_main, the_iicii should already have
1508 been filled in with any important details as required by whatever
1509 OS we have been built for.
1510 */
1511 static
1513 {
1523 //============================================================
1524 //
1525 // Nb: startup is complex. Prerequisites are shown at every step.
1526 // *** Be very careful when messing with the order ***
1527 //
1528 // The first order of business is to get debug logging, the address
1529 // space manager and the dynamic memory manager up and running.
1530 // Once that's done, we can relax a bit.
1531 //
1532 //============================================================
1534 /* This is needed to make VG_(getenv) usable early. */
1537 //--------------------------------------------------------------
1538 // Start up Mach kernel interface, if any
1539 // p: none
1540 //--------------------------------------------------------------
1541 # if defined(VGO_darwin)
1543 # endif
1545 //--------------------------------------------------------------
1546 // Start up the logging mechanism
1547 // p: none
1548 //--------------------------------------------------------------
1549 /* Start the debugging-log system ASAP. First find out how many
1550 "-d"s were specified. This is a pre-scan of the command line. Also
1551 get --profile-heap=yes, --core-redzone-size, --redzone-size
1552 --aspace-minaddr which are needed by the time we start up dynamic
1553 memory management. */
1566 # if VG_WORDSIZE == 4
1568 # else
1570 # endif
1579 "Must be a page aligned address between "
1581 }
1582 }
1584 /* ... and start the debug logger. Now we can safely emit logging
1585 messages all through startup. */
1590 //--------------------------------------------------------------
1591 // Ensure we're on a plausible stack.
1592 // p: logging
1593 //--------------------------------------------------------------
1599 /* Re "volatile": Apple clang version 4.0
1600 (tags/Apple/clang-421.0.57) (based on LLVM 3.1svn)" appeared
1601 to miscompile the following check, causing run to abort at
1602 this point (in 64-bit mode) even though aLocal is within limLo
1603 .. limHi. But in fact clang is within its rights to do
1604 strange things here. "The reason is that the comparisons
1605 aLocal < limLo and aLocal >= limHi cause undefined behaviour
1606 (according to c99 6.5.8) because they compare pointers that do
1607 not point into the same aggregate." Adding "volatile" appears
1608 to fix it because "The compiler would have to prove that there
1609 is undefined behavior in order to exploit it. But as a
1610 volatile variable can change its value in ways invisible to
1611 the compiler, the compiler must make the conservative
1612 assumption that it points into the same aggregate as the other
1613 pointer its compared against. I.e. the behaviour is possibly
1614 defined." (Analysis by Florian Krohm). */
1616 /* something's wrong. Stop. */
1623 }
1624 }
1626 //--------------------------------------------------------------
1627 // Ensure we have a plausible pointer to the stack on which
1628 // we gained control (not the current stack!)
1629 // p: logging
1630 //--------------------------------------------------------------
1637 }
1639 //--------------------------------------------------------------
1640 // Start up the address space manager, and determine the
1641 // approximate location of the client's stack
1642 // p: logging, plausible-stack
1643 //--------------------------------------------------------------
1655 //--------------------------------------------------------------
1656 // Start up the dynamic memory manager
1657 // p: address space management
1658 // p: getting --profile-heap,--core-redzone-size,--redzone-size
1659 // In fact m_mallocfree is self-initialising, so there's no
1660 // initialisation call to do. Instead, try a simple malloc/
1661 // free pair right now to check that nothing is broken.
1662 //--------------------------------------------------------------
1666 }
1669 //============================================================
1670 //
1671 // Dynamic memory management is now available.
1672 //
1673 //============================================================
1675 //--------------------------------------------------------------
1676 // Initialise m_debuginfo
1677 // p: dynamic memory allocation
1681 //--------------------------------------------------------------
1682 // Look for alternative libdir
1687 }
1689 //--------------------------------------------------------------
1690 // Extract the launcher name from the environment.
1697 }
1700 //--------------------------------------------------------------
1701 // Get the current process datasize rlimit, and set it to zero.
1702 // This prevents any internal uses of brk() from having any effect.
1703 // We remember the old value so we can restore it on exec, so that
1704 // child processes will have a reasonable brk value.
1709 // Get the current process stack rlimit.
1712 //--------------------------------------------------------------
1713 // Figure out what sort of CPU we're on, and whether it is
1714 // able to run V.
1717 VexArchInfo vex_archinfo;
1731 }
1737 );
1738 }
1740 //--------------------------------------------------------------
1741 // Record the working directory at startup
1742 // p: none
1748 }
1754 }
1756 //============================================================
1757 // Command line argument handling order:
1758 // * If --help/--help-debug are present, show usage message
1759 // (including the tool-specific usage)
1760 // * (If no --tool option given, default to Memcheck)
1761 // * Then, if client is missing, abort with error msg
1762 // * Then, if any cmdline args are bad, abort with error msg
1763 //============================================================
1765 //--------------------------------------------------------------
1766 // Split up argv into: C args, V args, V extra args, and exename.
1767 // p: dynamic memory allocation
1768 //--------------------------------------------------------------
1778 );
1784 );
1785 }
1787 //--------------------------------------------------------------
1788 // Extract tool name and whether help has been requested.
1789 // Note we can't print the help message yet, even if requested,
1790 // because the tool has not been initialised.
1791 // p: split_up_argv [for VG_(args_for_valgrind)]
1792 //--------------------------------------------------------------
1797 // Set default vex control params
1800 //--------------------------------------------------------------
1801 // Load client executable, finding in $PATH if necessary
1802 // p: early_process_cmd_line_options() [for 'exec', 'need_help',
1803 // clo_max_stackframe,
1804 // clo_main_stacksize]
1805 // p: layout_remaining_space [so there's space]
1806 //
1807 // Set up client's environment
1808 // p: set-libdir [for VG_(libdir)]
1809 // p: early_process_cmd_line_options [for toolname]
1810 //
1811 // Setup client stack, eip, and VG_(client_arg[cv])
1812 // p: load_client() [for 'info']
1813 // p: fix_environment() [for 'env']
1814 //
1815 // Setup client data (brk) segment. Initially a 1-page segment
1816 // which abuts a shrinkable reservation.
1817 // p: load_client() [for 'info' and hence VG_(brk_base)]
1818 //
1819 // p: _start_in_C (for zeroing out the_iicii and putting some
1820 // initial values into it)
1821 //--------------------------------------------------------------
1825 # if defined(VGO_linux) || defined(VGO_darwin)
1829 # else
1831 # endif
1833 /* NOTE: this call reads VG_(clo_main_stacksize). */
1835 }
1837 //==============================================================
1838 //
1839 // Finished loading/setting up the client address space.
1840 //
1841 //==============================================================
1843 //--------------------------------------------------------------
1844 // setup file descriptors
1845 // p: n/a
1846 //--------------------------------------------------------------
1850 //--------------------------------------------------------------
1851 // create fake /proc/<pid>/cmdline and /proc/<pid>/auxv files
1852 // and then unlink them, but hold onto the fds, so we can handr
1853 // them out to the client when it tries to open
1854 // /proc/<pid>/cmdline or /proc/<pid>/auxv for itself.
1855 // p: setup file descriptors
1856 // p: ii_create_image for VG_(client_auxv) setup.
1857 //--------------------------------------------------------------
1858 #if !defined(VGO_linux)
1859 // client shouldn't be using /proc!
1862 #else
1885 }
1887 /* Don't bother to seek the file back to the start; instead do
1888 it every time a copy of it is given out (by PRE(sys_open)).
1889 That is probably more robust across fork() etc. */
1891 /* Now delete it, but hang on to the fd. */
1908 client_auxv++;
1909 client_auxv++;
1911 }
1916 /* Don't bother to seek the file back to the start; instead do
1917 it every time a copy of it is given out (by PRE(sys_open)).
1918 That is probably more robust across fork() etc. */
1920 /* Now delete it, but hang on to the fd. */
1926 }
1927 #endif
1929 //--------------------------------------------------------------
1930 // Init tool part 1: pre_clo_init
1931 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
1932 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
1933 //--------------------------------------------------------------
1936 // Activate var info readers, if the tool asked for it:
1940 //--------------------------------------------------------------
1941 // If --tool and --help/--help-debug was given, now give the core+tool
1942 // help message
1943 // p: early_process_cmd_line_options() [for 'need_help']
1944 // p: tl_pre_clo_init [for 'VG_(tdict).usage']
1945 //--------------------------------------------------------------
1949 }
1951 //--------------------------------------------------------------
1952 // Process command line options to Valgrind + tool
1953 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
1954 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
1955 //--------------------------------------------------------------
1957 "(main_) Process Valgrind's command line options, "
1960 toolname );
1962 //--------------------------------------------------------------
1963 // Zeroise the millisecond counter by doing a first read of it.
1964 // p: none
1965 //--------------------------------------------------------------
1968 //--------------------------------------------------------------
1969 // Print the preamble
1970 // p: tl_pre_clo_init [for 'VG_(details).name' and friends]
1971 // p: main_process_cmd_line_options()
1972 // [for VG_(clo_verbosity), VG_(clo_xml),
1973 // logging_to_fd, xml_fname_unexpanded]
1974 //--------------------------------------------------------------
1979 //--------------------------------------------------------------
1980 // Init tool part 2: post_clo_init
1981 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
1982 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
1983 // p: print_preamble() [so any warnings printed in post_clo_init
1984 // are shown after the preamble]
1985 //--------------------------------------------------------------
1988 {
1989 /* The tool's "needs" will by now be finalised, since it has no
1990 further opportunity to specify them. So now sanity check
1991 them. */
1993 Bool ok;
1997 }
1998 }
2000 //--------------------------------------------------------------
2001 // Initialise translation table and translation cache
2002 // p: aspacem [??]
2003 // p: tl_pre_clo_init [for 'VG_(details).avg_translation_sizeB']
2004 //--------------------------------------------------------------
2008 //--------------------------------------------------------------
2009 // Initialise the redirect table.
2010 // p: init_tt_tc [so it can call VG_(search_transtab) safely]
2011 // p: aspacem [so can change ownership of sysinfo pages]
2012 //--------------------------------------------------------------
2016 //--------------------------------------------------------------
2017 // Allow GDB attach
2018 // p: main_process_cmd_line_options() [for VG_(clo_wait_for_gdb)]
2019 //--------------------------------------------------------------
2020 /* Hook to delay things long enough so we can get the pid and
2021 attach GDB in another shell. */
2027 # if defined(VGP_x86_linux)
2029 # elif defined(VGP_amd64_linux) || defined(VGP_ppc64be_linux) \
2030 || defined(VGP_ppc64le_linux)
2032 # elif defined(VGP_ppc32_linux)
2034 # elif defined(VGP_arm_linux)
2036 # elif defined(VGP_arm64_linux)
2038 # elif defined(VGP_s390x_linux)
2040 # elif defined(VGP_mips32_linux) || defined(VGP_mips64_linux)
2042 # elif defined(VGO_darwin)
2044 # else
2046 # endif
2051 }
2053 //--------------------------------------------------------------
2054 // Search for file descriptors that are inherited from our parent
2055 // p: main_process_cmd_line_options [for VG_(clo_track_fds)]
2056 //--------------------------------------------------------------
2060 }
2062 //--------------------------------------------------------------
2063 // Load debug info for the existing segments.
2064 // p: setup_code_redirect_table [so that redirs can be recorded]
2065 // p: mallocfree
2066 // p: probably: setup fds and process CLOs, so that logging works
2067 // p: initialise m_debuginfo
2068 //
2069 // While doing this, make a note of the debuginfo-handles that
2070 // come back from VG_(di_notify_mmap).
2071 // Later, in "Tell the tool about the initial client memory permissions"
2072 // (just below) we can then hand these handles off to the tool in
2073 // calls to VG_TRACK(new_mem_startup, ...). This gives the tool the
2074 // opportunity to make further queries to m_debuginfo before the
2075 // client is started, if it wants. We put this information into an
2076 // XArray, each handle along with the associated segment start address,
2077 // and search the XArray for the handles later, when calling
2078 // VG_TRACK(new_mem_startup, ...).
2079 //--------------------------------------------------------------
2087 # if defined(VGO_linux)
2089 Int n_seg_starts;
2090 Addr_n_ULong anu;
2095 /* show them all to the debug info reader. allow_SkFileV has to
2096 be True here so that we read info from the valgrind executable
2097 itself. */
2101 /* anu.ull holds the debuginfo handle returned by di_notify_mmap,
2102 if any. */
2106 }
2107 }
2110 }
2111 # elif defined(VGO_darwin)
2113 Int n_seg_starts;
2117 /* show them all to the debug info reader.
2118 Don't read from V segments (unlike Linux) */
2119 // GrP fixme really?
2123 }
2126 }
2127 # else
2128 # error Unknown OS
2129 # endif
2131 //--------------------------------------------------------------
2132 // Tell aspacem of ownership change of the asm helpers, so that
2133 // m_translate allows them to be translated. However, only do this
2134 // after the initial debug info read, since making a hole in the
2135 // address range for the stage2 binary confuses the debug info reader.
2136 // p: aspacem
2137 //--------------------------------------------------------------
2145 change_ownership_v_c_OK
2148 }
2157 buf );
2159 }
2163 //--------------------------------------------------------------
2164 // Initialise the scheduler (phase 1) [generates tid_main]
2165 // p: none, afaics
2166 //--------------------------------------------------------------
2171 /* Tell the tool about tid_main */
2174 //--------------------------------------------------------------
2175 // Tell the tool about the initial client memory permissions
2176 // p: aspacem
2177 // p: mallocfree
2178 // p: setup_client_stack
2179 // p: setup_client_dataseg
2180 //
2181 // For each segment we tell the client about, look up in
2182 // addr2dihandle as created above, to see if there's a debuginfo
2183 // handle associated with the segment, that we can hand along
2184 // to the tool, to be helpful.
2185 //--------------------------------------------------------------
2188 Int n_seg_starts;
2192 /* Mark the main thread as running while we tell the tool about
2193 the client memory so that the tool can associate that memory
2194 with the main thread. */
2201 /* show interesting ones to the tool */
2208 /* This next assertion is tricky. If it is placed
2209 immediately before this 'if', it very occasionally fails.
2210 Why? Because previous iterations of the loop may have
2211 caused tools (via the new_mem_startup calls) to do
2212 dynamic memory allocation, and that may affect the mapped
2213 segments; in particular it may cause segment merging to
2214 happen. Hence we cannot assume that seg_starts[i], which
2215 reflects the state of the world before we started this
2216 loop, is the same as seg->start, as the latter reflects
2217 the state of the world (viz, mappings) at this particular
2218 iteration of the loop.
2220 Why does moving it inside the 'if' make it safe? Because
2221 any dynamic memory allocation done by the tools will
2222 affect only the state of Valgrind-owned segments, not of
2223 Client-owned segments. And the 'if' guards against that
2224 -- we only get in here for Client-owned segments.
2226 In other words: the loop may change the state of
2227 Valgrind-owned segments as it proceeds. But it should
2228 not cause the Client-owned segments to change. */
2236 /* search addr2dihandle to see if we have an entry
2237 matching seg->start. */
2244 }
2245 }
2249 /* and the retrieved debuginfo handle, if any */
2250 j < n
2253 }
2254 }
2259 /* Also do the initial stack permissions. */
2260 {
2261 SSizeT inaccessible_len;
2269 /* Stuff below the initial SP is unaddressable. Take into
2270 account any ABI-mandated space below the stack pointer that
2271 is required (VG_STACK_REDZONE_SZB). setup_client_stack()
2272 will have allocated an extra page if a red zone is required,
2273 to be on the safe side. */
2280 inaccessible_len );
2284 }
2286 /* Also the assembly helpers. */
2296 /* Clear the running thread indicator */
2300 /* Darwin only: tell the tools where the client's kernel commpage
2301 is. It would be better to do this by telling aspacemgr about
2302 it -- see the now disused record_system_memory() in
2303 initimg-darwin.c -- but that causes the sync checker to fail,
2304 since the mapping doesn't appear in the kernel-supplied
2305 process map. So do it here instead. */
2306 # if defined(VGP_amd64_darwin)
2311 # elif defined(VGP_x86_darwin)
2316 # endif
2317 }
2319 //--------------------------------------------------------------
2320 // Initialise the scheduler (phase 2)
2321 // p: Initialise the scheduler (phase 1) [for tid_main]
2322 // p: setup_file_descriptors() [else VG_(safe_fd)() breaks]
2323 // p: setup_client_stack
2324 //--------------------------------------------------------------
2334 }
2336 //--------------------------------------------------------------
2337 // Set up state for the root thread
2338 // p: ?
2339 // setup_scheduler() [for sched-specific thread 1 stuff]
2340 // VG_(ii_create_image) [for 'the_iicii' initial info]
2341 //--------------------------------------------------------------
2345 //--------------------------------------------------------------
2346 // Initialise the signal handling subsystem
2347 // p: n/a
2348 //--------------------------------------------------------------
2349 // Nb: temporarily parks the saved blocking-mask in saved_sigmask.
2351 /* Check that the kernel-interface signal definitions look sane */
2353 /* .. and go on to use them. */
2356 //--------------------------------------------------------------
2357 // Read suppression file
2358 // p: main_process_cmd_line_options() [for VG_(clo_suppressions)]
2359 //--------------------------------------------------------------
2363 }
2365 //--------------------------------------------------------------
2366 // register client stack
2367 //--------------------------------------------------------------
2370 //--------------------------------------------------------------
2371 // Show the address space state so far
2372 //--------------------------------------------------------------
2379 //--------------------------------------------------------------
2380 // Run!
2381 //--------------------------------------------------------------
2384 /* As a result of the following call, the last thread standing
2385 eventually winds up running shutdown_actions_NORETURN
2386 just below. Unfortunately, simply exporting said function
2387 causes m_main to be part of a module cycle, which is pretty
2388 nonsensical. So instead of doing that, the address of said
2389 function is stored in a global variable 'owned' by m_syswrap,
2390 and it uses that function pointer to get back here when it needs
2391 to. */
2393 /* Set continuation address. */
2397 /* Run the first thread, eventually ending up at the continuation
2398 address. */
2401 /*NOTREACHED*/
2403 }
2405 /* Do everything which needs doing when the last thread exits or when
2406 a thread exits requesting a complete process exit.
2408 We enter here holding The Lock. For the case VgSrc_ExitProcess we
2409 must never release it, because to do so would allow other threads
2410 to continue after the system is ostensibly shut down. So we must
2411 go to our grave, so to speak, holding the lock.
2413 In fact, there is never any point in releasing the lock at this
2414 point - we have it, we're shutting down the entire system, and
2415 for the case VgSrc_ExitProcess doing so positively causes trouble.
2416 So don't.
2418 The final_tidyup call makes a bit of a nonsense of the ExitProcess
2419 case, since it will run the libc_freeres function, thus allowing
2420 other lurking threads to run again. Hmm. */
2422 static
2424 VgSchedReturnCode tids_schedretcode )
2425 {
2437 // We are the last surviving thread. Right?
2440 // Wait for all other threads to exit.
2441 // jrs: Huh? but they surely are already gone
2444 // Clean the client up before the final report
2445 // this causes the libc_freeres function to run
2448 /* be paranoid */
2454 // We may not be the last surviving thread. However, we
2455 // want to shut down the entire process. We hold the lock
2456 // and we need to keep hold of it all the way out, in order
2457 // that none of the other threads ever run again.
2460 // Clean the client up before the final report
2461 // this causes the libc_freeres function to run
2462 // perhaps this is unsafe, as per comment above
2465 /* be paranoid */
2468 }
2470 /* Final call to gdbserver, if requested. */
2474 }
2477 //--------------------------------------------------------------
2478 // Finalisation: cleanup, messages, etc. Order not so important, only
2479 // affects what order the messages come.
2480 //--------------------------------------------------------------
2481 // First thing in the post-amble is a blank line.
2495 buf);
2496 }
2498 /* Print out file descriptor summary and stats. */
2502 /* Call the tool's finalisation function. This makes Memcheck's
2503 leak checker run, and possibly chuck a bunch of leak errors into
2504 the error management machinery. */
2507 /* Show the error counts. */
2511 }
2513 /* In XML mode, this merely prints the used suppressions. */
2521 }
2529 /* Show a profile of the heap(s) at shutdown. Optionally, first
2530 throw away all the debug info, as that makes it easy to spot
2531 leaks in the debuginfo reader. */
2535 }
2537 /* If profiling has been requested, but with zero interval, it
2538 means "profile at the end of the run only". In which case we
2539 need to dump the profile now. */
2542 }
2544 /* Print Vex storage stats */
2548 /* Flush any output cached by previous calls to VG_(message). */
2551 /* Terminate gdbserver if ever it was started. We terminate it here
2552 so that it get the output above if output was redirected to
2553 gdb */
2556 /* Ok, finally exit in the os-specific way, according to the scheduler's
2557 return code. In short, if the (last) thread exited by calling
2558 sys_exit, do likewise; if the (last) thread stopped due to a fatal
2559 signal, terminate the entire system with that same fatal signal. */
2566 /* Change the application return code to user's return code,
2567 if an error was found */
2572 /* otherwise, return the client's exit code, in the normal
2573 way. */
2575 }
2576 /* NOT ALIVE HERE! */
2581 /* We were killed by a fatal signal, so replicate the effect */
2584 /* we shouldn't be alive at this point. But VG_(kill_self)
2585 sometimes fails with EPERM on Darwin, for unclear reasons. */
2586 # if defined(VGO_darwin)
2589 /* fall through .. */
2590 # endif
2596 }
2597 }
2599 /* -------------------- */
2601 /* Final clean-up before terminating the process.
2602 Clean up the client by calling __libc_freeres() (if requested)
2603 This is Linux-specific?
2604 GrP fixme glibc-specific, anyway
2605 */
2607 {
2608 #if !defined(VGO_darwin)
2609 # if defined(VGP_ppc64be_linux)
2610 Addr r2;
2611 # endif
2621 # if defined(VGP_ppc64be_linux)
2629 }
2630 # endif
2638 /* set thread context to point to libc_freeres_wrapper */
2639 /* ppc64be-linux note: __libc_freeres_wrapper gives us the real
2640 function entry point, not a fn descriptor, so can use it
2641 directly. However, we need to set R2 (the toc pointer)
2642 appropriately. */
2644 # if defined(VGP_ppc64be_linux)
2646 # elif defined(VGP_ppc64le_linux)
2647 /* setting GPR2 but not really needed, GPR12 is needed */
2650 # endif
2651 /* mips-linux note: we need to set t9 */
2652 # if defined(VGP_mips32_linux) || defined(VGP_mips64_linux)
2654 # endif
2656 /* Block all blockable signals by copying the real block state into
2657 the thread's block state*/
2661 /* and restore handlers to default */
2667 // We were exiting, so assert that...
2669 // ...but now we're not again
2672 // run until client thread exits - ideally with LIBC_FREERES_DONE,
2673 // but exit/exitgroup/signal will do
2677 #endif
2678 }
2681 /*====================================================================*/
2682 /*=== Getting to main() alive: LINUX ===*/
2683 /*====================================================================*/
2685 #if defined(VGO_linux)
2687 /* If linking of the final executables is done with glibc present,
2688 then Valgrind starts at main() above as usual, and all of the
2689 following code is irrelevant.
2691 However, this is not the intended mode of use. The plan is to
2692 avoid linking against glibc, by giving gcc the flags
2693 -nodefaultlibs -lgcc -nostartfiles at startup.
2695 From this derive two requirements:
2697 1. gcc may emit calls to memcpy, memmove and memset to deal with
2698 structure assignments etc. Since we have chosen to ignore all the
2699 "normal" supporting libraries, we have to provide our own
2700 implementations of them. No problem.
2702 2. We have to provide a symbol "_start", to which the kernel
2703 hands control at startup. Hence the code below.
2704 */
2706 /* ---------------- Requirement 1 ---------------- */
2711 }
2715 }
2719 }
2721 /* BVA: abort() for those platforms that need it (PPC and ARM). */
2726 }
2728 /* EAZG: ARM's EABI will call floating point exception handlers in
2729 libgcc which boil down to an abort or raise, that's usually defined
2730 in libc. Instead, define them here. */
2731 #if defined(VGP_arm_linux)
2736 }
2742 }
2748 }
2749 #endif
2751 /* ---------------- Requirement 2 ---------------- */
2753 /* Glibc's sysdeps/i386/elf/start.S has the following gem of a
2754 comment, which explains how the stack looks right at process start
2755 (when _start is jumped to). Hence _start passes %esp to
2756 _start_in_C_linux, which extracts argc/argv/envp and starts up
2757 correctly. */
2759 /* This is the canonical entry point, usually the first thing in the text
2760 segment. The SVR4/i386 ABI (pages 3-31, 3-32) says that when the entry
2761 point runs, most registers' values are unspecified, except for:
2763 %edx Contains a function pointer to be registered with `atexit'.
2764 This is how the dynamic linker arranges to have DT_FINI
2765 functions called for shared libraries that have been loaded
2766 before this code runs.
2768 %esp The stack contains the arguments and environment:
2769 0(%esp) argc
2770 4(%esp) argv[0]
2771 ...
2772 (4*argc)(%esp) NULL
2773 (4*(argc+1))(%esp) envp[0]
2774 ...
2775 NULL
2776 */
2778 /* The kernel hands control to _start, which extracts the initial
2779 stack pointer and calls onwards to _start_in_C_linux. This also switches
2780 the new stack. */
2781 #if defined(VGP_x86_linux)
2787 /* set up the new stack in %eax */
2793 /* install it, and collect the original one */
2795 /* call _start_in_C_linux, passing it the startup %esp */
2800 );
2801 #elif defined(VGP_amd64_linux)
2807 /* set up the new stack in %rdi */
2812 /* install it, and collect the original one */
2814 /* call _start_in_C_linux, passing it the startup %rsp */
2818 );
2819 #elif defined(VGP_ppc32_linux)
2825 /* set up the new stack in r16 */
2835 /* now r16 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2836 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2837 boundary. And r1 is the original SP. Set the SP to r16 and
2838 call _start_in_C_linux, passing it the initial SP. */
2844 );
2845 #elif defined(VGP_ppc64be_linux)
2847 /* PPC64 ELF ABI says '_start' points to a function descriptor.
2848 So we must have one, and that is what goes into the .opd section. */
2859 /* set up the new stack in r16 */
2874 /* now r16 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2875 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2876 boundary. And r1 is the original SP. Set the SP to r16 and
2877 call _start_in_C_linux, passing it the initial SP. */
2890 );
2891 #elif defined(VGP_ppc64le_linux)
2892 /* Little Endian uses ELF version 2 but in the future may also
2893 * support other ELF versions.
2894 */
2905 /* set up the new stack in r16 */
2920 /* now r16 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2921 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2922 boundary. And r1 is the original SP. Set the SP to r16 and
2923 call _start_in_C_linux, passing it the initial SP. */
2935 );
2936 #elif defined(VGP_s390x_linux)
2937 /*
2938 This is the canonical entry point, usually the first thing in the text
2939 segment. Most registers' values are unspecified, except for:
2941 %r14 Contains a function pointer to be registered with `atexit'.
2942 This is how the dynamic linker arranges to have DT_FINI
2943 functions called for shared libraries that have been loaded
2944 before this code runs.
2946 %r15 The stack contains the arguments and environment:
2947 0(%r15) argc
2948 8(%r15) argv[0]
2949 ...
2950 (8*argc)(%r15) NULL
2951 (8*(argc+1))(%r15) envp[0]
2952 ...
2953 NULL
2954 */
2960 /* set up the new stack in %r1 */
2966 /* install it, and collect the original one */
2969 /* call _start_in_C_linux, passing it the startup %r15 */
2971 /* trigger execution of an invalid opcode -> halt machine */
2976 );
2977 #elif defined(VGP_arm_linux)
2998 );
2999 #elif defined(VGP_arm64_linux)
3008 // The next 2 assume that VG_STACK_GUARD_SZB fits in 32 bits
3013 // The next 2 assume that VG_STACK_ACTIVE_SZB fits in 32 bits
3023 );
3024 #elif defined(VGP_mips32_linux)
3040 /* t1/$9 <- Addr(interim_stack) */
3042 /* t1/$9 <- Addr(interim_stack) */
3053 /* now t1/$9 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
3054 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
3055 boundary. And $29 is the original SP. Set the SP to t1 and
3056 call _start_in_C, passing it the initial SP. */
3067 );
3068 #elif defined(VGP_mips64_linux)
3079 /* t1/$9 <- Addr(interim_stack) */
3089 /* now t1/$9 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
3090 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
3091 boundary. And $29 is the original SP. Set the SP to t1 and
3092 call _start_in_C, passing it the initial SP. */
3106 );
3107 #else
3109 #endif
3111 /* --- !!! --- EXTERNAL HEADERS start --- !!! --- */
3112 #define _GNU_SOURCE
3113 #define _FILE_OFFSET_BITS 64
3114 /* This is in order to get AT_NULL and AT_PAGESIZE. */
3115 #include <elf.h>
3116 /* --- !!! --- EXTERNAL HEADERS end --- !!! --- */
3118 /* Avoid compiler warnings: this fn _is_ used, but labelling it
3119 'static' causes gcc to complain it isn't.
3120 attribute 'used' also ensures the code is not eliminated at link
3121 time */
3126 {
3127 Int r;
3132 // For an inner Valgrind, register the interim stack asap.
3133 // This is needed to allow the outer valgrind to do stacktraces during init.
3134 // Note that this stack is not unregistered when the main thread
3135 // is switching to the (real) stack. Unregistering this would imply
3136 // to save the stack id in a global variable, and have a "if"
3137 // in run_a_thread_NORETURN to do the unregistration only for the
3138 // main thread. This unregistration is not worth this complexity.
3139 INNER_REQUEST
3149 # if defined(VGP_ppc32_linux) || defined(VGP_ppc64be_linux) \
3150 || defined(VGP_ppc64le_linux) || defined(VGP_arm64_linux)
3151 {
3152 /* ppc32/ppc64 can be configured with different page sizes.
3153 Determine this early. This is an ugly hack and really should
3154 be moved into valgrind_main. */
3157 ;
3165 }
3166 }
3167 # endif
3170 /* NOTREACHED */
3172 }
3175 /*====================================================================*/
3176 /*=== Getting to main() alive: darwin ===*/
3177 /*====================================================================*/
3179 #elif defined(VGO_darwin)
3181 /*
3182 Memory layout established by kernel:
3184 0(%esp) argc
3185 4(%esp) argv[0]
3186 ...
3187 argv[argc-1]
3188 NULL
3189 envp[0]
3190 ...
3191 envp[n]
3192 NULL
3193 executable name (presumably, a pointer to it)
3194 NULL
3196 Ditto in the 64-bit case, except all offsets from SP are obviously
3197 twice as large.
3198 */
3200 /* The kernel hands control to _start, which extracts the initial
3201 stack pointer and calls onwards to _start_in_C_darwin. This also
3202 switches to the new stack. */
3203 #if defined(VGP_x86_darwin)
3209 /* set up the new stack in %eax */
3215 /* install it, and collect the original one */
3218 /* call _start_in_C_darwin, passing it the startup %esp */
3223 );
3224 #elif defined(VGP_amd64_darwin)
3230 /* set up the new stack in %rdi */
3235 /* install it, and collect the original one */
3237 /* call _start_in_C_darwin, passing it the startup %rsp */
3241 );
3242 #endif
3246 // skip check
3248 }
3251 // skip check
3253 }
3257 }
3262 }
3266 }
3268 /* Avoid compiler warnings: this fn _is_ used, but labelling it
3269 'static' causes gcc to complain it isn't. */
3272 {
3273 Int r;
3278 // See _start_in_C_linux
3279 INNER_REQUEST
3290 /* NOTREACHED */
3292 }
3295 #else
3298 #endif
3301 /*====================================================================*/
3302 /*=== {u,}{div,mod}di3 replacements ===*/
3303 /*====================================================================*/
3305 /* For static linking on x86-darwin, we need to supply our own 64-bit
3306 integer division code, else the link dies thusly:
3308 ld_classic: Undefined symbols:
3309 ___udivdi3
3310 ___umoddi3
3311 */
3312 #if defined(VGP_x86_darwin)
3314 /* Routines for doing signed/unsigned 64 x 64 ==> 64 div and mod
3315 (udivdi3, umoddi3, divdi3, moddi3) using only 32 x 32 ==> 32
3316 division. Cobbled together from
3318 http://www.hackersdelight.org/HDcode/divlu.c
3319 http://www.hackersdelight.org/HDcode/divls.c
3320 http://www.hackersdelight.org/HDcode/newCode/divDouble.c
3322 The code from those three files is covered by the following license,
3323 as it appears at:
3325 http://www.hackersdelight.org/permissions.htm
3327 You are free to use, copy, and distribute any of the code on
3328 this web site, whether modified by you or not. You need not give
3329 attribution. This includes the algorithms (some of which appear
3330 in Hacker's Delight), the Hacker's Assistant, and any code
3331 submitted by readers. Submitters implicitly agree to this.
3332 */
3334 /* Long division, unsigned (64/32 ==> 32).
3335 This procedure performs unsigned "long division" i.e., division of a
3336 64-bit unsigned dividend by a 32-bit unsigned divisor, producing a
3337 32-bit quotient. In the overflow cases (divide by 0, or quotient
3338 exceeds 32 bits), it returns a remainder of 0xFFFFFFFF (an impossible
3339 value).
3340 The dividend is u1 and u0, with u1 being the most significant word.
3341 The divisor is parameter v. The value returned is the quotient.
3342 Max line length is 57, to fit in hacker.book. */
3345 {
3346 Int n;
3355 }
3357 /* 64 x 32 ==> 32 unsigned division, using only 32 x 32 ==> 32
3358 division as a primitive. */
3360 {
3387 again1:
3397 again2:
3406 }
3409 /* 64 x 32 ==> 32 signed division, using only 32 x 32 ==> 32 division
3410 as a primitive. */
3412 {
3439 }
3443 /* This file contains a program for doing 64/64 ==> 64 division, on a
3444 machine that does not have that instruction but that does have
3445 instructions for "long division" (64/32 ==> 32). Code for unsigned
3446 division is given first, followed by a simple program for doing the
3447 signed version by using the unsigned version.
3448 These programs are useful in implementing "long long" (64-bit)
3449 arithmetic on a machine that has the long division instruction. It will
3450 work on 64- and 32-bit machines, provided the compiler implements long
3451 long's (64-bit integers). It is desirable that the machine have the
3452 Count Leading Zeros instruction.
3453 In the GNU world, these programs are known as __divdi3 and __udivdi3,
3454 and similar names are used here.
3455 This material is not in HD, but may be in a future edition.
3456 Max line length is 57, to fit in hacker.book. */
3460 {
3461 Int n;
3471 }
3473 // ---------------------------- udivdi3 --------------------------------
3475 /* The variables u0, u1, etc. take on only 32-bit values, but they
3476 are declared long long to avoid some compiler warning messages and to
3477 avoid some unnecessary EXTRs that the compiler would put in, to
3478 convert long longs to ints.
3480 First the procedure takes care of the case in which the divisor is a
3481 32-bit quantity. There are two subcases: (1) If the left half of the
3482 dividend is less than the divisor, one execution of DIVU is all that
3483 is required (overflow is not possible). (2) Otherwise it does two
3484 divisions, using the grade school method, with variables used as
3485 suggested below.
3487 q1 q0
3488 ________
3489 v) u1 u0
3490 q1*v
3491 ____
3492 k u0 */
3494 /* These macros must be used with arguments of the appropriate type
3495 (unsigned long long for DIVU and long long for DIVS. They are
3496 simulations of the presumed machines ops. I.e., they look at only the
3497 low-order 32 bits of the divisor, they return garbage if the division
3498 overflows, and they return garbage in the high-order half of the
3499 quotient doubleword.
3500 In practice, these would be replaced with uses of the machine's DIVU
3501 and DIVS instructions (e.g., by using the GNU "asm" facility). */
3504 {
3508 }
3511 {
3515 }
3517 /* 64 x 64 ==> 64 unsigned division, using only 32 x 32 ==> 32
3518 division as a primitive. */
3520 {
3536 }
3537 }
3538 // Here v >= 2**32.
3541 // so its MSB is 1.
3546 // division of u by 2.
3552 }
3555 // ----------------------------- divdi3 --------------------------------
3557 /* This routine presumes that smallish cases (those which can be done in
3558 one execution of DIVS) are common. If this is not the case, the test for
3559 this case should be deleted.
3560 Note that the test for when DIVS can be used is not entirely
3561 accurate. For example, DIVS is not used if v = 0xFFFFFFFF8000000,
3562 whereas if could be (if u is sufficiently small in magnitude). */
3564 // ------------------------------ cut ----------------------------------
3567 {
3570 }
3572 /* 64 x 64 ==> 64 signed division, using only 32 x 32 ==> 32 division
3573 as a primitive. */
3575 {
3581 // if (v << 32 >> 32 == v) { // If v is in range and
3585 }
3586 }
3590 }
3592 // ---------------------------- end cut --------------------------------
3596 {
3598 }
3602 {
3604 }
3608 {
3612 }
3616 {
3620 }
3622 /* ------------------------------------------------
3623 ld_classic: Undefined symbols:
3624 ___fixunsdfdi
3625 ------------------------------------------------
3626 */
3628 /* ===-- fixunsdfdi.c - Implement __fixunsdfdi -----------------------------===
3629 *
3630 * The LLVM Compiler Infrastructure
3631 *
3632 * This file is dual licensed under the MIT and the University of Illinois Open
3633 * Source Licenses. See LICENSE.TXT for details.
3634 *
3635 * ===----------------------------------------------------------------------===
3636 *
3637 * This file implements __fixunsdfdi for the compiler_rt library.
3638 *
3639 * ===----------------------------------------------------------------------===
3640 */
3642 /* As per http://www.gnu.org/licenses/license-list.html#GPLCompatibleLicenses,
3644 the "NCSA/University of Illinois Open Source License" is compatible
3645 with the GPL (both version 2 and 3). What is claimed to be
3646 compatible is this
3648 http://www.opensource.org/licenses/UoI-NCSA.php
3650 and the LLVM documentation at
3652 http://www.llvm.org/docs/DeveloperPolicy.html#license
3654 says all the code in LLVM is available under the University of
3655 Illinois/NCSA Open Source License, at this URL
3657 http://www.opensource.org/licenses/UoI-NCSA.php
3659 viz, the same one that the FSF pages claim is compatible. So I
3660 think it's OK to include it.
3661 */
3663 /* Returns: convert a to a unsigned long long, rounding toward zero.
3664 * Negative values all become zero.
3665 */
3667 /* Assumption: double is a IEEE 64 bit floating point type
3668 * du_int is a 64 bit integral type
3669 * value in double is representable in du_int or is negative
3670 * (no range checking performed)
3671 */
3673 /* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
3679 {
3680 du_int all;
3681 struct
3682 {
3683 #if VG_LITTLEENDIAN
3684 su_int low;
3685 su_int high;
3686 #else
3687 su_int high;
3688 su_int low;
3694 {
3695 udwords u;
3701 du_int
3703 {
3704 double_bits fb;
3709 udwords r;
3714 else
3717 }
3720 #endif
3723 /*--------------------------------------------------------------------*/
3724 /*--- end ---*/
3725 /*--------------------------------------------------------------------*/