| blob | 2a0b2a67785a75afbeb10b5c8dbcf74bb4aa3c15 |
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. */
293 // Ensure the message goes to stdout
303 }
304 /* 'usage1' a type as described after each arg. */
312 N_SECTORS_DEFAULT /* int */
313 );
318 else
320 }
329 else
331 }
332 }
334 VG_BUGS_TO);
336 }
339 /* Peer at previously set up VG_(args_for_valgrind) and do some
340 minimal command line processing that must happen early on:
342 - show the version string, if requested (-v)
343 - extract any request for help (--help, -h, --help-debug)
344 - get the toolname (--tool=)
345 - set VG_(clo_max_stackframe) (--max-stackframe=)
346 - set VG_(clo_main_stacksize) (--main-stacksize=)
347 - set VG_(clo_sim_hints) (--sim-hints=)
349 That's all it does. The main command line processing is done below
350 by main_process_cmd_line_options. Note that
351 main_process_cmd_line_options has to handle but ignore the ones we
352 have handled here.
353 */
356 {
357 UInt i;
362 /* parse the options we have (only the options we care about now) */
368 // Nb: the version string goes to stdout.
373 }
379 // The tool has already been determined, but we need to know the name
380 // here.
383 // Set up VG_(clo_max_stackframe) and VG_(clo_main_stacksize).
384 // These are needed by VG_(ii_create_image), which happens
385 // before main_process_cmd_line_options().
389 // Set up VG_(clo_sim_hints). This is needed a.o. for an inner
390 // running in an outer, to have "no-inner-prefix" enabled
391 // as early as possible.
393 "lax-ioctls,fuse-compatible,"
394 "enable-outer,no-inner-prefix,"
397 }
398 }
400 /* The main processing for command line options. See comments above
401 on early_process_cmd_line_options.
403 Comments on how the logging options are handled:
405 User can specify:
406 --log-fd= for a fd to write to (default setting, fd = 2)
407 --log-file= for a file name to write to
408 --log-socket= for a socket to write to
410 As a result of examining these and doing relevant socket/file
411 opening, a final fd is established. This is stored in
412 VG_(log_output_sink) in m_libcprint. Also, if --log-file=STR was
413 specified, then STR, after expansion of %p and %q templates within
414 it, is stored in VG_(clo_log_fname_expanded), in m_options, just in
415 case anybody wants to know what it is.
417 When printing, VG_(log_output_sink) is consulted to find the
418 fd to send output to.
420 Exactly analogous actions are undertaken for the XML output
421 channel, with the one difference that the default fd is -1, meaning
422 the channel is disabled by default.
423 */
424 static
428 {
429 // VG_(clo_log_fd) is used by all the messaging. It starts as 2 (stderr)
430 // and we cannot change it until we know what we are changing it to is
431 // ok. So we have tmp_log_fd to hold the tmp fd prior to that point.
432 SysRes sres;
437 VgLogTo_Fd,
438 VgLogTo_File,
439 VgLogTo_Socket
443 /* Temporarily holds the string STR specified with
444 --{log,xml}-{name,socket}=STR. 'fs' stands for
445 file-or-socket. */
449 /* Whether the user has explicitly provided --sigill-diagnostics.
450 If not explicitly given depends on general verbosity setting. */
453 /* Log to stderr by default, but usage message goes to stdout. XML
454 output is initially disabled. */
458 /* Check for sane path in ./configure --prefix=... */
472 /* BEGIN command-line processing loop */
479 // Look for a colon in the option name.
481 colon++;
483 // Does it have the form "--toolname:foo"? We have to do it at the start
484 // in case someone has combined a prefix with a core-specific option,
485 // eg. "--memcheck:verbose".
490 {
491 // Prefix matches, convert "--toolname:foo" to "--foo".
492 // Two things to note:
493 // - We cannot modify the option in-place. If we did, and then
494 // a child was spawned with --trace-children=yes, the
495 // now-non-prefixed option would be passed and could screw up
496 // the child.
497 // - We create copies, and never free them. Why? Non-prefixed
498 // options hang around forever, so tools need not make copies
499 // of strings within them. We need to have the same behaviour
500 // for prefixed options. The pointer to the copy will be lost
501 // once we leave this function (although a tool may keep a
502 // pointer into it), but the space wasted is insignificant.
503 // (In bug #142197, the copies were being freed, which caused
504 // problems for tools that reasonably assumed that arguments
505 // wouldn't disappear on them.)
513 // prefix doesn't match, skip to next arg
515 }
516 }
518 /* Ignore these options - they've already been handled */
531 /* Obsolete options. Report an error and exit */
537 }
544 }
546 // These options are new.
565 /* automatically updates register values at each insn
566 with --vgdb=full */
569 }
577 }
586 Int m;
592 m++) {
593 /* Release previous value if clo given multiple times. */
606 }
608 }
609 }
626 else
629 }
636 True) {}
638 True) {}
654 VG_DEEPEST_BACKTRACE) {}
660 VG_DEEPEST_BACKTRACE) {}
663 Vg_SmcNone);
665 Vg_SmcStack);
667 Vg_SmcAll);
670 Vg_SmcAllNonFile);
673 "bproc,"
674 "android-no-hw-tls,"
675 "android-gpu-sgx5xx,"
693 VexRegUpdSpAtMemAccess);
697 VexRegUpdUnwindregsAtMemAccess);
701 VexRegUpdAllregsAtMemAccess);
705 VexRegUpdAllregsAtEachInsn);
718 }
722 }
726 }
729 }
733 }
736 }
752 }
756 }
762 /* String needs to be of the form C?*C?*, where C is any
763 character, but is the same both times. Having it in this
764 form facilitates finding the boundary between the sopatt
765 and the fnpatt just by looking for the second occurrence
766 of C, without hardwiring any assumption about what C
767 is. */
777 }
781 }
783 }
785 /* "stuvwxyz" --> stuvwxyz (binary) */
787 Int j;
791 }
798 }
799 }
800 }
806 /* "stuvwxyz" --> stuvwxyz (binary) */
808 Int j;
812 }
819 }
820 }
822 }
849 }
850 }
852 /* END command-line processing loop */
854 /* Notify about deprecated features */
860 /* Determine the path prefix for vgdb */
864 /* Make VEX control parameters sane */
874 /* Check various option values */
884 /* [] */
888 /* [0 .. notabove] */
890 }
893 /* [notbelow .. ] */
896 /* [notbelow .. notabove] */
897 }
898 }
907 }
909 # if !defined(VGO_darwin)
913 /*NOTREACHED*/
914 }
915 # endif
917 /* If XML output is requested, check that the tool actually
918 supports it. */
923 /*NOTREACHED*/
924 }
929 /* If we've been asked to emit XML, mash around various other
930 options so as to constrain the output somewhat, and to remove
931 any need for user input during the run.
932 */
935 /* We can't allow --gen-suppressions=yes, since that requires us
936 to print the error and then ask the user if she wants a
937 suppression for it, but in XML mode we won't print it until
938 we know whether we also need to print a suppression. Hence a
939 circular dependency. So disallow this.
940 (--gen-suppressions=all is still OK since we don't need any
941 user interaction in this case.) */
946 "or --gen-suppressions=all is allowed, but not "
948 }
950 /* We can't allow DB attaching (or we maybe could, but results
951 could be chaotic ..) since it requires user input. Hence
952 disallow. */
958 }
960 /* Disallow dump_error in XML mode; sounds like a recipe for
961 chaos. No big deal; dump_error is a flag for debugging V
962 itself. */
965 }
967 /* Disable error limits (this might be a bad idea!) */
969 /* Disable emulation warnings */
971 /* Also, we want to set options for the leak checker, but that
972 will have to be done in Memcheck's flag-handling code, not
973 here. */
974 }
976 /* All non-logging-related options have been checked. If the logging
977 option specified is ok, we can switch to it, as we know we won't
978 have to generate any other command-line-related error messages.
979 (So far we should be still attached to stderr, so we can show on
980 the terminal any problems to do with processing command line
981 opts.)
983 So set up logging now. After this is done, VG_(log_output_sink)
984 and (if relevant) VG_(xml_output_sink) should be connected to
985 whatever sink has been selected, and we indiscriminately chuck
986 stuff into it without worrying what the nature of it is. Oh the
987 wonder of Unix streams. */
997 /* --- set up the normal text output channel --- */
1011 // Nb: we overwrite an existing file of this name without asking
1012 // any questions.
1014 log_fsname_unexpanded);
1025 /*NOTREACHED*/
1026 }
1028 }
1036 log_fsname_unexpanded);
1038 /*NOTREACHED*/
1039 }
1043 log_fsname_unexpanded );
1045 /* We don't change anything here. */
1051 }
1053 }
1054 }
1056 /* --- set up the XML output channel --- */
1070 // Nb: we overwrite an existing file of this name without asking
1071 // any questions.
1073 xml_fsname_unexpanded);
1085 /*NOTREACHED*/
1086 }
1088 }
1096 xml_fsname_unexpanded );
1098 /*NOTREACHED*/
1099 }
1103 xml_fsname_unexpanded);
1104 /* We don't change anything here. */
1110 }
1112 }
1113 }
1115 /* If we've got this far, and XML mode was requested, but no XML
1116 output channel appears to have been specified, just stop. We
1117 could continue, and XML output will simply vanish into nowhere,
1118 but that is likely to confuse the hell out of users, which is
1119 distinctly Ungood. */
1126 );
1127 }
1129 // Finalise the output fds: the log fd ..
1132 // Move log_fd into the safe range, so it doesn't conflict with
1133 // any app fds.
1143 }
1145 // If they said --log-fd=-1, don't print anything. Plausible for use in
1146 // regression testing suites that use client requests to count errors.
1149 }
1151 // Finalise the output fds: and the XML fd ..
1154 // Move xml_fd into the safe range, so it doesn't conflict with
1155 // any app fds.
1165 }
1167 // If they said --xml-fd=-1, don't print anything. Plausible for use in
1168 // regression testing suites that use client requests to count errors.
1171 }
1173 // Suppressions related stuff
1177 /* If we haven't reached the max number of suppressions, load
1178 the default one. */
1184 }
1187 }
1189 // Write the name and value of log file qualifiers to the xml file.
1190 // We can safely assume here that the format string is well-formed.
1191 // It has been checked earlier in VG_(expand_file_name) when processing
1192 // command line options.
1194 {
1199 // We saw a '%'. What's next...
1200 i++;
1202 i++;
1204 // Get the env var name, print its contents.
1212 qualname_len);
1215 i++;
1220 }
1221 i++;
1222 }
1223 }
1224 }
1226 i++;
1227 }
1228 }
1229 }
1232 /*====================================================================*/
1233 /*=== Printing the preamble ===*/
1234 /*====================================================================*/
1236 // Print the argument, escaping any chars that require it.
1238 {
1241 Int i;
1245 }
1247 }
1248 }
1250 // Send output to the XML-stream and escape any XML meta-characters.
1252 {
1254 }
1256 /* Ok, the logging sink is running now. Print a suitable preamble.
1257 If logging to file or a socket, write details of parent PID and
1258 command line args, to help people trying to interpret the
1259 results of a run which encompasses multiple processes. */
1263 {
1264 Int i;
1285 }
1292 /* Tool details */
1294 xpre,
1300 xpost );
1305 xpre, xpost
1306 );
1307 }
1312 /* Core details */
1316 );
1318 // Print the command line. At one point we wrapped at 80 chars and
1319 // printed a '\' as a line joiner, but that makes it hard to cut and
1320 // paste the command line (because of the "==pid==" prefixes), so we now
1321 // favour utility and simplicity over aesthetics.
1329 }
1334 }
1336 // Print the parent PID, and other stuff, if necessary.
1339 }
1340 else
1349 /* Note: the user comment itself is XML and is therefore to
1350 be passed through verbatim (%s) rather than escaped
1351 (%pS). */
1354 }
1362 else
1369 );
1370 }
1380 );
1381 }
1385 }
1387 // Last thing in the preamble is a blank line.
1394 SysRes fd;
1395 VexArch vex_arch;
1396 VexArchInfo vex_archinfo;
1404 }
1420 }
1426 }
1430 Vg_DebugMsg,
1435 );
1437 Vg_DebugMsg,
1440 );
1443 }
1444 }
1447 /*====================================================================*/
1448 /*=== File descriptor setup ===*/
1449 /*====================================================================*/
1451 /* Number of file descriptors that Valgrind tries to reserve for
1452 it's own use - just a small constant. */
1453 #define N_RESERVED_FDS (10)
1456 {
1460 /* Get the current file descriptor limits. */
1464 }
1466 # if defined(VGO_darwin)
1467 /* Darwin lies. It reports file max as RLIM_INFINITY but
1468 silently disallows anything bigger than 10240. */
1471 }
1472 # endif
1478 /* Work out where to move the soft limit to. */
1483 }
1485 /* Reserve some file descriptors for our use. */
1489 /* Update the soft limit. */
1497 }
1501 }
1504 /*====================================================================*/
1505 /*=== main() ===*/
1506 /*====================================================================*/
1508 /* When main() is entered, we should be on the following stack, not
1509 the one the kernel gave us. We will run on this stack until
1510 simulation of the root thread is started, at which point a transfer
1511 is made to a dynamically allocated stack. This is for the sake of
1512 uniform overflow detection for all Valgrind threads. This is
1513 marked global even though it isn't, because assembly code below
1514 needs to reference the name. */
1518 /* These are the structures used to hold info for creating the initial
1519 client image.
1521 'iicii' mostly holds important register state present at system
1522 startup (_start_valgrind). valgrind_main() then fills in the rest
1523 of it and passes it to VG_(ii_create_image)(). That produces
1524 'iifii', which is later handed to VG_(ii_finalise_image). */
1526 /* In all OS-instantiations, the_iicii has a field .sp_at_startup.
1527 This should get some address inside the stack on which we gained
1528 control (eg, it could be the SP at startup). It doesn't matter
1529 exactly where in the stack it is. This value is passed to the
1530 address space manager at startup. On Linux, aspacem then uses it
1531 to identify the initial stack segment and hence the upper end of
1532 the usable address space. */
1538 /* A simple pair structure, used for conveying debuginfo handles to
1539 calls to VG_TRACK(new_mem_startup, ...). */
1543 /* --- Forwards decls to do with shutdown --- */
1547 /* Do everything which needs doing when the last thread exits */
1548 static
1550 VgSchedReturnCode tids_schedretcode );
1552 /* --- end of Forwards decls to do with shutdown --- */
1555 /* By the time we get to valgrind_main, the_iicii should already have
1556 been filled in with any important details as required by whatever
1557 OS we have been built for.
1558 */
1559 static
1561 {
1571 //============================================================
1572 //
1573 // Nb: startup is complex. Prerequisites are shown at every step.
1574 // *** Be very careful when messing with the order ***
1575 //
1576 // The first order of business is to get debug logging, the address
1577 // space manager and the dynamic memory manager up and running.
1578 // Once that's done, we can relax a bit.
1579 //
1580 //============================================================
1582 /* This is needed to make VG_(getenv) usable early. */
1585 //--------------------------------------------------------------
1586 // Start up Mach kernel interface, if any
1587 // p: none
1588 //--------------------------------------------------------------
1589 # if defined(VGO_darwin)
1591 # endif
1593 //--------------------------------------------------------------
1594 // Start up the logging mechanism
1595 // p: none
1596 //--------------------------------------------------------------
1597 /* Start the debugging-log system ASAP. First find out how many
1598 "-d"s were specified. This is a pre-scan of the command line. Also
1599 get --profile-heap=yes, --core-redzone-size, --redzone-size
1600 --aspace-minaddr which are needed by the time we start up dynamic
1601 memory management. */
1614 # if VG_WORDSIZE == 4
1616 # else
1618 # endif
1627 "Must be a page aligned address between "
1629 }
1630 }
1632 /* ... and start the debug logger. Now we can safely emit logging
1633 messages all through startup. */
1638 //--------------------------------------------------------------
1639 // Ensure we're on a plausible stack.
1640 // p: logging
1641 //--------------------------------------------------------------
1647 /* Re "volatile": Apple clang version 4.0
1648 (tags/Apple/clang-421.0.57) (based on LLVM 3.1svn)" appeared
1649 to miscompile the following check, causing run to abort at
1650 this point (in 64-bit mode) even though aLocal is within limLo
1651 .. limHi. But in fact clang is within its rights to do
1652 strange things here. "The reason is that the comparisons
1653 aLocal < limLo and aLocal >= limHi cause undefined behaviour
1654 (according to c99 6.5.8) because they compare pointers that do
1655 not point into the same aggregate." Adding "volatile" appears
1656 to fix it because "The compiler would have to prove that there
1657 is undefined behavior in order to exploit it. But as a
1658 volatile variable can change its value in ways invisible to
1659 the compiler, the compiler must make the conservative
1660 assumption that it points into the same aggregate as the other
1661 pointer its compared against. I.e. the behaviour is possibly
1662 defined." (Analysis by Florian Krohm). */
1664 /* something's wrong. Stop. */
1671 }
1672 }
1674 //--------------------------------------------------------------
1675 // Ensure we have a plausible pointer to the stack on which
1676 // we gained control (not the current stack!)
1677 // p: logging
1678 //--------------------------------------------------------------
1685 }
1687 //--------------------------------------------------------------
1688 // Start up the address space manager, and determine the
1689 // approximate location of the client's stack
1690 // p: logging, plausible-stack
1691 //--------------------------------------------------------------
1703 //--------------------------------------------------------------
1704 // Start up the dynamic memory manager
1705 // p: address space management
1706 // p: getting --profile-heap,--core-redzone-size,--redzone-size
1707 // In fact m_mallocfree is self-initialising, so there's no
1708 // initialisation call to do. Instead, try a simple malloc/
1709 // free pair right now to check that nothing is broken.
1710 //--------------------------------------------------------------
1714 }
1717 //============================================================
1718 //
1719 // Dynamic memory management is now available.
1720 //
1721 //============================================================
1723 //--------------------------------------------------------------
1724 // Initialise m_debuginfo
1725 // p: dynamic memory allocation
1729 //--------------------------------------------------------------
1730 // Look for alternative libdir
1735 }
1737 //--------------------------------------------------------------
1738 // Extract the launcher name from the environment.
1745 }
1748 //--------------------------------------------------------------
1749 // Get the current process datasize rlimit, and set it to zero.
1750 // This prevents any internal uses of brk() from having any effect.
1751 // We remember the old value so we can restore it on exec, so that
1752 // child processes will have a reasonable brk value.
1757 // Get the current process stack rlimit.
1760 //--------------------------------------------------------------
1761 // Figure out what sort of CPU we're on, and whether it is
1762 // able to run V.
1765 VexArchInfo vex_archinfo;
1779 }
1785 );
1786 }
1788 //--------------------------------------------------------------
1789 // Record the working directory at startup
1790 // p: none
1796 }
1799 //============================================================
1800 // Command line argument handling order:
1801 // * If --help/--help-debug are present, show usage message
1802 // (including the tool-specific usage)
1803 // * (If no --tool option given, default to Memcheck)
1804 // * Then, if client is missing, abort with error msg
1805 // * Then, if any cmdline args are bad, abort with error msg
1806 //============================================================
1808 //--------------------------------------------------------------
1809 // Split up argv into: C args, V args, V extra args, and exename.
1810 // p: dynamic memory allocation
1811 //--------------------------------------------------------------
1821 );
1827 );
1828 }
1830 //--------------------------------------------------------------
1831 // Extract tool name and whether help has been requested.
1832 // Note we can't print the help message yet, even if requested,
1833 // because the tool has not been initialised.
1834 // p: split_up_argv [for VG_(args_for_valgrind)]
1835 //--------------------------------------------------------------
1840 // BEGIN HACK
1843 # if !defined(VGO_darwin)
1847 /* Change the default setting. Later on (just below)
1848 main_process_cmd_line_options should pick up any
1849 user-supplied setting for it and will override the default
1850 set here. */
1852 }
1853 # endif
1854 // END HACK
1856 // Set default vex control params
1859 //--------------------------------------------------------------
1860 // Load client executable, finding in $PATH if necessary
1861 // p: early_process_cmd_line_options() [for 'exec', 'need_help',
1862 // clo_max_stackframe,
1863 // clo_main_stacksize]
1864 // p: layout_remaining_space [so there's space]
1865 //
1866 // Set up client's environment
1867 // p: set-libdir [for VG_(libdir)]
1868 // p: early_process_cmd_line_options [for toolname]
1869 //
1870 // Setup client stack, eip, and VG_(client_arg[cv])
1871 // p: load_client() [for 'info']
1872 // p: fix_environment() [for 'env']
1873 //
1874 // Setup client data (brk) segment. Initially a 1-page segment
1875 // which abuts a shrinkable reservation.
1876 // p: load_client() [for 'info' and hence VG_(brk_base)]
1877 //
1878 // p: _start_in_C (for zeroing out the_iicii and putting some
1879 // initial values into it)
1880 //--------------------------------------------------------------
1884 # if defined(VGO_linux) || defined(VGO_darwin)
1888 # else
1890 # endif
1892 /* NOTE: this call reads VG_(clo_main_stacksize). */
1894 }
1896 //==============================================================
1897 //
1898 // Finished loading/setting up the client address space.
1899 //
1900 //==============================================================
1902 //--------------------------------------------------------------
1903 // setup file descriptors
1904 // p: n/a
1905 //--------------------------------------------------------------
1909 //--------------------------------------------------------------
1910 // create fake /proc/<pid>/cmdline and /proc/<pid>/auxv files
1911 // and then unlink them, but hold onto the fds, so we can handr
1912 // them out to the client when it tries to open
1913 // /proc/<pid>/cmdline or /proc/<pid>/auxv for itself.
1914 // p: setup file descriptors
1915 // p: ii_create_image for VG_(client_auxv) setup.
1916 //--------------------------------------------------------------
1917 #if !defined(VGO_linux)
1918 // client shouldn't be using /proc!
1921 #else
1945 }
1947 /* Don't bother to seek the file back to the start; instead do
1948 it every time a copy of it is given out (by PRE(sys_open)).
1949 That is probably more robust across fork() etc. */
1951 /* Now delete it, but hang on to the fd. */
1968 client_auxv++;
1969 client_auxv++;
1971 }
1976 /* Don't bother to seek the file back to the start; instead do
1977 it every time a copy of it is given out (by PRE(sys_open)).
1978 That is probably more robust across fork() etc. */
1980 /* Now delete it, but hang on to the fd. */
1986 }
1987 #endif
1989 //--------------------------------------------------------------
1990 // Init tool part 1: pre_clo_init
1991 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
1992 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
1993 //--------------------------------------------------------------
1996 // Activate var info readers, if the tool asked for it:
2000 //--------------------------------------------------------------
2001 // If --tool and --help/--help-debug was given, now give the core+tool
2002 // help message
2003 // p: early_process_cmd_line_options() [for 'need_help']
2004 // p: tl_pre_clo_init [for 'VG_(tdict).usage']
2005 //--------------------------------------------------------------
2009 }
2011 //--------------------------------------------------------------
2012 // Process command line options to Valgrind + tool
2013 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
2014 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
2015 //--------------------------------------------------------------
2017 "(main_) Process Valgrind's command line options, "
2020 toolname );
2022 //--------------------------------------------------------------
2023 // Zeroise the millisecond counter by doing a first read of it.
2024 // p: none
2025 //--------------------------------------------------------------
2028 //--------------------------------------------------------------
2029 // Print the preamble
2030 // p: tl_pre_clo_init [for 'VG_(details).name' and friends]
2031 // p: main_process_cmd_line_options()
2032 // [for VG_(clo_verbosity), VG_(clo_xml),
2033 // logging_to_fd, xml_fname_unexpanded]
2034 //--------------------------------------------------------------
2039 //--------------------------------------------------------------
2040 // Init tool part 2: post_clo_init
2041 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
2042 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
2043 // p: print_preamble() [so any warnings printed in post_clo_init
2044 // are shown after the preamble]
2045 //--------------------------------------------------------------
2048 {
2049 /* The tool's "needs" will by now be finalised, since it has no
2050 further opportunity to specify them. So now sanity check
2051 them. */
2053 Bool ok;
2057 }
2058 }
2060 //--------------------------------------------------------------
2061 // Initialise translation table and translation cache
2062 // p: aspacem [??]
2063 // p: tl_pre_clo_init [for 'VG_(details).avg_translation_sizeB']
2064 //--------------------------------------------------------------
2068 //--------------------------------------------------------------
2069 // Initialise the redirect table.
2070 // p: init_tt_tc [so it can call VG_(search_transtab) safely]
2071 // p: aspacem [so can change ownership of sysinfo pages]
2072 //--------------------------------------------------------------
2076 //--------------------------------------------------------------
2077 // Allow GDB attach
2078 // p: main_process_cmd_line_options() [for VG_(clo_wait_for_gdb)]
2079 //--------------------------------------------------------------
2080 /* Hook to delay things long enough so we can get the pid and
2081 attach GDB in another shell. */
2087 # if defined(VGP_x86_linux)
2089 # elif defined(VGP_amd64_linux) || defined(VGP_ppc64be_linux) \
2090 || defined(VGP_ppc64le_linux)
2092 # elif defined(VGP_ppc32_linux)
2094 # elif defined(VGP_arm_linux)
2096 # elif defined(VGP_arm64_linux)
2098 # elif defined(VGP_s390x_linux)
2100 # elif defined(VGP_mips32_linux) || defined(VGP_mips64_linux)
2102 # elif defined(VGO_darwin)
2104 # else
2106 # endif
2111 }
2113 //--------------------------------------------------------------
2114 // Search for file descriptors that are inherited from our parent
2115 // p: main_process_cmd_line_options [for VG_(clo_track_fds)]
2116 //--------------------------------------------------------------
2120 }
2122 //--------------------------------------------------------------
2123 // Load debug info for the existing segments.
2124 // p: setup_code_redirect_table [so that redirs can be recorded]
2125 // p: mallocfree
2126 // p: probably: setup fds and process CLOs, so that logging works
2127 // p: initialise m_debuginfo
2128 //
2129 // While doing this, make a note of the debuginfo-handles that
2130 // come back from VG_(di_notify_mmap).
2131 // Later, in "Tell the tool about the initial client memory permissions"
2132 // (just below) we can then hand these handles off to the tool in
2133 // calls to VG_TRACK(new_mem_startup, ...). This gives the tool the
2134 // opportunity to make further queries to m_debuginfo before the
2135 // client is started, if it wants. We put this information into an
2136 // XArray, each handle along with the associated segment start address,
2137 // and search the XArray for the handles later, when calling
2138 // VG_TRACK(new_mem_startup, ...).
2139 //--------------------------------------------------------------
2146 # if defined(VGO_linux)
2148 Int n_seg_starts;
2149 Addr_n_ULong anu;
2154 /* show them all to the debug info reader. allow_SkFileV has to
2155 be True here so that we read info from the valgrind executable
2156 itself. */
2160 /* anu.ull holds the debuginfo handle returned by di_notify_mmap,
2161 if any. */
2165 }
2166 }
2169 }
2170 # elif defined(VGO_darwin)
2172 Int n_seg_starts;
2176 /* show them all to the debug info reader.
2177 Don't read from V segments (unlike Linux) */
2178 // GrP fixme really?
2182 }
2185 }
2186 # else
2187 # error Unknown OS
2188 # endif
2190 //--------------------------------------------------------------
2191 // Tell aspacem of ownership change of the asm helpers, so that
2192 // m_translate allows them to be translated. However, only do this
2193 // after the initial debug info read, since making a hole in the
2194 // address range for the stage2 binary confuses the debug info reader.
2195 // p: aspacem
2196 //--------------------------------------------------------------
2204 change_ownership_v_c_OK
2207 }
2216 buf );
2218 }
2222 //--------------------------------------------------------------
2223 // Initialise the scheduler (phase 1) [generates tid_main]
2224 // p: none, afaics
2225 //--------------------------------------------------------------
2230 /* Tell the tool about tid_main */
2233 //--------------------------------------------------------------
2234 // Tell the tool about the initial client memory permissions
2235 // p: aspacem
2236 // p: mallocfree
2237 // p: setup_client_stack
2238 // p: setup_client_dataseg
2239 //
2240 // For each segment we tell the client about, look up in
2241 // addr2dihandle as created above, to see if there's a debuginfo
2242 // handle associated with the segment, that we can hand along
2243 // to the tool, to be helpful.
2244 //--------------------------------------------------------------
2247 Int n_seg_starts;
2251 /* Mark the main thread as running while we tell the tool about
2252 the client memory so that the tool can associate that memory
2253 with the main thread. */
2260 /* show interesting ones to the tool */
2267 /* This next assertion is tricky. If it is placed
2268 immediately before this 'if', it very occasionally fails.
2269 Why? Because previous iterations of the loop may have
2270 caused tools (via the new_mem_startup calls) to do
2271 dynamic memory allocation, and that may affect the mapped
2272 segments; in particular it may cause segment merging to
2273 happen. Hence we cannot assume that seg_starts[i], which
2274 reflects the state of the world before we started this
2275 loop, is the same as seg->start, as the latter reflects
2276 the state of the world (viz, mappings) at this particular
2277 iteration of the loop.
2279 Why does moving it inside the 'if' make it safe? Because
2280 any dynamic memory allocation done by the tools will
2281 affect only the state of Valgrind-owned segments, not of
2282 Client-owned segments. And the 'if' guards against that
2283 -- we only get in here for Client-owned segments.
2285 In other words: the loop may change the state of
2286 Valgrind-owned segments as it proceeds. But it should
2287 not cause the Client-owned segments to change. */
2295 /* search addr2dihandle to see if we have an entry
2296 matching seg->start. */
2303 }
2304 }
2308 /* and the retrieved debuginfo handle, if any */
2309 j < n
2312 }
2313 }
2318 /* Also do the initial stack permissions. */
2319 {
2320 SSizeT inaccessible_len;
2328 /* Stuff below the initial SP is unaddressable. Take into
2329 account any ABI-mandated space below the stack pointer that
2330 is required (VG_STACK_REDZONE_SZB). setup_client_stack()
2331 will have allocated an extra page if a red zone is required,
2332 to be on the safe side. */
2339 inaccessible_len );
2343 }
2345 /* Also the assembly helpers. */
2355 /* Clear the running thread indicator */
2359 /* Darwin only: tell the tools where the client's kernel commpage
2360 is. It would be better to do this by telling aspacemgr about
2361 it -- see the now disused record_system_memory() in
2362 initimg-darwin.c -- but that causes the sync checker to fail,
2363 since the mapping doesn't appear in the kernel-supplied
2364 process map. So do it here instead. */
2365 # if defined(VGP_amd64_darwin)
2370 # elif defined(VGP_x86_darwin)
2375 # endif
2376 }
2378 //--------------------------------------------------------------
2379 // Initialise the scheduler (phase 2)
2380 // p: Initialise the scheduler (phase 1) [for tid_main]
2381 // p: setup_file_descriptors() [else VG_(safe_fd)() breaks]
2382 // p: setup_client_stack
2383 //--------------------------------------------------------------
2393 }
2395 //--------------------------------------------------------------
2396 // Set up state for the root thread
2397 // p: ?
2398 // setup_scheduler() [for sched-specific thread 1 stuff]
2399 // VG_(ii_create_image) [for 'the_iicii' initial info]
2400 //--------------------------------------------------------------
2404 //--------------------------------------------------------------
2405 // Initialise the signal handling subsystem
2406 // p: n/a
2407 //--------------------------------------------------------------
2408 // Nb: temporarily parks the saved blocking-mask in saved_sigmask.
2410 /* Check that the kernel-interface signal definitions look sane */
2412 /* .. and go on to use them. */
2415 //--------------------------------------------------------------
2416 // Read suppression file
2417 // p: main_process_cmd_line_options() [for VG_(clo_suppressions)]
2418 //--------------------------------------------------------------
2422 }
2424 //--------------------------------------------------------------
2425 // register client stack
2426 //--------------------------------------------------------------
2429 //--------------------------------------------------------------
2430 // Show the address space state so far
2431 //--------------------------------------------------------------
2438 //--------------------------------------------------------------
2439 // Run!
2440 //--------------------------------------------------------------
2443 /* As a result of the following call, the last thread standing
2444 eventually winds up running shutdown_actions_NORETURN
2445 just below. Unfortunately, simply exporting said function
2446 causes m_main to be part of a module cycle, which is pretty
2447 nonsensical. So instead of doing that, the address of said
2448 function is stored in a global variable 'owned' by m_syswrap,
2449 and it uses that function pointer to get back here when it needs
2450 to. */
2452 /* Set continuation address. */
2456 /* Run the first thread, eventually ending up at the continuation
2457 address. */
2460 /*NOTREACHED*/
2462 }
2464 /* Do everything which needs doing when the last thread exits or when
2465 a thread exits requesting a complete process exit.
2467 We enter here holding The Lock. For the case VgSrc_ExitProcess we
2468 must never release it, because to do so would allow other threads
2469 to continue after the system is ostensibly shut down. So we must
2470 go to our grave, so to speak, holding the lock.
2472 In fact, there is never any point in releasing the lock at this
2473 point - we have it, we're shutting down the entire system, and
2474 for the case VgSrc_ExitProcess doing so positively causes trouble.
2475 So don't.
2477 The final_tidyup call makes a bit of a nonsense of the ExitProcess
2478 case, since it will run the libc_freeres function, thus allowing
2479 other lurking threads to run again. Hmm. */
2481 static
2483 VgSchedReturnCode tids_schedretcode )
2484 {
2496 // We are the last surviving thread. Right?
2499 // Wait for all other threads to exit.
2500 // jrs: Huh? but they surely are already gone
2503 // Clean the client up before the final report
2504 // this causes the libc_freeres function to run
2507 /* be paranoid */
2513 // We may not be the last surviving thread. However, we
2514 // want to shut down the entire process. We hold the lock
2515 // and we need to keep hold of it all the way out, in order
2516 // that none of the other threads ever run again.
2519 // Clean the client up before the final report
2520 // this causes the libc_freeres function to run
2521 // perhaps this is unsafe, as per comment above
2524 /* be paranoid */
2527 }
2529 /* Final call to gdbserver, if requested. */
2533 }
2536 //--------------------------------------------------------------
2537 // Finalisation: cleanup, messages, etc. Order not so important, only
2538 // affects what order the messages come.
2539 //--------------------------------------------------------------
2540 // First thing in the post-amble is a blank line.
2554 buf);
2555 }
2557 /* Print out file descriptor summary and stats. */
2561 /* Call the tool's finalisation function. This makes Memcheck's
2562 leak checker run, and possibly chuck a bunch of leak errors into
2563 the error management machinery. */
2566 /* Show the error counts. */
2570 }
2572 /* In XML mode, this merely prints the used suppressions. */
2580 }
2588 /* Show a profile of the heap(s) at shutdown. Optionally, first
2589 throw away all the debug info, as that makes it easy to spot
2590 leaks in the debuginfo reader. */
2594 }
2596 /* If profiling has been requested, but with zero interval, it
2597 means "profile at the end of the run only". In which case we
2598 need to dump the profile now. */
2601 }
2603 /* Print Vex storage stats */
2607 /* Flush any output cached by previous calls to VG_(message). */
2610 /* Terminate gdbserver if ever it was started. We terminate it here
2611 so that it get the output above if output was redirected to
2612 gdb */
2615 /* Ok, finally exit in the os-specific way, according to the scheduler's
2616 return code. In short, if the (last) thread exited by calling
2617 sys_exit, do likewise; if the (last) thread stopped due to a fatal
2618 signal, terminate the entire system with that same fatal signal. */
2625 /* Change the application return code to user's return code,
2626 if an error was found */
2631 /* otherwise, return the client's exit code, in the normal
2632 way. */
2634 }
2635 /* NOT ALIVE HERE! */
2640 /* We were killed by a fatal signal, so replicate the effect */
2643 /* we shouldn't be alive at this point. But VG_(kill_self)
2644 sometimes fails with EPERM on Darwin, for unclear reasons. */
2645 # if defined(VGO_darwin)
2648 /* fall through .. */
2649 # endif
2655 }
2656 }
2658 /* -------------------- */
2660 /* Final clean-up before terminating the process.
2661 Clean up the client by calling __libc_freeres() (if requested)
2662 This is Linux-specific?
2663 GrP fixme glibc-specific, anyway
2664 */
2666 {
2667 #if !defined(VGO_darwin)
2668 # if defined(VGP_ppc64be_linux)
2669 Addr r2;
2670 # endif
2680 # if defined(VGP_ppc64be_linux)
2688 }
2689 # endif
2697 /* set thread context to point to libc_freeres_wrapper */
2698 /* ppc64be-linux note: __libc_freeres_wrapper gives us the real
2699 function entry point, not a fn descriptor, so can use it
2700 directly. However, we need to set R2 (the toc pointer)
2701 appropriately. */
2703 # if defined(VGP_ppc64be_linux)
2705 # elif defined(VGP_ppc64le_linux)
2706 /* setting GPR2 but not really needed, GPR12 is needed */
2709 # endif
2710 /* mips-linux note: we need to set t9 */
2711 # if defined(VGP_mips32_linux) || defined(VGP_mips64_linux)
2713 # endif
2715 /* Block all blockable signals by copying the real block state into
2716 the thread's block state*/
2720 /* and restore handlers to default */
2726 // We were exiting, so assert that...
2728 // ...but now we're not again
2731 // run until client thread exits - ideally with LIBC_FREERES_DONE,
2732 // but exit/exitgroup/signal will do
2736 #endif
2737 }
2740 /*====================================================================*/
2741 /*=== Getting to main() alive: LINUX ===*/
2742 /*====================================================================*/
2744 #if defined(VGO_linux)
2746 /* If linking of the final executables is done with glibc present,
2747 then Valgrind starts at main() above as usual, and all of the
2748 following code is irrelevant.
2750 However, this is not the intended mode of use. The plan is to
2751 avoid linking against glibc, by giving gcc the flags
2752 -nodefaultlibs -lgcc -nostartfiles at startup.
2754 From this derive two requirements:
2756 1. gcc may emit calls to memcpy, memmove and memset to deal with
2757 structure assignments etc. Since we have chosen to ignore all the
2758 "normal" supporting libraries, we have to provide our own
2759 implementations of them. No problem.
2761 2. We have to provide a symbol "_start", to which the kernel
2762 hands control at startup. Hence the code below.
2763 */
2765 /* ---------------- Requirement 1 ---------------- */
2770 }
2774 }
2778 }
2780 /* BVA: abort() for those platforms that need it (PPC and ARM). */
2785 }
2787 /* EAZG: ARM's EABI will call floating point exception handlers in
2788 libgcc which boil down to an abort or raise, that's usually defined
2789 in libc. Instead, define them here. */
2790 #if defined(VGP_arm_linux)
2795 }
2801 }
2807 }
2808 #endif
2810 /* ---------------- Requirement 2 ---------------- */
2812 /* Glibc's sysdeps/i386/elf/start.S has the following gem of a
2813 comment, which explains how the stack looks right at process start
2814 (when _start is jumped to). Hence _start passes %esp to
2815 _start_in_C_linux, which extracts argc/argv/envp and starts up
2816 correctly. */
2818 /* This is the canonical entry point, usually the first thing in the text
2819 segment. The SVR4/i386 ABI (pages 3-31, 3-32) says that when the entry
2820 point runs, most registers' values are unspecified, except for:
2822 %edx Contains a function pointer to be registered with `atexit'.
2823 This is how the dynamic linker arranges to have DT_FINI
2824 functions called for shared libraries that have been loaded
2825 before this code runs.
2827 %esp The stack contains the arguments and environment:
2828 0(%esp) argc
2829 4(%esp) argv[0]
2830 ...
2831 (4*argc)(%esp) NULL
2832 (4*(argc+1))(%esp) envp[0]
2833 ...
2834 NULL
2835 */
2837 /* The kernel hands control to _start, which extracts the initial
2838 stack pointer and calls onwards to _start_in_C_linux. This also switches
2839 the new stack. */
2840 #if defined(VGP_x86_linux)
2846 /* set up the new stack in %eax */
2852 /* install it, and collect the original one */
2854 /* call _start_in_C_linux, passing it the startup %esp */
2859 );
2860 #elif defined(VGP_amd64_linux)
2866 /* set up the new stack in %rdi */
2871 /* install it, and collect the original one */
2873 /* call _start_in_C_linux, passing it the startup %rsp */
2877 );
2878 #elif defined(VGP_ppc32_linux)
2884 /* set up the new stack in r16 */
2894 /* now r16 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2895 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2896 boundary. And r1 is the original SP. Set the SP to r16 and
2897 call _start_in_C_linux, passing it the initial SP. */
2903 );
2904 #elif defined(VGP_ppc64be_linux)
2906 /* PPC64 ELF ABI says '_start' points to a function descriptor.
2907 So we must have one, and that is what goes into the .opd section. */
2918 /* set up the new stack in r16 */
2933 /* now r16 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2934 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2935 boundary. And r1 is the original SP. Set the SP to r16 and
2936 call _start_in_C_linux, passing it the initial SP. */
2949 );
2950 #elif defined(VGP_ppc64le_linux)
2951 /* Little Endian uses ELF version 2 but in the future may also
2952 * support other ELF versions.
2953 */
2964 /* set up the new stack in r16 */
2979 /* now r16 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2980 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2981 boundary. And r1 is the original SP. Set the SP to r16 and
2982 call _start_in_C_linux, passing it the initial SP. */
2994 );
2995 #elif defined(VGP_s390x_linux)
2996 /*
2997 This is the canonical entry point, usually the first thing in the text
2998 segment. Most registers' values are unspecified, except for:
3000 %r14 Contains a function pointer to be registered with `atexit'.
3001 This is how the dynamic linker arranges to have DT_FINI
3002 functions called for shared libraries that have been loaded
3003 before this code runs.
3005 %r15 The stack contains the arguments and environment:
3006 0(%r15) argc
3007 8(%r15) argv[0]
3008 ...
3009 (8*argc)(%r15) NULL
3010 (8*(argc+1))(%r15) envp[0]
3011 ...
3012 NULL
3013 */
3019 /* set up the new stack in %r1 */
3025 /* install it, and collect the original one */
3028 /* call _start_in_C_linux, passing it the startup %r15 */
3030 /* trigger execution of an invalid opcode -> halt machine */
3035 );
3036 #elif defined(VGP_arm_linux)
3057 );
3058 #elif defined(VGP_arm64_linux)
3067 // The next 2 assume that VG_STACK_GUARD_SZB fits in 32 bits
3072 // The next 2 assume that VG_STACK_ACTIVE_SZB fits in 32 bits
3082 );
3083 #elif defined(VGP_mips32_linux)
3099 /* t1/$9 <- Addr(interim_stack) */
3101 /* t1/$9 <- Addr(interim_stack) */
3112 /* now t1/$9 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
3113 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
3114 boundary. And $29 is the original SP. Set the SP to t1 and
3115 call _start_in_C, passing it the initial SP. */
3126 );
3127 #elif defined(VGP_mips64_linux)
3138 /* t1/$9 <- Addr(interim_stack) */
3148 /* now t1/$9 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
3149 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
3150 boundary. And $29 is the original SP. Set the SP to t1 and
3151 call _start_in_C, passing it the initial SP. */
3165 );
3166 #else
3168 #endif
3170 /* --- !!! --- EXTERNAL HEADERS start --- !!! --- */
3171 #define _GNU_SOURCE
3172 #define _FILE_OFFSET_BITS 64
3173 /* This is in order to get AT_NULL and AT_PAGESIZE. */
3174 #include <elf.h>
3175 /* --- !!! --- EXTERNAL HEADERS end --- !!! --- */
3177 /* Avoid compiler warnings: this fn _is_ used, but labelling it
3178 'static' causes gcc to complain it isn't.
3179 attribute 'used' also ensures the code is not eliminated at link
3180 time */
3185 {
3186 Int r;
3191 // For an inner Valgrind, register the interim stack asap.
3192 // This is needed to allow the outer valgrind to do stacktraces during init.
3193 // Note that this stack is not unregistered when the main thread
3194 // is switching to the (real) stack. Unregistering this would imply
3195 // to save the stack id in a global variable, and have a "if"
3196 // in run_a_thread_NORETURN to do the unregistration only for the
3197 // main thread. This unregistration is not worth this complexity.
3198 INNER_REQUEST
3208 # if defined(VGP_ppc32_linux) || defined(VGP_ppc64be_linux) \
3209 || defined(VGP_ppc64le_linux) || defined(VGP_arm64_linux)
3210 {
3211 /* ppc32/ppc64 can be configured with different page sizes.
3212 Determine this early. This is an ugly hack and really should
3213 be moved into valgrind_main. */
3216 ;
3224 }
3225 }
3226 # endif
3229 /* NOTREACHED */
3231 }
3234 /*====================================================================*/
3235 /*=== Getting to main() alive: darwin ===*/
3236 /*====================================================================*/
3238 #elif defined(VGO_darwin)
3240 /*
3241 Memory layout established by kernel:
3243 0(%esp) argc
3244 4(%esp) argv[0]
3245 ...
3246 argv[argc-1]
3247 NULL
3248 envp[0]
3249 ...
3250 envp[n]
3251 NULL
3252 executable name (presumably, a pointer to it)
3253 NULL
3255 Ditto in the 64-bit case, except all offsets from SP are obviously
3256 twice as large.
3257 */
3259 /* The kernel hands control to _start, which extracts the initial
3260 stack pointer and calls onwards to _start_in_C_darwin. This also
3261 switches to the new stack. */
3262 #if defined(VGP_x86_darwin)
3268 /* set up the new stack in %eax */
3274 /* install it, and collect the original one */
3277 /* call _start_in_C_darwin, passing it the startup %esp */
3282 );
3283 #elif defined(VGP_amd64_darwin)
3289 /* set up the new stack in %rdi */
3294 /* install it, and collect the original one */
3296 /* call _start_in_C_darwin, passing it the startup %rsp */
3300 );
3301 #endif
3305 // skip check
3307 }
3310 // skip check
3312 }
3316 }
3321 }
3325 }
3327 /* Avoid compiler warnings: this fn _is_ used, but labelling it
3328 'static' causes gcc to complain it isn't. */
3331 {
3332 Int r;
3337 // See _start_in_C_linux
3338 INNER_REQUEST
3349 /* NOTREACHED */
3351 }
3354 #else
3357 #endif
3360 /*====================================================================*/
3361 /*=== {u,}{div,mod}di3 replacements ===*/
3362 /*====================================================================*/
3364 /* For static linking on x86-darwin, we need to supply our own 64-bit
3365 integer division code, else the link dies thusly:
3367 ld_classic: Undefined symbols:
3368 ___udivdi3
3369 ___umoddi3
3370 */
3371 #if defined(VGP_x86_darwin)
3373 /* Routines for doing signed/unsigned 64 x 64 ==> 64 div and mod
3374 (udivdi3, umoddi3, divdi3, moddi3) using only 32 x 32 ==> 32
3375 division. Cobbled together from
3377 http://www.hackersdelight.org/HDcode/divlu.c
3378 http://www.hackersdelight.org/HDcode/divls.c
3379 http://www.hackersdelight.org/HDcode/newCode/divDouble.c
3381 The code from those three files is covered by the following license,
3382 as it appears at:
3384 http://www.hackersdelight.org/permissions.htm
3386 You are free to use, copy, and distribute any of the code on
3387 this web site, whether modified by you or not. You need not give
3388 attribution. This includes the algorithms (some of which appear
3389 in Hacker's Delight), the Hacker's Assistant, and any code
3390 submitted by readers. Submitters implicitly agree to this.
3391 */
3393 /* Long division, unsigned (64/32 ==> 32).
3394 This procedure performs unsigned "long division" i.e., division of a
3395 64-bit unsigned dividend by a 32-bit unsigned divisor, producing a
3396 32-bit quotient. In the overflow cases (divide by 0, or quotient
3397 exceeds 32 bits), it returns a remainder of 0xFFFFFFFF (an impossible
3398 value).
3399 The dividend is u1 and u0, with u1 being the most significant word.
3400 The divisor is parameter v. The value returned is the quotient.
3401 Max line length is 57, to fit in hacker.book. */
3404 {
3405 Int n;
3414 }
3416 /* 64 x 32 ==> 32 unsigned division, using only 32 x 32 ==> 32
3417 division as a primitive. */
3419 {
3446 again1:
3456 again2:
3465 }
3468 /* 64 x 32 ==> 32 signed division, using only 32 x 32 ==> 32 division
3469 as a primitive. */
3471 {
3498 }
3502 /* This file contains a program for doing 64/64 ==> 64 division, on a
3503 machine that does not have that instruction but that does have
3504 instructions for "long division" (64/32 ==> 32). Code for unsigned
3505 division is given first, followed by a simple program for doing the
3506 signed version by using the unsigned version.
3507 These programs are useful in implementing "long long" (64-bit)
3508 arithmetic on a machine that has the long division instruction. It will
3509 work on 64- and 32-bit machines, provided the compiler implements long
3510 long's (64-bit integers). It is desirable that the machine have the
3511 Count Leading Zeros instruction.
3512 In the GNU world, these programs are known as __divdi3 and __udivdi3,
3513 and similar names are used here.
3514 This material is not in HD, but may be in a future edition.
3515 Max line length is 57, to fit in hacker.book. */
3519 {
3520 Int n;
3530 }
3532 // ---------------------------- udivdi3 --------------------------------
3534 /* The variables u0, u1, etc. take on only 32-bit values, but they
3535 are declared long long to avoid some compiler warning messages and to
3536 avoid some unnecessary EXTRs that the compiler would put in, to
3537 convert long longs to ints.
3539 First the procedure takes care of the case in which the divisor is a
3540 32-bit quantity. There are two subcases: (1) If the left half of the
3541 dividend is less than the divisor, one execution of DIVU is all that
3542 is required (overflow is not possible). (2) Otherwise it does two
3543 divisions, using the grade school method, with variables used as
3544 suggested below.
3546 q1 q0
3547 ________
3548 v) u1 u0
3549 q1*v
3550 ____
3551 k u0 */
3553 /* These macros must be used with arguments of the appropriate type
3554 (unsigned long long for DIVU and long long for DIVS. They are
3555 simulations of the presumed machines ops. I.e., they look at only the
3556 low-order 32 bits of the divisor, they return garbage if the division
3557 overflows, and they return garbage in the high-order half of the
3558 quotient doubleword.
3559 In practice, these would be replaced with uses of the machine's DIVU
3560 and DIVS instructions (e.g., by using the GNU "asm" facility). */
3563 {
3567 }
3570 {
3574 }
3576 /* 64 x 64 ==> 64 unsigned division, using only 32 x 32 ==> 32
3577 division as a primitive. */
3579 {
3595 }
3596 }
3597 // Here v >= 2**32.
3600 // so its MSB is 1.
3605 // division of u by 2.
3611 }
3614 // ----------------------------- divdi3 --------------------------------
3616 /* This routine presumes that smallish cases (those which can be done in
3617 one execution of DIVS) are common. If this is not the case, the test for
3618 this case should be deleted.
3619 Note that the test for when DIVS can be used is not entirely
3620 accurate. For example, DIVS is not used if v = 0xFFFFFFFF8000000,
3621 whereas if could be (if u is sufficiently small in magnitude). */
3623 // ------------------------------ cut ----------------------------------
3626 {
3629 }
3631 /* 64 x 64 ==> 64 signed division, using only 32 x 32 ==> 32 division
3632 as a primitive. */
3634 {
3640 // if (v << 32 >> 32 == v) { // If v is in range and
3644 }
3645 }
3649 }
3651 // ---------------------------- end cut --------------------------------
3655 {
3657 }
3661 {
3663 }
3667 {
3671 }
3675 {
3679 }
3681 /* ------------------------------------------------
3682 ld_classic: Undefined symbols:
3683 ___fixunsdfdi
3684 ------------------------------------------------
3685 */
3687 /* ===-- fixunsdfdi.c - Implement __fixunsdfdi -----------------------------===
3688 *
3689 * The LLVM Compiler Infrastructure
3690 *
3691 * This file is dual licensed under the MIT and the University of Illinois Open
3692 * Source Licenses. See LICENSE.TXT for details.
3693 *
3694 * ===----------------------------------------------------------------------===
3695 *
3696 * This file implements __fixunsdfdi for the compiler_rt library.
3697 *
3698 * ===----------------------------------------------------------------------===
3699 */
3701 /* As per http://www.gnu.org/licenses/license-list.html#GPLCompatibleLicenses,
3703 the "NCSA/University of Illinois Open Source License" is compatible
3704 with the GPL (both version 2 and 3). What is claimed to be
3705 compatible is this
3707 http://www.opensource.org/licenses/UoI-NCSA.php
3709 and the LLVM documentation at
3711 http://www.llvm.org/docs/DeveloperPolicy.html#license
3713 says all the code in LLVM is available under the University of
3714 Illinois/NCSA Open Source License, at this URL
3716 http://www.opensource.org/licenses/UoI-NCSA.php
3718 viz, the same one that the FSF pages claim is compatible. So I
3719 think it's OK to include it.
3720 */
3722 /* Returns: convert a to a unsigned long long, rounding toward zero.
3723 * Negative values all become zero.
3724 */
3726 /* Assumption: double is a IEEE 64 bit floating point type
3727 * du_int is a 64 bit integral type
3728 * value in double is representable in du_int or is negative
3729 * (no range checking performed)
3730 */
3732 /* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
3738 {
3739 du_int all;
3740 struct
3741 {
3742 #if VG_LITTLEENDIAN
3743 su_int low;
3744 su_int high;
3745 #else
3746 su_int high;
3747 su_int low;
3753 {
3754 udwords u;
3760 du_int
3762 {
3763 double_bits fb;
3768 udwords r;
3773 else
3776 }
3779 #endif
3782 /*====================================================================*/
3783 /*=== Dummy _voucher_mach_msg_set for OSX 10.10 ===*/
3784 /*====================================================================*/
3786 #if defined(VGO_darwin) && DARWIN_VERS == DARWIN_10_10
3788 /* Builds on MacOSX 10.10 seem to need this for some reason. */
3789 /* extern boolean_t voucher_mach_msg_set(mach_msg_header_t *msg)
3790 __attribute__((weak_import));
3791 I haven't a clue what the return value means, so just return 0.
3792 Looks like none of the generated uses in the tree look at the
3793 return value anyway.
3794 */
3797 {
3799 }
3801 #endif
3804 /*--------------------------------------------------------------------*/
3805 /*--- end ---*/
3806 /*--------------------------------------------------------------------*/