| blob | ee83a2280c2a1dd80abcdee0d59ee030731804a6 |
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. */
276 // Ensure the message goes to stdout
286 }
287 /* 'usage1' a type as described after each arg. */
295 N_SECTORS_DEFAULT /* int */
296 );
301 else
303 }
312 else
314 }
315 }
317 VG_BUGS_TO);
319 }
322 /* Peer at previously set up VG_(args_for_valgrind) and do some
323 minimal command line processing that must happen early on:
325 - show the version string, if requested (-v)
326 - extract any request for help (--help, -h, --help-debug)
327 - get the toolname (--tool=)
328 - set VG_(clo_max_stackframe) (--max-stackframe=)
329 - set VG_(clo_main_stacksize) (--main-stacksize=)
330 - set VG_(clo_sim_hints) (--sim-hints=)
332 That's all it does. The main command line processing is done below
333 by main_process_cmd_line_options. Note that
334 main_process_cmd_line_options has to handle but ignore the ones we
335 have handled here.
336 */
339 {
340 UInt i;
345 /* parse the options we have (only the options we care about now) */
351 // Nb: the version string goes to stdout.
356 }
362 // The tool has already been determined, but we need to know the name
363 // here.
366 // Set up VG_(clo_max_stackframe) and VG_(clo_main_stacksize).
367 // These are needed by VG_(ii_create_image), which happens
368 // before main_process_cmd_line_options().
372 // Set up VG_(clo_sim_hints). This is needed a.o. for an inner
373 // running in an outer, to have "no-inner-prefix" enabled
374 // as early as possible.
376 }
377 }
379 /* The main processing for command line options. See comments above
380 on early_process_cmd_line_options.
382 Comments on how the logging options are handled:
384 User can specify:
385 --log-fd= for a fd to write to (default setting, fd = 2)
386 --log-file= for a file name to write to
387 --log-socket= for a socket to write to
389 As a result of examining these and doing relevant socket/file
390 opening, a final fd is established. This is stored in
391 VG_(log_output_sink) in m_libcprint. Also, if --log-file=STR was
392 specified, then STR, after expansion of %p and %q templates within
393 it, is stored in VG_(clo_log_fname_expanded), in m_options, just in
394 case anybody wants to know what it is.
396 When printing, VG_(log_output_sink) is consulted to find the
397 fd to send output to.
399 Exactly analogous actions are undertaken for the XML output
400 channel, with the one difference that the default fd is -1, meaning
401 the channel is disabled by default.
402 */
403 static
407 {
408 // VG_(clo_log_fd) is used by all the messaging. It starts as 2 (stderr)
409 // and we cannot change it until we know what we are changing it to is
410 // ok. So we have tmp_log_fd to hold the tmp fd prior to that point.
411 SysRes sres;
416 VgLogTo_Fd,
417 VgLogTo_File,
418 VgLogTo_Socket
422 /* Temporarily holds the string STR specified with
423 --{log,xml}-{name,socket}=STR. 'fs' stands for
424 file-or-socket. */
428 /* Whether the user has explicitly provided --sigill-diagnostics.
429 If not explicitly given depends on general verbosity setting. */
432 /* Log to stderr by default, but usage message goes to stdout. XML
433 output is initially disabled. */
437 /* Check for sane path in ./configure --prefix=... */
444 /* BEGIN command-line processing loop */
451 // Look for a colon in the option name.
453 colon++;
455 // Does it have the form "--toolname:foo"? We have to do it at the start
456 // in case someone has combined a prefix with a core-specific option,
457 // eg. "--memcheck:verbose".
462 {
463 // Prefix matches, convert "--toolname:foo" to "--foo".
464 // Two things to note:
465 // - We cannot modify the option in-place. If we did, and then
466 // a child was spawned with --trace-children=yes, the
467 // now-non-prefixed option would be passed and could screw up
468 // the child.
469 // - We create copies, and never free them. Why? Non-prefixed
470 // options hang around forever, so tools need not make copies
471 // of strings within them. We need to have the same behaviour
472 // for prefixed options. The pointer to the copy will be lost
473 // once we leave this function (although a tool may keep a
474 // pointer into it), but the space wasted is insignificant.
475 // (In bug #142197, the copies were being freed, which caused
476 // problems for tools that reasonably assumed that arguments
477 // wouldn't disappear on them.)
485 // prefix doesn't match, skip to next arg
487 }
488 }
490 /* Ignore these options - they've already been handled */
503 /* Obsolete options. Report an error and exit */
509 }
516 }
518 // These options are new.
537 /* automatically updates register values at each insn
538 with --vgdb=full */
541 }
548 }
551 }
575 else
578 }
585 True) {}
587 True) {}
602 VG_DEEPEST_BACKTRACE) {}
608 VG_DEEPEST_BACKTRACE) {}
611 Vg_SmcNone);
613 Vg_SmcStack);
615 Vg_SmcAll);
618 Vg_SmcAllNonFile);
636 VexRegUpdSpAtMemAccess);
640 VexRegUpdUnwindregsAtMemAccess);
644 VexRegUpdAllregsAtMemAccess);
648 VexRegUpdAllregsAtEachInsn);
661 }
665 }
669 }
672 }
676 }
679 }
695 }
698 }
705 }
708 }
718 }
719 /* String needs to be of the form C?*C?*, where C is any
720 character, but is the same both times. Having it in this
721 form facilitates finding the boundary between the sopatt
722 and the fnpatt just by looking for the second occurrence
723 of C, without hardwiring any assumption about what C
724 is. */
734 }
738 }
741 }
743 /* "stuvwxyz" --> stuvwxyz (binary) */
745 Int j;
749 }
756 }
757 }
758 }
764 /* "stuvwxyz" --> stuvwxyz (binary) */
766 Int j;
770 }
777 }
778 }
780 }
800 }
801 }
803 /* END command-line processing loop */
805 /* Determine the path prefix for vgdb */
809 /* Make VEX control parameters sane */
819 /* Check various option values */
829 /* [] */
833 /* [0 .. notabove] */
835 }
838 /* [notbelow .. ] */
841 /* [notbelow .. notabove] */
842 }
843 }
852 }
854 /* If XML output is requested, check that the tool actually
855 supports it. */
860 /*NOTREACHED*/
861 }
866 /* If we've been asked to emit XML, mash around various other
867 options so as to constrain the output somewhat, and to remove
868 any need for user input during the run.
869 */
872 /* We can't allow --gen-suppressions=yes, since that requires us
873 to print the error and then ask the user if she wants a
874 suppression for it, but in XML mode we won't print it until
875 we know whether we also need to print a suppression. Hence a
876 circular dependency. So disallow this.
877 (--gen-suppressions=all is still OK since we don't need any
878 user interaction in this case.) */
883 "or --gen-suppressions=all is allowed, but not "
885 }
887 /* We can't allow DB attaching (or we maybe could, but results
888 could be chaotic ..) since it requires user input. Hence
889 disallow. */
895 }
897 /* Disallow dump_error in XML mode; sounds like a recipe for
898 chaos. No big deal; dump_error is a flag for debugging V
899 itself. */
902 }
904 /* Disable error limits (this might be a bad idea!) */
906 /* Disable emulation warnings */
908 /* Also, we want to set options for the leak checker, but that
909 will have to be done in Memcheck's flag-handling code, not
910 here. */
911 }
913 /* All non-logging-related options have been checked. If the logging
914 option specified is ok, we can switch to it, as we know we won't
915 have to generate any other command-line-related error messages.
916 (So far we should be still attached to stderr, so we can show on
917 the terminal any problems to do with processing command line
918 opts.)
920 So set up logging now. After this is done, VG_(log_output_sink)
921 and (if relevant) VG_(xml_output_sink) should be connected to
922 whatever sink has been selected, and we indiscriminately chuck
923 stuff into it without worrying what the nature of it is. Oh the
924 wonder of Unix streams. */
934 /* --- set up the normal text output channel --- */
948 // Nb: we overwrite an existing file of this name without asking
949 // any questions.
951 log_fsname_unexpanded);
962 /*NOTREACHED*/
963 }
965 }
973 log_fsname_unexpanded);
975 /*NOTREACHED*/
976 }
980 log_fsname_unexpanded );
982 /* We don't change anything here. */
988 }
990 }
991 }
993 /* --- set up the XML output channel --- */
1007 // Nb: we overwrite an existing file of this name without asking
1008 // any questions.
1010 xml_fsname_unexpanded);
1017 /* strdup here is probably paranoid overkill, but ... */
1019 xml_fsname_unexpanded );
1024 /*NOTREACHED*/
1025 }
1027 }
1035 xml_fsname_unexpanded );
1037 /*NOTREACHED*/
1038 }
1042 xml_fsname_unexpanded);
1043 /* We don't change anything here. */
1049 }
1051 }
1052 }
1054 /* If we've got this far, and XML mode was requested, but no XML
1055 output channel appears to have been specified, just stop. We
1056 could continue, and XML output will simply vanish into nowhere,
1057 but that is likely to confuse the hell out of users, which is
1058 distinctly Ungood. */
1065 );
1066 }
1068 // Finalise the output fds: the log fd ..
1071 // Move log_fd into the safe range, so it doesn't conflict with
1072 // any app fds.
1082 }
1084 // If they said --log-fd=-1, don't print anything. Plausible for use in
1085 // regression testing suites that use client requests to count errors.
1088 }
1090 // Finalise the output fds: and the XML fd ..
1093 // Move xml_fd into the safe range, so it doesn't conflict with
1094 // any app fds.
1104 }
1106 // If they said --xml-fd=-1, don't print anything. Plausible for use in
1107 // regression testing suites that use client requests to count errors.
1110 }
1112 // Suppressions related stuff
1116 /* If we haven't reached the max number of suppressions, load
1117 the default one. */
1124 }
1127 }
1129 // Write the name and value of log file qualifiers to the xml file.
1131 {
1136 // We saw a '%'. What's next...
1137 i++;
1139 i++;
1141 // Get the env var name, print its contents.
1144 i++;
1148 // Temporarily replace the '}' with NUL to extract var
1149 // name.
1153 }
1154 i++;
1155 }
1158 "<logfilequalifier> <var>%pS</var> "
1160 qualname,qual
1161 );
1163 i++;
1164 }
1165 }
1167 i++;
1168 }
1169 }
1170 }
1173 /*====================================================================*/
1174 /*=== Printing the preamble ===*/
1175 /*====================================================================*/
1177 // Print the argument, escaping any chars that require it.
1179 {
1182 Int i;
1186 }
1188 }
1189 }
1191 // Send output to the XML-stream and escape any XML meta-characters.
1193 {
1195 }
1197 /* Ok, the logging sink is running now. Print a suitable preamble.
1198 If logging to file or a socket, write details of parent PID and
1199 command line args, to help people trying to interpret the
1200 results of a run which encompasses multiple processes. */
1204 {
1205 Int i;
1226 }
1233 /* Tool details */
1235 xpre,
1241 xpost );
1246 xpre, xpost
1247 );
1248 }
1253 /* Core details */
1257 );
1259 // Print the command line. At one point we wrapped at 80 chars and
1260 // printed a '\' as a line joiner, but that makes it hard to cut and
1261 // paste the command line (because of the "==pid==" prefixes), so we now
1262 // favour utility and simplicity over aesthetics.
1271 }
1276 }
1278 // Print the parent PID, and other stuff, if necessary.
1281 }
1282 else
1291 /* Note: the user comment itself is XML and is therefore to
1292 be passed through verbatim (%s) rather than escaped
1293 (%pS). */
1296 }
1304 else
1311 );
1312 }
1323 );
1324 }
1328 }
1330 // Last thing in the preamble is a blank line.
1336 # if defined(VGO_darwin) && DARWIN_VERS == DARWIN_10_8
1337 /* Uh, this doesn't play nice with XML output. */
1343 # endif
1346 SysRes fd;
1347 VexArch vex_arch;
1348 VexArchInfo vex_archinfo;
1356 }
1363 # define BUF_LEN 256
1372 }
1374 # undef BUF_LEN
1375 }
1379 Vg_DebugMsg,
1383 );
1385 Vg_DebugMsg,
1388 );
1391 }
1392 }
1395 /*====================================================================*/
1396 /*=== File descriptor setup ===*/
1397 /*====================================================================*/
1399 /* Number of file descriptors that Valgrind tries to reserve for
1400 it's own use - just a small constant. */
1401 #define N_RESERVED_FDS (10)
1404 {
1408 /* Get the current file descriptor limits. */
1412 }
1414 # if defined(VGO_darwin)
1415 /* Darwin lies. It reports file max as RLIM_INFINITY but
1416 silently disallows anything bigger than 10240. */
1419 }
1420 # endif
1426 /* Work out where to move the soft limit to. */
1431 }
1433 /* Reserve some file descriptors for our use. */
1437 /* Update the soft limit. */
1445 }
1449 }
1452 /*====================================================================*/
1453 /*=== main() ===*/
1454 /*====================================================================*/
1456 /* When main() is entered, we should be on the following stack, not
1457 the one the kernel gave us. We will run on this stack until
1458 simulation of the root thread is started, at which point a transfer
1459 is made to a dynamically allocated stack. This is for the sake of
1460 uniform overflow detection for all Valgrind threads. This is
1461 marked global even though it isn't, because assembly code below
1462 needs to reference the name. */
1466 /* These are the structures used to hold info for creating the initial
1467 client image.
1469 'iicii' mostly holds important register state present at system
1470 startup (_start_valgrind). valgrind_main() then fills in the rest
1471 of it and passes it to VG_(ii_create_image)(). That produces
1472 'iifii', which is later handed to VG_(ii_finalise_image). */
1474 /* In all OS-instantiations, the_iicii has a field .sp_at_startup.
1475 This should get some address inside the stack on which we gained
1476 control (eg, it could be the SP at startup). It doesn't matter
1477 exactly where in the stack it is. This value is passed to the
1478 address space manager at startup. On Linux, aspacem then uses it
1479 to identify the initial stack segment and hence the upper end of
1480 the usable address space. */
1486 /* A simple pair structure, used for conveying debuginfo handles to
1487 calls to VG_TRACK(new_mem_startup, ...). */
1491 /* --- Forwards decls to do with shutdown --- */
1495 /* Do everything which needs doing when the last thread exits */
1496 static
1498 VgSchedReturnCode tids_schedretcode );
1500 /* --- end of Forwards decls to do with shutdown --- */
1503 /* By the time we get to valgrind_main, the_iicii should already have
1504 been filled in with any important details as required by whatever
1505 OS we have been built for.
1506 */
1507 static
1509 {
1519 //============================================================
1520 //
1521 // Nb: startup is complex. Prerequisites are shown at every step.
1522 // *** Be very careful when messing with the order ***
1523 //
1524 // The first order of business is to get debug logging, the address
1525 // space manager and the dynamic memory manager up and running.
1526 // Once that's done, we can relax a bit.
1527 //
1528 //============================================================
1530 /* This is needed to make VG_(getenv) usable early. */
1533 //--------------------------------------------------------------
1534 // Start up Mach kernel interface, if any
1535 // p: none
1536 //--------------------------------------------------------------
1537 # if defined(VGO_darwin)
1539 # endif
1541 //--------------------------------------------------------------
1542 // Start up the logging mechanism
1543 // p: none
1544 //--------------------------------------------------------------
1545 /* Start the debugging-log system ASAP. First find out how many
1546 "-d"s were specified. This is a pre-scan of the command line. Also
1547 get --profile-heap=yes, --core-redzone-size, --redzone-size
1548 --aspace-minaddr which are needed by the time we start up dynamic
1549 memory management. */
1562 # if VG_WORDSIZE == 4
1564 # else
1566 # endif
1575 "Must be a page aligned address between "
1577 }
1578 }
1580 /* ... and start the debug logger. Now we can safely emit logging
1581 messages all through startup. */
1586 //--------------------------------------------------------------
1587 // Ensure we're on a plausible stack.
1588 // p: logging
1589 //--------------------------------------------------------------
1595 /* Re "volatile": Apple clang version 4.0
1596 (tags/Apple/clang-421.0.57) (based on LLVM 3.1svn)" appeared
1597 to miscompile the following check, causing run to abort at
1598 this point (in 64-bit mode) even though aLocal is within limLo
1599 .. limHi. But in fact clang is within its rights to do
1600 strange things here. "The reason is that the comparisons
1601 aLocal < limLo and aLocal >= limHi cause undefined behaviour
1602 (according to c99 6.5.8) because they compare pointers that do
1603 not point into the same aggregate." Adding "volatile" appears
1604 to fix it because "The compiler would have to prove that there
1605 is undefined behavior in order to exploit it. But as a
1606 volatile variable can change its value in ways invisible to
1607 the compiler, the compiler must make the conservative
1608 assumption that it points into the same aggregate as the other
1609 pointer its compared against. I.e. the behaviour is possibly
1610 defined." (Analysis by Florian Krohm). */
1612 /* something's wrong. Stop. */
1619 }
1620 }
1622 //--------------------------------------------------------------
1623 // Ensure we have a plausible pointer to the stack on which
1624 // we gained control (not the current stack!)
1625 // p: logging
1626 //--------------------------------------------------------------
1633 }
1635 //--------------------------------------------------------------
1636 // Start up the address space manager, and determine the
1637 // approximate location of the client's stack
1638 // p: logging, plausible-stack
1639 //--------------------------------------------------------------
1651 //--------------------------------------------------------------
1652 // Start up the dynamic memory manager
1653 // p: address space management
1654 // p: getting --profile-heap,--core-redzone-size,--redzone-size
1655 // In fact m_mallocfree is self-initialising, so there's no
1656 // initialisation call to do. Instead, try a simple malloc/
1657 // free pair right now to check that nothing is broken.
1658 //--------------------------------------------------------------
1662 }
1665 //============================================================
1666 //
1667 // Dynamic memory management is now available.
1668 //
1669 //============================================================
1671 //--------------------------------------------------------------
1672 // Initialise m_debuginfo
1673 // p: dynamic memory allocation
1677 //--------------------------------------------------------------
1678 // Look for alternative libdir
1683 }
1685 //--------------------------------------------------------------
1686 // Extract the launcher name from the environment.
1693 }
1696 //--------------------------------------------------------------
1697 // Get the current process datasize rlimit, and set it to zero.
1698 // This prevents any internal uses of brk() from having any effect.
1699 // We remember the old value so we can restore it on exec, so that
1700 // child processes will have a reasonable brk value.
1705 // Get the current process stack rlimit.
1708 //--------------------------------------------------------------
1709 // Figure out what sort of CPU we're on, and whether it is
1710 // able to run V.
1713 VexArchInfo vex_archinfo;
1727 }
1733 );
1734 }
1736 //--------------------------------------------------------------
1737 // Record the working directory at startup
1738 // p: none
1744 }
1750 }
1752 //============================================================
1753 // Command line argument handling order:
1754 // * If --help/--help-debug are present, show usage message
1755 // (including the tool-specific usage)
1756 // * (If no --tool option given, default to Memcheck)
1757 // * Then, if client is missing, abort with error msg
1758 // * Then, if any cmdline args are bad, abort with error msg
1759 //============================================================
1761 //--------------------------------------------------------------
1762 // Split up argv into: C args, V args, V extra args, and exename.
1763 // p: dynamic memory allocation
1764 //--------------------------------------------------------------
1774 );
1780 );
1781 }
1783 //--------------------------------------------------------------
1784 // Extract tool name and whether help has been requested.
1785 // Note we can't print the help message yet, even if requested,
1786 // because the tool has not been initialised.
1787 // p: split_up_argv [for VG_(args_for_valgrind)]
1788 //--------------------------------------------------------------
1793 // Set default vex control params
1796 //--------------------------------------------------------------
1797 // Load client executable, finding in $PATH if necessary
1798 // p: early_process_cmd_line_options() [for 'exec', 'need_help',
1799 // clo_max_stackframe,
1800 // clo_main_stacksize]
1801 // p: layout_remaining_space [so there's space]
1802 //
1803 // Set up client's environment
1804 // p: set-libdir [for VG_(libdir)]
1805 // p: early_process_cmd_line_options [for toolname]
1806 //
1807 // Setup client stack, eip, and VG_(client_arg[cv])
1808 // p: load_client() [for 'info']
1809 // p: fix_environment() [for 'env']
1810 //
1811 // Setup client data (brk) segment. Initially a 1-page segment
1812 // which abuts a shrinkable reservation.
1813 // p: load_client() [for 'info' and hence VG_(brk_base)]
1814 //
1815 // p: _start_in_C (for zeroing out the_iicii and putting some
1816 // initial values into it)
1817 //--------------------------------------------------------------
1821 # if defined(VGO_linux) || defined(VGO_darwin)
1825 # else
1827 # endif
1829 /* NOTE: this call reads VG_(clo_main_stacksize). */
1831 }
1833 //==============================================================
1834 //
1835 // Finished loading/setting up the client address space.
1836 //
1837 //==============================================================
1839 //--------------------------------------------------------------
1840 // setup file descriptors
1841 // p: n/a
1842 //--------------------------------------------------------------
1846 //--------------------------------------------------------------
1847 // create fake /proc/<pid>/cmdline and /proc/<pid>/auxv files
1848 // and then unlink them, but hold onto the fds, so we can handr
1849 // them out to the client when it tries to open
1850 // /proc/<pid>/cmdline or /proc/<pid>/auxv for itself.
1851 // p: setup file descriptors
1852 // p: ii_create_image for VG_(client_auxv) setup.
1853 //--------------------------------------------------------------
1854 #if !defined(VGO_linux)
1855 // client shouldn't be using /proc!
1858 #else
1882 }
1884 /* Don't bother to seek the file back to the start; instead do
1885 it every time a copy of it is given out (by PRE(sys_open)).
1886 That is probably more robust across fork() etc. */
1888 /* Now delete it, but hang on to the fd. */
1905 client_auxv++;
1906 client_auxv++;
1908 }
1913 /* Don't bother to seek the file back to the start; instead do
1914 it every time a copy of it is given out (by PRE(sys_open)).
1915 That is probably more robust across fork() etc. */
1917 /* Now delete it, but hang on to the fd. */
1923 }
1924 #endif
1926 //--------------------------------------------------------------
1927 // Init tool part 1: pre_clo_init
1928 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
1929 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
1930 //--------------------------------------------------------------
1934 //--------------------------------------------------------------
1935 // If --tool and --help/--help-debug was given, now give the core+tool
1936 // help message
1937 // p: early_process_cmd_line_options() [for 'need_help']
1938 // p: tl_pre_clo_init [for 'VG_(tdict).usage']
1939 //--------------------------------------------------------------
1943 }
1945 //--------------------------------------------------------------
1946 // Process command line options to Valgrind + tool
1947 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
1948 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
1949 //--------------------------------------------------------------
1951 "(main_) Process Valgrind's command line options, "
1954 toolname );
1956 //--------------------------------------------------------------
1957 // Zeroise the millisecond counter by doing a first read of it.
1958 // p: none
1959 //--------------------------------------------------------------
1962 //--------------------------------------------------------------
1963 // Print the preamble
1964 // p: tl_pre_clo_init [for 'VG_(details).name' and friends]
1965 // p: main_process_cmd_line_options()
1966 // [for VG_(clo_verbosity), VG_(clo_xml),
1967 // logging_to_fd, xml_fname_unexpanded]
1968 //--------------------------------------------------------------
1973 //--------------------------------------------------------------
1974 // Init tool part 2: post_clo_init
1975 // p: setup_client_stack() [for 'VG_(client_arg[cv]']
1976 // p: setup_file_descriptors() [for 'VG_(fd_xxx_limit)']
1977 // p: print_preamble() [so any warnings printed in post_clo_init
1978 // are shown after the preamble]
1979 //--------------------------------------------------------------
1982 {
1983 /* The tool's "needs" will by now be finalised, since it has no
1984 further opportunity to specify them. So now sanity check
1985 them. */
1987 Bool ok;
1991 }
1992 }
1994 //--------------------------------------------------------------
1995 // Initialise translation table and translation cache
1996 // p: aspacem [??]
1997 // p: tl_pre_clo_init [for 'VG_(details).avg_translation_sizeB']
1998 //--------------------------------------------------------------
2002 //--------------------------------------------------------------
2003 // Initialise the redirect table.
2004 // p: init_tt_tc [so it can call VG_(search_transtab) safely]
2005 // p: aspacem [so can change ownership of sysinfo pages]
2006 //--------------------------------------------------------------
2010 //--------------------------------------------------------------
2011 // Allow GDB attach
2012 // p: main_process_cmd_line_options() [for VG_(clo_wait_for_gdb)]
2013 //--------------------------------------------------------------
2014 /* Hook to delay things long enough so we can get the pid and
2015 attach GDB in another shell. */
2021 # if defined(VGP_x86_linux)
2023 # elif defined(VGP_amd64_linux) || defined(VGP_ppc64_linux)
2025 # elif defined(VGP_ppc32_linux)
2027 # elif defined(VGP_arm_linux)
2029 # elif defined(VGP_arm64_linux)
2031 # elif defined(VGP_s390x_linux)
2033 # elif defined(VGP_mips32_linux) || defined(VGP_mips64_linux)
2035 # elif defined(VGO_darwin)
2037 # else
2039 # endif
2044 }
2046 //--------------------------------------------------------------
2047 // Search for file descriptors that are inherited from our parent
2048 // p: main_process_cmd_line_options [for VG_(clo_track_fds)]
2049 //--------------------------------------------------------------
2053 }
2055 //--------------------------------------------------------------
2056 // Load debug info for the existing segments.
2057 // p: setup_code_redirect_table [so that redirs can be recorded]
2058 // p: mallocfree
2059 // p: probably: setup fds and process CLOs, so that logging works
2060 // p: initialise m_debuginfo
2061 //
2062 // While doing this, make a note of the debuginfo-handles that
2063 // come back from VG_(di_notify_mmap).
2064 // Later, in "Tell the tool about the initial client memory permissions"
2065 // (just below) we can then hand these handles off to the tool in
2066 // calls to VG_TRACK(new_mem_startup, ...). This gives the tool the
2067 // opportunity to make further queries to m_debuginfo before the
2068 // client is started, if it wants. We put this information into an
2069 // XArray, each handle along with the associated segment start address,
2070 // and search the XArray for the handles later, when calling
2071 // VG_TRACK(new_mem_startup, ...).
2072 //--------------------------------------------------------------
2080 # if defined(VGO_linux)
2082 Int n_seg_starts;
2083 Addr_n_ULong anu;
2088 /* show them all to the debug info reader. allow_SkFileV has to
2089 be True here so that we read info from the valgrind executable
2090 itself. */
2094 /* anu.ull holds the debuginfo handle returned by di_notify_mmap,
2095 if any. */
2099 }
2100 }
2103 }
2104 # elif defined(VGO_darwin)
2106 Int n_seg_starts;
2110 /* show them all to the debug info reader.
2111 Don't read from V segments (unlike Linux) */
2112 // GrP fixme really?
2116 }
2119 }
2120 # else
2121 # error Unknown OS
2122 # endif
2124 //--------------------------------------------------------------
2125 // Tell aspacem of ownership change of the asm helpers, so that
2126 // m_translate allows them to be translated. However, only do this
2127 // after the initial debug info read, since making a hole in the
2128 // address range for the stage2 binary confuses the debug info reader.
2129 // p: aspacem
2130 //--------------------------------------------------------------
2138 change_ownership_v_c_OK
2141 }
2150 buf );
2152 }
2156 //--------------------------------------------------------------
2157 // Initialise the scheduler (phase 1) [generates tid_main]
2158 // p: none, afaics
2159 //--------------------------------------------------------------
2164 /* Tell the tool about tid_main */
2167 //--------------------------------------------------------------
2168 // Tell the tool about the initial client memory permissions
2169 // p: aspacem
2170 // p: mallocfree
2171 // p: setup_client_stack
2172 // p: setup_client_dataseg
2173 //
2174 // For each segment we tell the client about, look up in
2175 // addr2dihandle as created above, to see if there's a debuginfo
2176 // handle associated with the segment, that we can hand along
2177 // to the tool, to be helpful.
2178 //--------------------------------------------------------------
2181 Int n_seg_starts;
2185 /* Mark the main thread as running while we tell the tool about
2186 the client memory so that the tool can associate that memory
2187 with the main thread. */
2194 /* show interesting ones to the tool */
2201 /* This next assertion is tricky. If it is placed
2202 immediately before this 'if', it very occasionally fails.
2203 Why? Because previous iterations of the loop may have
2204 caused tools (via the new_mem_startup calls) to do
2205 dynamic memory allocation, and that may affect the mapped
2206 segments; in particular it may cause segment merging to
2207 happen. Hence we cannot assume that seg_starts[i], which
2208 reflects the state of the world before we started this
2209 loop, is the same as seg->start, as the latter reflects
2210 the state of the world (viz, mappings) at this particular
2211 iteration of the loop.
2213 Why does moving it inside the 'if' make it safe? Because
2214 any dynamic memory allocation done by the tools will
2215 affect only the state of Valgrind-owned segments, not of
2216 Client-owned segments. And the 'if' guards against that
2217 -- we only get in here for Client-owned segments.
2219 In other words: the loop may change the state of
2220 Valgrind-owned segments as it proceeds. But it should
2221 not cause the Client-owned segments to change. */
2229 /* search addr2dihandle to see if we have an entry
2230 matching seg->start. */
2237 }
2238 }
2242 /* and the retrieved debuginfo handle, if any */
2243 j < n
2246 }
2247 }
2252 /* Also do the initial stack permissions. */
2253 {
2254 SSizeT inaccessible_len;
2262 /* Stuff below the initial SP is unaddressable. Take into
2263 account any ABI-mandated space below the stack pointer that
2264 is required (VG_STACK_REDZONE_SZB). setup_client_stack()
2265 will have allocated an extra page if a red zone is required,
2266 to be on the safe side. */
2273 inaccessible_len );
2277 }
2279 /* Also the assembly helpers. */
2289 /* Clear the running thread indicator */
2292 }
2294 //--------------------------------------------------------------
2295 // Initialise the scheduler (phase 2)
2296 // p: Initialise the scheduler (phase 1) [for tid_main]
2297 // p: setup_file_descriptors() [else VG_(safe_fd)() breaks]
2298 // p: setup_client_stack
2299 //--------------------------------------------------------------
2309 }
2311 //--------------------------------------------------------------
2312 // Set up state for the root thread
2313 // p: ?
2314 // setup_scheduler() [for sched-specific thread 1 stuff]
2315 // VG_(ii_create_image) [for 'the_iicii' initial info]
2316 //--------------------------------------------------------------
2320 //--------------------------------------------------------------
2321 // Initialise the signal handling subsystem
2322 // p: n/a
2323 //--------------------------------------------------------------
2324 // Nb: temporarily parks the saved blocking-mask in saved_sigmask.
2326 /* Check that the kernel-interface signal definitions look sane */
2328 /* .. and go on to use them. */
2331 //--------------------------------------------------------------
2332 // Read suppression file
2333 // p: main_process_cmd_line_options() [for VG_(clo_suppressions)]
2334 //--------------------------------------------------------------
2338 }
2340 //--------------------------------------------------------------
2341 // register client stack
2342 //--------------------------------------------------------------
2345 //--------------------------------------------------------------
2346 // Show the address space state so far
2347 //--------------------------------------------------------------
2354 //--------------------------------------------------------------
2355 // Run!
2356 //--------------------------------------------------------------
2359 /* As a result of the following call, the last thread standing
2360 eventually winds up running shutdown_actions_NORETURN
2361 just below. Unfortunately, simply exporting said function
2362 causes m_main to be part of a module cycle, which is pretty
2363 nonsensical. So instead of doing that, the address of said
2364 function is stored in a global variable 'owned' by m_syswrap,
2365 and it uses that function pointer to get back here when it needs
2366 to. */
2368 /* Set continuation address. */
2372 /* Run the first thread, eventually ending up at the continuation
2373 address. */
2376 /*NOTREACHED*/
2378 }
2380 /* Do everything which needs doing when the last thread exits or when
2381 a thread exits requesting a complete process exit.
2383 We enter here holding The Lock. For the case VgSrc_ExitProcess we
2384 must never release it, because to do so would allow other threads
2385 to continue after the system is ostensibly shut down. So we must
2386 go to our grave, so to speak, holding the lock.
2388 In fact, there is never any point in releasing the lock at this
2389 point - we have it, we're shutting down the entire system, and
2390 for the case VgSrc_ExitProcess doing so positively causes trouble.
2391 So don't.
2393 The final_tidyup call makes a bit of a nonsense of the ExitProcess
2394 case, since it will run the libc_freeres function, thus allowing
2395 other lurking threads to run again. Hmm. */
2397 static
2399 VgSchedReturnCode tids_schedretcode )
2400 {
2412 // We are the last surviving thread. Right?
2415 // Wait for all other threads to exit.
2416 // jrs: Huh? but they surely are already gone
2419 // Clean the client up before the final report
2420 // this causes the libc_freeres function to run
2423 /* be paranoid */
2429 // We may not be the last surviving thread. However, we
2430 // want to shut down the entire process. We hold the lock
2431 // and we need to keep hold of it all the way out, in order
2432 // that none of the other threads ever run again.
2435 // Clean the client up before the final report
2436 // this causes the libc_freeres function to run
2437 // perhaps this is unsafe, as per comment above
2440 /* be paranoid */
2443 }
2445 /* Final call to gdbserver, if requested. */
2449 }
2452 //--------------------------------------------------------------
2453 // Finalisation: cleanup, messages, etc. Order not so important, only
2454 // affects what order the messages come.
2455 //--------------------------------------------------------------
2456 // First thing in the post-amble is a blank line.
2470 buf);
2471 }
2473 /* Print out file descriptor summary and stats. */
2477 /* Call the tool's finalisation function. This makes Memcheck's
2478 leak checker run, and possibly chuck a bunch of leak errors into
2479 the error management machinery. */
2482 /* Show the error counts. */
2486 }
2488 /* In XML mode, this merely prints the used suppressions. */
2496 }
2504 /* Show a profile of the heap(s) at shutdown. Optionally, first
2505 throw away all the debug info, as that makes it easy to spot
2506 leaks in the debuginfo reader. */
2510 }
2512 /* If profiling has been requested, but with zero interval, it
2513 means "profile at the end of the run only". In which case we
2514 need to dump the profile now. */
2517 }
2519 /* Print Vex storage stats */
2523 /* Flush any output cached by previous calls to VG_(message). */
2526 /* Terminate gdbserver if ever it was started. We terminate it here
2527 so that it get the output above if output was redirected to
2528 gdb */
2531 /* Ok, finally exit in the os-specific way, according to the scheduler's
2532 return code. In short, if the (last) thread exited by calling
2533 sys_exit, do likewise; if the (last) thread stopped due to a fatal
2534 signal, terminate the entire system with that same fatal signal. */
2541 /* Change the application return code to user's return code,
2542 if an error was found */
2547 /* otherwise, return the client's exit code, in the normal
2548 way. */
2550 }
2551 /* NOT ALIVE HERE! */
2556 /* We were killed by a fatal signal, so replicate the effect */
2559 /* we shouldn't be alive at this point. But VG_(kill_self)
2560 sometimes fails with EPERM on Darwin, for unclear reasons. */
2561 # if defined(VGO_darwin)
2564 /* fall through .. */
2565 # endif
2571 }
2572 }
2574 /* -------------------- */
2576 /* Final clean-up before terminating the process.
2577 Clean up the client by calling __libc_freeres() (if requested)
2578 This is Linux-specific?
2579 GrP fixme glibc-specific, anyway
2580 */
2582 {
2583 #if !defined(VGO_darwin)
2584 # if defined(VGP_ppc64_linux)
2585 Addr r2;
2586 # endif
2596 # if defined(VGP_ppc64_linux)
2604 }
2605 # endif
2613 /* set thread context to point to libc_freeres_wrapper */
2614 /* ppc64-linux note: __libc_freeres_wrapper gives us the real
2615 function entry point, not a fn descriptor, so can use it
2616 directly. However, we need to set R2 (the toc pointer)
2617 appropriately. */
2619 # if defined(VGP_ppc64_linux)
2621 # endif
2622 /* mips-linux note: we need to set t9 */
2623 # if defined(VGP_mips32_linux) || defined(VGP_mips64_linux)
2625 # endif
2627 /* Block all blockable signals by copying the real block state into
2628 the thread's block state*/
2632 /* and restore handlers to default */
2638 // We were exiting, so assert that...
2640 // ...but now we're not again
2643 // run until client thread exits - ideally with LIBC_FREERES_DONE,
2644 // but exit/exitgroup/signal will do
2648 #endif
2649 }
2652 /*====================================================================*/
2653 /*=== Getting to main() alive: LINUX ===*/
2654 /*====================================================================*/
2656 #if defined(VGO_linux)
2658 /* If linking of the final executables is done with glibc present,
2659 then Valgrind starts at main() above as usual, and all of the
2660 following code is irrelevant.
2662 However, this is not the intended mode of use. The plan is to
2663 avoid linking against glibc, by giving gcc the flags
2664 -nodefaultlibs -lgcc -nostartfiles at startup.
2666 From this derive two requirements:
2668 1. gcc may emit calls to memcpy, memmove and memset to deal with
2669 structure assignments etc. Since we have chosen to ignore all the
2670 "normal" supporting libraries, we have to provide our own
2671 implementations of them. No problem.
2673 2. We have to provide a symbol "_start", to which the kernel
2674 hands control at startup. Hence the code below.
2675 */
2677 /* ---------------- Requirement 1 ---------------- */
2682 }
2686 }
2690 }
2692 /* BVA: abort() for those platforms that need it (PPC and ARM). */
2697 }
2699 /* EAZG: ARM's EABI will call floating point exception handlers in
2700 libgcc which boil down to an abort or raise, that's usually defined
2701 in libc. Instead, define them here. */
2702 #if defined(VGP_arm_linux)
2707 }
2713 }
2719 }
2720 #endif
2722 /* ---------------- Requirement 2 ---------------- */
2724 /* Glibc's sysdeps/i386/elf/start.S has the following gem of a
2725 comment, which explains how the stack looks right at process start
2726 (when _start is jumped to). Hence _start passes %esp to
2727 _start_in_C_linux, which extracts argc/argv/envp and starts up
2728 correctly. */
2730 /* This is the canonical entry point, usually the first thing in the text
2731 segment. The SVR4/i386 ABI (pages 3-31, 3-32) says that when the entry
2732 point runs, most registers' values are unspecified, except for:
2734 %edx Contains a function pointer to be registered with `atexit'.
2735 This is how the dynamic linker arranges to have DT_FINI
2736 functions called for shared libraries that have been loaded
2737 before this code runs.
2739 %esp The stack contains the arguments and environment:
2740 0(%esp) argc
2741 4(%esp) argv[0]
2742 ...
2743 (4*argc)(%esp) NULL
2744 (4*(argc+1))(%esp) envp[0]
2745 ...
2746 NULL
2747 */
2749 /* The kernel hands control to _start, which extracts the initial
2750 stack pointer and calls onwards to _start_in_C_linux. This also switches
2751 the new stack. */
2752 #if defined(VGP_x86_linux)
2758 /* set up the new stack in %eax */
2764 /* install it, and collect the original one */
2766 /* call _start_in_C_linux, passing it the startup %esp */
2771 );
2772 #elif defined(VGP_amd64_linux)
2778 /* set up the new stack in %rdi */
2783 /* install it, and collect the original one */
2785 /* call _start_in_C_linux, passing it the startup %rsp */
2789 );
2790 #elif defined(VGP_ppc32_linux)
2796 /* set up the new stack in r16 */
2806 /* now r16 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2807 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2808 boundary. And r1 is the original SP. Set the SP to r16 and
2809 call _start_in_C_linux, passing it the initial SP. */
2815 );
2816 #elif defined(VGP_ppc64_linux)
2818 /* PPC64 ELF ABI says '_start' points to a function descriptor.
2819 So we must have one, and that is what goes into the .opd section. */
2830 /* set up the new stack in r16 */
2845 /* now r16 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2846 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2847 boundary. And r1 is the original SP. Set the SP to r16 and
2848 call _start_in_C_linux, passing it the initial SP. */
2861 );
2862 #elif defined(VGP_s390x_linux)
2863 /*
2864 This is the canonical entry point, usually the first thing in the text
2865 segment. Most registers' values are unspecified, except for:
2867 %r14 Contains a function pointer to be registered with `atexit'.
2868 This is how the dynamic linker arranges to have DT_FINI
2869 functions called for shared libraries that have been loaded
2870 before this code runs.
2872 %r15 The stack contains the arguments and environment:
2873 0(%r15) argc
2874 8(%r15) argv[0]
2875 ...
2876 (8*argc)(%r15) NULL
2877 (8*(argc+1))(%r15) envp[0]
2878 ...
2879 NULL
2880 */
2886 /* set up the new stack in %r1 */
2892 /* install it, and collect the original one */
2895 /* call _start_in_C_linux, passing it the startup %r15 */
2897 /* trigger execution of an invalid opcode -> halt machine */
2902 );
2903 #elif defined(VGP_arm_linux)
2924 );
2925 #elif defined(VGP_arm64_linux)
2934 // The next 2 assume that VG_STACK_GUARD_SZB fits in 32 bits
2939 // The next 2 assume that VG_STACK_ACTIVE_SZB fits in 32 bits
2949 );
2950 #elif defined(VGP_mips32_linux)
2966 /* t1/$9 <- Addr(interim_stack) */
2968 /* t1/$9 <- Addr(interim_stack) */
2979 /* now t1/$9 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
2980 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
2981 boundary. And $29 is the original SP. Set the SP to t1 and
2982 call _start_in_C, passing it the initial SP. */
2993 );
2994 #elif defined(VGP_mips64_linux)
3005 /* t1/$9 <- Addr(interim_stack) */
3015 /* now t1/$9 = &vgPlain_interim_stack + VG_STACK_GUARD_SZB +
3016 VG_STACK_ACTIVE_SZB rounded down to the nearest 16-byte
3017 boundary. And $29 is the original SP. Set the SP to t1 and
3018 call _start_in_C, passing it the initial SP. */
3032 );
3033 #else
3035 #endif
3037 /* --- !!! --- EXTERNAL HEADERS start --- !!! --- */
3038 #define _GNU_SOURCE
3039 #define _FILE_OFFSET_BITS 64
3040 /* This is in order to get AT_NULL and AT_PAGESIZE. */
3041 #include <elf.h>
3042 /* --- !!! --- EXTERNAL HEADERS end --- !!! --- */
3044 /* Avoid compiler warnings: this fn _is_ used, but labelling it
3045 'static' causes gcc to complain it isn't.
3046 attribute 'used' also ensures the code is not eliminated at link
3047 time */
3052 {
3053 Int r;
3058 // For an inner Valgrind, register the interim stack asap.
3059 // This is needed to allow the outer valgrind to do stacktraces during init.
3060 // Note that this stack is not unregistered when the main thread
3061 // is switching to the (real) stack. Unregistering this would imply
3062 // to save the stack id in a global variable, and have a "if"
3063 // in run_a_thread_NORETURN to do the unregistration only for the
3064 // main thread. This unregistration is not worth this complexity.
3065 INNER_REQUEST
3075 # if defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux) \
3076 || defined(VGP_arm64_linux)
3077 {
3078 /* ppc/ppc64 can be configured with different page sizes.
3079 Determine this early. This is an ugly hack and really should
3080 be moved into valgrind_main. */
3083 ;
3091 }
3092 }
3093 # endif
3096 /* NOTREACHED */
3098 }
3101 /*====================================================================*/
3102 /*=== Getting to main() alive: darwin ===*/
3103 /*====================================================================*/
3105 #elif defined(VGO_darwin)
3107 /*
3108 Memory layout established by kernel:
3110 0(%esp) argc
3111 4(%esp) argv[0]
3112 ...
3113 argv[argc-1]
3114 NULL
3115 envp[0]
3116 ...
3117 envp[n]
3118 NULL
3119 executable name (presumably, a pointer to it)
3120 NULL
3122 Ditto in the 64-bit case, except all offsets from SP are obviously
3123 twice as large.
3124 */
3126 /* The kernel hands control to _start, which extracts the initial
3127 stack pointer and calls onwards to _start_in_C_darwin. This also
3128 switches to the new stack. */
3129 #if defined(VGP_x86_darwin)
3135 /* set up the new stack in %eax */
3141 /* install it, and collect the original one */
3144 /* call _start_in_C_darwin, passing it the startup %esp */
3149 );
3150 #elif defined(VGP_amd64_darwin)
3156 /* set up the new stack in %rdi */
3161 /* install it, and collect the original one */
3163 /* call _start_in_C_darwin, passing it the startup %rsp */
3167 );
3168 #endif
3172 // skip check
3174 }
3177 // skip check
3179 }
3183 }
3188 }
3192 }
3194 /* Avoid compiler warnings: this fn _is_ used, but labelling it
3195 'static' causes gcc to complain it isn't. */
3198 {
3199 Int r;
3204 // See _start_in_C_linux
3205 INNER_REQUEST
3216 /* NOTREACHED */
3218 }
3221 #else
3224 #endif
3227 /*====================================================================*/
3228 /*=== {u,}{div,mod}di3 replacements ===*/
3229 /*====================================================================*/
3231 /* For static linking on x86-darwin, we need to supply our own 64-bit
3232 integer division code, else the link dies thusly:
3234 ld_classic: Undefined symbols:
3235 ___udivdi3
3236 ___umoddi3
3237 */
3238 #if defined(VGP_x86_darwin)
3240 /* Routines for doing signed/unsigned 64 x 64 ==> 64 div and mod
3241 (udivdi3, umoddi3, divdi3, moddi3) using only 32 x 32 ==> 32
3242 division. Cobbled together from
3244 http://www.hackersdelight.org/HDcode/divlu.c
3245 http://www.hackersdelight.org/HDcode/divls.c
3246 http://www.hackersdelight.org/HDcode/newCode/divDouble.c
3248 The code from those three files is covered by the following license,
3249 as it appears at:
3251 http://www.hackersdelight.org/permissions.htm
3253 You are free to use, copy, and distribute any of the code on
3254 this web site, whether modified by you or not. You need not give
3255 attribution. This includes the algorithms (some of which appear
3256 in Hacker's Delight), the Hacker's Assistant, and any code
3257 submitted by readers. Submitters implicitly agree to this.
3258 */
3260 /* Long division, unsigned (64/32 ==> 32).
3261 This procedure performs unsigned "long division" i.e., division of a
3262 64-bit unsigned dividend by a 32-bit unsigned divisor, producing a
3263 32-bit quotient. In the overflow cases (divide by 0, or quotient
3264 exceeds 32 bits), it returns a remainder of 0xFFFFFFFF (an impossible
3265 value).
3266 The dividend is u1 and u0, with u1 being the most significant word.
3267 The divisor is parameter v. The value returned is the quotient.
3268 Max line length is 57, to fit in hacker.book. */
3271 {
3272 Int n;
3281 }
3283 /* 64 x 32 ==> 32 unsigned division, using only 32 x 32 ==> 32
3284 division as a primitive. */
3286 {
3313 again1:
3323 again2:
3332 }
3335 /* 64 x 32 ==> 32 signed division, using only 32 x 32 ==> 32 division
3336 as a primitive. */
3338 {
3365 }
3369 /* This file contains a program for doing 64/64 ==> 64 division, on a
3370 machine that does not have that instruction but that does have
3371 instructions for "long division" (64/32 ==> 32). Code for unsigned
3372 division is given first, followed by a simple program for doing the
3373 signed version by using the unsigned version.
3374 These programs are useful in implementing "long long" (64-bit)
3375 arithmetic on a machine that has the long division instruction. It will
3376 work on 64- and 32-bit machines, provided the compiler implements long
3377 long's (64-bit integers). It is desirable that the machine have the
3378 Count Leading Zeros instruction.
3379 In the GNU world, these programs are known as __divdi3 and __udivdi3,
3380 and similar names are used here.
3381 This material is not in HD, but may be in a future edition.
3382 Max line length is 57, to fit in hacker.book. */
3386 {
3387 Int n;
3397 }
3399 // ---------------------------- udivdi3 --------------------------------
3401 /* The variables u0, u1, etc. take on only 32-bit values, but they
3402 are declared long long to avoid some compiler warning messages and to
3403 avoid some unnecessary EXTRs that the compiler would put in, to
3404 convert long longs to ints.
3406 First the procedure takes care of the case in which the divisor is a
3407 32-bit quantity. There are two subcases: (1) If the left half of the
3408 dividend is less than the divisor, one execution of DIVU is all that
3409 is required (overflow is not possible). (2) Otherwise it does two
3410 divisions, using the grade school method, with variables used as
3411 suggested below.
3413 q1 q0
3414 ________
3415 v) u1 u0
3416 q1*v
3417 ____
3418 k u0 */
3420 /* These macros must be used with arguments of the appropriate type
3421 (unsigned long long for DIVU and long long for DIVS. They are
3422 simulations of the presumed machines ops. I.e., they look at only the
3423 low-order 32 bits of the divisor, they return garbage if the division
3424 overflows, and they return garbage in the high-order half of the
3425 quotient doubleword.
3426 In practice, these would be replaced with uses of the machine's DIVU
3427 and DIVS instructions (e.g., by using the GNU "asm" facility). */
3430 {
3434 }
3437 {
3441 }
3443 /* 64 x 64 ==> 64 unsigned division, using only 32 x 32 ==> 32
3444 division as a primitive. */
3446 {
3462 }
3463 }
3464 // Here v >= 2**32.
3467 // so its MSB is 1.
3472 // division of u by 2.
3478 }
3481 // ----------------------------- divdi3 --------------------------------
3483 /* This routine presumes that smallish cases (those which can be done in
3484 one execution of DIVS) are common. If this is not the case, the test for
3485 this case should be deleted.
3486 Note that the test for when DIVS can be used is not entirely
3487 accurate. For example, DIVS is not used if v = 0xFFFFFFFF8000000,
3488 whereas if could be (if u is sufficiently small in magnitude). */
3490 // ------------------------------ cut ----------------------------------
3493 {
3496 }
3498 /* 64 x 64 ==> 64 signed division, using only 32 x 32 ==> 32 division
3499 as a primitive. */
3501 {
3507 // if (v << 32 >> 32 == v) { // If v is in range and
3511 }
3512 }
3516 }
3518 // ---------------------------- end cut --------------------------------
3522 {
3524 }
3528 {
3530 }
3534 {
3538 }
3542 {
3546 }
3548 /* ------------------------------------------------
3549 ld_classic: Undefined symbols:
3550 ___fixunsdfdi
3551 ------------------------------------------------
3552 */
3554 /* ===-- fixunsdfdi.c - Implement __fixunsdfdi -----------------------------===
3555 *
3556 * The LLVM Compiler Infrastructure
3557 *
3558 * This file is dual licensed under the MIT and the University of Illinois Open
3559 * Source Licenses. See LICENSE.TXT for details.
3560 *
3561 * ===----------------------------------------------------------------------===
3562 *
3563 * This file implements __fixunsdfdi for the compiler_rt library.
3564 *
3565 * ===----------------------------------------------------------------------===
3566 */
3568 /* As per http://www.gnu.org/licenses/license-list.html#GPLCompatibleLicenses,
3570 the "NCSA/University of Illinois Open Source License" is compatible
3571 with the GPL (both version 2 and 3). What is claimed to be
3572 compatible is this
3574 http://www.opensource.org/licenses/UoI-NCSA.php
3576 and the LLVM documentation at
3578 http://www.llvm.org/docs/DeveloperPolicy.html#license
3580 says all the code in LLVM is available under the University of
3581 Illinois/NCSA Open Source License, at this URL
3583 http://www.opensource.org/licenses/UoI-NCSA.php
3585 viz, the same one that the FSF pages claim is compatible. So I
3586 think it's OK to include it.
3587 */
3589 /* Returns: convert a to a unsigned long long, rounding toward zero.
3590 * Negative values all become zero.
3591 */
3593 /* Assumption: double is a IEEE 64 bit floating point type
3594 * du_int is a 64 bit integral type
3595 * value in double is representable in du_int or is negative
3596 * (no range checking performed)
3597 */
3599 /* seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm */
3605 {
3606 du_int all;
3607 struct
3608 {
3609 #if VG_LITTLEENDIAN
3610 su_int low;
3611 su_int high;
3612 #else
3613 su_int high;
3614 su_int low;
3620 {
3621 udwords u;
3627 du_int
3629 {
3630 double_bits fb;
3635 udwords r;
3640 else
3643 }
3646 #endif
3649 /*--------------------------------------------------------------------*/
3650 /*--- end ---*/
3651 /*--------------------------------------------------------------------*/