1This is gprof.info, produced by makeinfo version 6.5 from gprof.texi. 2 3This file documents the gprof profiler of the GNU system. 4 5 Copyright (C) 1988-2020 Free Software Foundation, Inc. 6 7 Permission is granted to copy, distribute and/or modify this document 8under the terms of the GNU Free Documentation License, Version 1.3 or 9any later version published by the Free Software Foundation; with no 10Invariant Sections, with no Front-Cover Texts, and with no Back-Cover 11Texts. A copy of the license is included in the section entitled "GNU 12Free Documentation License". 13 14INFO-DIR-SECTION Software development 15START-INFO-DIR-ENTRY 16* gprof: (gprof). Profiling your program's execution 17END-INFO-DIR-ENTRY 18 19 20File: gprof.info, Node: Top, Next: Introduction, Up: (dir) 21 22Profiling a Program: Where Does It Spend Its Time? 23************************************************** 24 25This manual describes the GNU profiler, 'gprof', and how you can use it 26to determine which parts of a program are taking most of the execution 27time. We assume that you know how to write, compile, and execute 28programs. GNU 'gprof' was written by Jay Fenlason. 29 30 This manual is for 'gprof' (GNU Binutils) version 2.34. 31 32 This document is distributed under the terms of the GNU Free 33Documentation License version 1.3. A copy of the license is included in 34the section entitled "GNU Free Documentation License". 35 36* Menu: 37 38* Introduction:: What profiling means, and why it is useful. 39 40* Compiling:: How to compile your program for profiling. 41* Executing:: Executing your program to generate profile data 42* Invoking:: How to run 'gprof', and its options 43 44* Output:: Interpreting 'gprof''s output 45 46* Inaccuracy:: Potential problems you should be aware of 47* How do I?:: Answers to common questions 48* Incompatibilities:: (between GNU 'gprof' and Unix 'gprof'.) 49* Details:: Details of how profiling is done 50* GNU Free Documentation License:: GNU Free Documentation License 51 52 53File: gprof.info, Node: Introduction, Next: Compiling, Prev: Top, Up: Top 54 551 Introduction to Profiling 56*************************** 57 58Profiling allows you to learn where your program spent its time and 59which functions called which other functions while it was executing. 60This information can show you which pieces of your program are slower 61than you expected, and might be candidates for rewriting to make your 62program execute faster. It can also tell you which functions are being 63called more or less often than you expected. This may help you spot 64bugs that had otherwise been unnoticed. 65 66 Since the profiler uses information collected during the actual 67execution of your program, it can be used on programs that are too large 68or too complex to analyze by reading the source. However, how your 69program is run will affect the information that shows up in the profile 70data. If you don't use some feature of your program while it is being 71profiled, no profile information will be generated for that feature. 72 73 Profiling has several steps: 74 75 * You must compile and link your program with profiling enabled. 76 *Note Compiling a Program for Profiling: Compiling. 77 78 * You must execute your program to generate a profile data file. 79 *Note Executing the Program: Executing. 80 81 * You must run 'gprof' to analyze the profile data. *Note 'gprof' 82 Command Summary: Invoking. 83 84 The next three chapters explain these steps in greater detail. 85 86 Several forms of output are available from the analysis. 87 88 The "flat profile" shows how much time your program spent in each 89function, and how many times that function was called. If you simply 90want to know which functions burn most of the cycles, it is stated 91concisely here. *Note The Flat Profile: Flat Profile. 92 93 The "call graph" shows, for each function, which functions called it, 94which other functions it called, and how many times. There is also an 95estimate of how much time was spent in the subroutines of each function. 96This can suggest places where you might try to eliminate function calls 97that use a lot of time. *Note The Call Graph: Call Graph. 98 99 The "annotated source" listing is a copy of the program's source 100code, labeled with the number of times each line of the program was 101executed. *Note The Annotated Source Listing: Annotated Source. 102 103 To better understand how profiling works, you may wish to read a 104description of its implementation. *Note Implementation of Profiling: 105Implementation. 106 107 108File: gprof.info, Node: Compiling, Next: Executing, Prev: Introduction, Up: Top 109 1102 Compiling a Program for Profiling 111*********************************** 112 113The first step in generating profile information for your program is to 114compile and link it with profiling enabled. 115 116 To compile a source file for profiling, specify the '-pg' option when 117you run the compiler. (This is in addition to the options you normally 118use.) 119 120 To link the program for profiling, if you use a compiler such as 'cc' 121to do the linking, simply specify '-pg' in addition to your usual 122options. The same option, '-pg', alters either compilation or linking 123to do what is necessary for profiling. Here are examples: 124 125 cc -g -c myprog.c utils.c -pg 126 cc -o myprog myprog.o utils.o -pg 127 128 The '-pg' option also works with a command that both compiles and 129links: 130 131 cc -o myprog myprog.c utils.c -g -pg 132 133 Note: The '-pg' option must be part of your compilation options as 134well as your link options. If it is not then no call-graph data will be 135gathered and when you run 'gprof' you will get an error message like 136this: 137 138 gprof: gmon.out file is missing call-graph data 139 140 If you add the '-Q' switch to suppress the printing of the call graph 141data you will still be able to see the time samples: 142 143 Flat profile: 144 145 Each sample counts as 0.01 seconds. 146 % cumulative self self total 147 time seconds seconds calls Ts/call Ts/call name 148 44.12 0.07 0.07 zazLoop 149 35.29 0.14 0.06 main 150 20.59 0.17 0.04 bazMillion 151 152 If you run the linker 'ld' directly instead of through a compiler 153such as 'cc', you may have to specify a profiling startup file 'gcrt0.o' 154as the first input file instead of the usual startup file 'crt0.o'. In 155addition, you would probably want to specify the profiling C library, 156'libc_p.a', by writing '-lc_p' instead of the usual '-lc'. This is not 157absolutely necessary, but doing this gives you number-of-calls 158information for standard library functions such as 'read' and 'open'. 159For example: 160 161 ld -o myprog /lib/gcrt0.o myprog.o utils.o -lc_p 162 163 If you are running the program on a system which supports shared 164libraries you may run into problems with the profiling support code in a 165shared library being called before that library has been fully 166initialised. This is usually detected by the program encountering a 167segmentation fault as soon as it is run. The solution is to link 168against a static version of the library containing the profiling support 169code, which for 'gcc' users can be done via the '-static' or 170'-static-libgcc' command-line option. For example: 171 172 gcc -g -pg -static-libgcc myprog.c utils.c -o myprog 173 174 If you compile only some of the modules of the program with '-pg', 175you can still profile the program, but you won't get complete 176information about the modules that were compiled without '-pg'. The 177only information you get for the functions in those modules is the total 178time spent in them; there is no record of how many times they were 179called, or from where. This will not affect the flat profile (except 180that the 'calls' field for the functions will be blank), but will 181greatly reduce the usefulness of the call graph. 182 183 If you wish to perform line-by-line profiling you should use the 184'gcov' tool instead of 'gprof'. See that tool's manual or info pages 185for more details of how to do this. 186 187 Note, older versions of 'gcc' produce line-by-line profiling 188information that works with 'gprof' rather than 'gcov' so there is still 189support for displaying this kind of information in 'gprof'. *Note 190Line-by-line Profiling: Line-by-line. 191 192 It also worth noting that 'gcc' implements a '-finstrument-functions' 193command-line option which will insert calls to special user supplied 194instrumentation routines at the entry and exit of every function in 195their program. This can be used to implement an alternative profiling 196scheme. 197 198 199File: gprof.info, Node: Executing, Next: Invoking, Prev: Compiling, Up: Top 200 2013 Executing the Program 202*********************** 203 204Once the program is compiled for profiling, you must run it in order to 205generate the information that 'gprof' needs. Simply run the program as 206usual, using the normal arguments, file names, etc. The program should 207run normally, producing the same output as usual. It will, however, run 208somewhat slower than normal because of the time spent collecting and 209writing the profile data. 210 211 The way you run the program--the arguments and input that you give 212it--may have a dramatic effect on what the profile information shows. 213The profile data will describe the parts of the program that were 214activated for the particular input you use. For example, if the first 215command you give to your program is to quit, the profile data will show 216the time used in initialization and in cleanup, but not much else. 217 218 Your program will write the profile data into a file called 219'gmon.out' just before exiting. If there is already a file called 220'gmon.out', its contents are overwritten. There is currently no way to 221tell the program to write the profile data under a different name, but 222you can rename the file afterwards if you are concerned that it may be 223overwritten. 224 225 In order to write the 'gmon.out' file properly, your program must 226exit normally: by returning from 'main' or by calling 'exit'. Calling 227the low-level function '_exit' does not write the profile data, and 228neither does abnormal termination due to an unhandled signal. 229 230 The 'gmon.out' file is written in the program's _current working 231directory_ at the time it exits. This means that if your program calls 232'chdir', the 'gmon.out' file will be left in the last directory your 233program 'chdir''d to. If you don't have permission to write in this 234directory, the file is not written, and you will get an error message. 235 236 Older versions of the GNU profiling library may also write a file 237called 'bb.out'. This file, if present, contains an human-readable 238listing of the basic-block execution counts. Unfortunately, the 239appearance of a human-readable 'bb.out' means the basic-block counts 240didn't get written into 'gmon.out'. The Perl script 'bbconv.pl', 241included with the 'gprof' source distribution, will convert a 'bb.out' 242file into a format readable by 'gprof'. Invoke it like this: 243 244 bbconv.pl < bb.out > BH-DATA 245 246 This translates the information in 'bb.out' into a form that 'gprof' 247can understand. But you still need to tell 'gprof' about the existence 248of this translated information. To do that, include BB-DATA on the 249'gprof' command line, _along with 'gmon.out'_, like this: 250 251 gprof OPTIONS EXECUTABLE-FILE gmon.out BB-DATA [YET-MORE-PROFILE-DATA-FILES...] [> OUTFILE] 252 253 254File: gprof.info, Node: Invoking, Next: Output, Prev: Executing, Up: Top 255 2564 'gprof' Command Summary 257************************* 258 259After you have a profile data file 'gmon.out', you can run 'gprof' to 260interpret the information in it. The 'gprof' program prints a flat 261profile and a call graph on standard output. Typically you would 262redirect the output of 'gprof' into a file with '>'. 263 264 You run 'gprof' like this: 265 266 gprof OPTIONS [EXECUTABLE-FILE [PROFILE-DATA-FILES...]] [> OUTFILE] 267 268Here square-brackets indicate optional arguments. 269 270 If you omit the executable file name, the file 'a.out' is used. If 271you give no profile data file name, the file 'gmon.out' is used. If any 272file is not in the proper format, or if the profile data file does not 273appear to belong to the executable file, an error message is printed. 274 275 You can give more than one profile data file by entering all their 276names after the executable file name; then the statistics in all the 277data files are summed together. 278 279 The order of these options does not matter. 280 281* Menu: 282 283* Output Options:: Controlling 'gprof''s output style 284* Analysis Options:: Controlling how 'gprof' analyzes its data 285* Miscellaneous Options:: 286* Deprecated Options:: Options you no longer need to use, but which 287 have been retained for compatibility 288* Symspecs:: Specifying functions to include or exclude 289 290 291File: gprof.info, Node: Output Options, Next: Analysis Options, Up: Invoking 292 2934.1 Output Options 294================== 295 296These options specify which of several output formats 'gprof' should 297produce. 298 299 Many of these options take an optional "symspec" to specify functions 300to be included or excluded. These options can be specified multiple 301times, with different symspecs, to include or exclude sets of symbols. 302*Note Symspecs: Symspecs. 303 304 Specifying any of these options overrides the default ('-p -q'), 305which prints a flat profile and call graph analysis for all functions. 306 307'-A[SYMSPEC]' 308'--annotated-source[=SYMSPEC]' 309 The '-A' option causes 'gprof' to print annotated source code. If 310 SYMSPEC is specified, print output only for matching symbols. 311 *Note The Annotated Source Listing: Annotated Source. 312 313'-b' 314'--brief' 315 If the '-b' option is given, 'gprof' doesn't print the verbose 316 blurbs that try to explain the meaning of all of the fields in the 317 tables. This is useful if you intend to print out the output, or 318 are tired of seeing the blurbs. 319 320'-C[SYMSPEC]' 321'--exec-counts[=SYMSPEC]' 322 The '-C' option causes 'gprof' to print a tally of functions and 323 the number of times each was called. If SYMSPEC is specified, 324 print tally only for matching symbols. 325 326 If the profile data file contains basic-block count records, 327 specifying the '-l' option, along with '-C', will cause basic-block 328 execution counts to be tallied and displayed. 329 330'-i' 331'--file-info' 332 The '-i' option causes 'gprof' to display summary information about 333 the profile data file(s) and then exit. The number of histogram, 334 call graph, and basic-block count records is displayed. 335 336'-I DIRS' 337'--directory-path=DIRS' 338 The '-I' option specifies a list of search directories in which to 339 find source files. Environment variable GPROF_PATH can also be 340 used to convey this information. Used mostly for annotated source 341 output. 342 343'-J[SYMSPEC]' 344'--no-annotated-source[=SYMSPEC]' 345 The '-J' option causes 'gprof' not to print annotated source code. 346 If SYMSPEC is specified, 'gprof' prints annotated source, but 347 excludes matching symbols. 348 349'-L' 350'--print-path' 351 Normally, source filenames are printed with the path component 352 suppressed. The '-L' option causes 'gprof' to print the full 353 pathname of source filenames, which is determined from symbolic 354 debugging information in the image file and is relative to the 355 directory in which the compiler was invoked. 356 357'-p[SYMSPEC]' 358'--flat-profile[=SYMSPEC]' 359 The '-p' option causes 'gprof' to print a flat profile. If SYMSPEC 360 is specified, print flat profile only for matching symbols. *Note 361 The Flat Profile: Flat Profile. 362 363'-P[SYMSPEC]' 364'--no-flat-profile[=SYMSPEC]' 365 The '-P' option causes 'gprof' to suppress printing a flat profile. 366 If SYMSPEC is specified, 'gprof' prints a flat profile, but 367 excludes matching symbols. 368 369'-q[SYMSPEC]' 370'--graph[=SYMSPEC]' 371 The '-q' option causes 'gprof' to print the call graph analysis. 372 If SYMSPEC is specified, print call graph only for matching symbols 373 and their children. *Note The Call Graph: Call Graph. 374 375'-Q[SYMSPEC]' 376'--no-graph[=SYMSPEC]' 377 The '-Q' option causes 'gprof' to suppress printing the call graph. 378 If SYMSPEC is specified, 'gprof' prints a call graph, but excludes 379 matching symbols. 380 381'-t' 382'--table-length=NUM' 383 The '-t' option causes the NUM most active source lines in each 384 source file to be listed when source annotation is enabled. The 385 default is 10. 386 387'-y' 388'--separate-files' 389 This option affects annotated source output only. Normally, 390 'gprof' prints annotated source files to standard-output. If this 391 option is specified, annotated source for a file named 392 'path/FILENAME' is generated in the file 'FILENAME-ann'. If the 393 underlying file system would truncate 'FILENAME-ann' so that it 394 overwrites the original 'FILENAME', 'gprof' generates annotated 395 source in the file 'FILENAME.ann' instead (if the original file 396 name has an extension, that extension is _replaced_ with '.ann'). 397 398'-Z[SYMSPEC]' 399'--no-exec-counts[=SYMSPEC]' 400 The '-Z' option causes 'gprof' not to print a tally of functions 401 and the number of times each was called. If SYMSPEC is specified, 402 print tally, but exclude matching symbols. 403 404'-r' 405'--function-ordering' 406 The '--function-ordering' option causes 'gprof' to print a 407 suggested function ordering for the program based on profiling 408 data. This option suggests an ordering which may improve paging, 409 tlb and cache behavior for the program on systems which support 410 arbitrary ordering of functions in an executable. 411 412 The exact details of how to force the linker to place functions in 413 a particular order is system dependent and out of the scope of this 414 manual. 415 416'-R MAP_FILE' 417'--file-ordering MAP_FILE' 418 The '--file-ordering' option causes 'gprof' to print a suggested .o 419 link line ordering for the program based on profiling data. This 420 option suggests an ordering which may improve paging, tlb and cache 421 behavior for the program on systems which do not support arbitrary 422 ordering of functions in an executable. 423 424 Use of the '-a' argument is highly recommended with this option. 425 426 The MAP_FILE argument is a pathname to a file which provides 427 function name to object file mappings. The format of the file is 428 similar to the output of the program 'nm'. 429 430 c-parse.o:00000000 T yyparse 431 c-parse.o:00000004 C yyerrflag 432 c-lang.o:00000000 T maybe_objc_method_name 433 c-lang.o:00000000 T print_lang_statistics 434 c-lang.o:00000000 T recognize_objc_keyword 435 c-decl.o:00000000 T print_lang_identifier 436 c-decl.o:00000000 T print_lang_type 437 ... 438 439 440 To create a MAP_FILE with GNU 'nm', type a command like 'nm 441 --extern-only --defined-only -v --print-file-name program-name'. 442 443'-T' 444'--traditional' 445 The '-T' option causes 'gprof' to print its output in "traditional" 446 BSD style. 447 448'-w WIDTH' 449'--width=WIDTH' 450 Sets width of output lines to WIDTH. Currently only used when 451 printing the function index at the bottom of the call graph. 452 453'-x' 454'--all-lines' 455 This option affects annotated source output only. By default, only 456 the lines at the beginning of a basic-block are annotated. If this 457 option is specified, every line in a basic-block is annotated by 458 repeating the annotation for the first line. This behavior is 459 similar to 'tcov''s '-a'. 460 461'--demangle[=STYLE]' 462'--no-demangle' 463 These options control whether C++ symbol names should be demangled 464 when printing output. The default is to demangle symbols. The 465 '--no-demangle' option may be used to turn off demangling. 466 Different compilers have different mangling styles. The optional 467 demangling style argument can be used to choose an appropriate 468 demangling style for your compiler. 469 470 471File: gprof.info, Node: Analysis Options, Next: Miscellaneous Options, Prev: Output Options, Up: Invoking 472 4734.2 Analysis Options 474==================== 475 476'-a' 477'--no-static' 478 The '-a' option causes 'gprof' to suppress the printing of 479 statically declared (private) functions. (These are functions 480 whose names are not listed as global, and which are not visible 481 outside the file/function/block where they were defined.) Time 482 spent in these functions, calls to/from them, etc., will all be 483 attributed to the function that was loaded directly before it in 484 the executable file. This option affects both the flat profile and 485 the call graph. 486 487'-c' 488'--static-call-graph' 489 The '-c' option causes the call graph of the program to be 490 augmented by a heuristic which examines the text space of the 491 object file and identifies function calls in the binary machine 492 code. Since normal call graph records are only generated when 493 functions are entered, this option identifies children that could 494 have been called, but never were. Calls to functions that were not 495 compiled with profiling enabled are also identified, but only if 496 symbol table entries are present for them. Calls to dynamic 497 library routines are typically _not_ found by this option. Parents 498 or children identified via this heuristic are indicated in the call 499 graph with call counts of '0'. 500 501'-D' 502'--ignore-non-functions' 503 The '-D' option causes 'gprof' to ignore symbols which are not 504 known to be functions. This option will give more accurate profile 505 data on systems where it is supported (Solaris and HPUX for 506 example). 507 508'-k FROM/TO' 509 The '-k' option allows you to delete from the call graph any arcs 510 from symbols matching symspec FROM to those matching symspec TO. 511 512'-l' 513'--line' 514 The '-l' option enables line-by-line profiling, which causes 515 histogram hits to be charged to individual source code lines, 516 instead of functions. This feature only works with programs 517 compiled by older versions of the 'gcc' compiler. Newer versions 518 of 'gcc' are designed to work with the 'gcov' tool instead. 519 520 If the program was compiled with basic-block counting enabled, this 521 option will also identify how many times each line of code was 522 executed. While line-by-line profiling can help isolate where in a 523 large function a program is spending its time, it also 524 significantly increases the running time of 'gprof', and magnifies 525 statistical inaccuracies. *Note Statistical Sampling Error: 526 Sampling Error. 527 528'--inline-file-names' 529 This option causes 'gprof' to print the source file after each 530 symbol in both the flat profile and the call graph. The full path 531 to the file is printed if used with the '-L' option. 532 533'-m NUM' 534'--min-count=NUM' 535 This option affects execution count output only. Symbols that are 536 executed less than NUM times are suppressed. 537 538'-nSYMSPEC' 539'--time=SYMSPEC' 540 The '-n' option causes 'gprof', in its call graph analysis, to only 541 propagate times for symbols matching SYMSPEC. 542 543'-NSYMSPEC' 544'--no-time=SYMSPEC' 545 The '-n' option causes 'gprof', in its call graph analysis, not to 546 propagate times for symbols matching SYMSPEC. 547 548'-SFILENAME' 549'--external-symbol-table=FILENAME' 550 The '-S' option causes 'gprof' to read an external symbol table 551 file, such as '/proc/kallsyms', rather than read the symbol table 552 from the given object file (the default is 'a.out'). This is 553 useful for profiling kernel modules. 554 555'-z' 556'--display-unused-functions' 557 If you give the '-z' option, 'gprof' will mention all functions in 558 the flat profile, even those that were never called, and that had 559 no time spent in them. This is useful in conjunction with the '-c' 560 option for discovering which routines were never called. 561 562 563File: gprof.info, Node: Miscellaneous Options, Next: Deprecated Options, Prev: Analysis Options, Up: Invoking 564 5654.3 Miscellaneous Options 566========================= 567 568'-d[NUM]' 569'--debug[=NUM]' 570 The '-d NUM' option specifies debugging options. If NUM is not 571 specified, enable all debugging. *Note Debugging 'gprof': 572 Debugging. 573 574'-h' 575'--help' 576 The '-h' option prints command line usage. 577 578'-ONAME' 579'--file-format=NAME' 580 Selects the format of the profile data files. Recognized formats 581 are 'auto' (the default), 'bsd', '4.4bsd', 'magic', and 'prof' (not 582 yet supported). 583 584'-s' 585'--sum' 586 The '-s' option causes 'gprof' to summarize the information in the 587 profile data files it read in, and write out a profile data file 588 called 'gmon.sum', which contains all the information from the 589 profile data files that 'gprof' read in. The file 'gmon.sum' may 590 be one of the specified input files; the effect of this is to merge 591 the data in the other input files into 'gmon.sum'. 592 593 Eventually you can run 'gprof' again without '-s' to analyze the 594 cumulative data in the file 'gmon.sum'. 595 596'-v' 597'--version' 598 The '-v' flag causes 'gprof' to print the current version number, 599 and then exit. 600 601 602File: gprof.info, Node: Deprecated Options, Next: Symspecs, Prev: Miscellaneous Options, Up: Invoking 603 6044.4 Deprecated Options 605====================== 606 607These options have been replaced with newer versions that use symspecs. 608 609'-e FUNCTION_NAME' 610 The '-e FUNCTION' option tells 'gprof' to not print information 611 about the function FUNCTION_NAME (and its children...) in the call 612 graph. The function will still be listed as a child of any 613 functions that call it, but its index number will be shown as '[not 614 printed]'. More than one '-e' option may be given; only one 615 FUNCTION_NAME may be indicated with each '-e' option. 616 617'-E FUNCTION_NAME' 618 The '-E FUNCTION' option works like the '-e' option, but time spent 619 in the function (and children who were not called from anywhere 620 else), will not be used to compute the percentages-of-time for the 621 call graph. More than one '-E' option may be given; only one 622 FUNCTION_NAME may be indicated with each '-E' option. 623 624'-f FUNCTION_NAME' 625 The '-f FUNCTION' option causes 'gprof' to limit the call graph to 626 the function FUNCTION_NAME and its children (and their 627 children...). More than one '-f' option may be given; only one 628 FUNCTION_NAME may be indicated with each '-f' option. 629 630'-F FUNCTION_NAME' 631 The '-F FUNCTION' option works like the '-f' option, but only time 632 spent in the function and its children (and their children...) will 633 be used to determine total-time and percentages-of-time for the 634 call graph. More than one '-F' option may be given; only one 635 FUNCTION_NAME may be indicated with each '-F' option. The '-F' 636 option overrides the '-E' option. 637 638 Note that only one function can be specified with each '-e', '-E', 639'-f' or '-F' option. To specify more than one function, use multiple 640options. For example, this command: 641 642 gprof -e boring -f foo -f bar myprogram > gprof.output 643 644lists in the call graph all functions that were reached from either 645'foo' or 'bar' and were not reachable from 'boring'. 646 647 648File: gprof.info, Node: Symspecs, Prev: Deprecated Options, Up: Invoking 649 6504.5 Symspecs 651============ 652 653Many of the output options allow functions to be included or excluded 654using "symspecs" (symbol specifications), which observe the following 655syntax: 656 657 filename_containing_a_dot 658 | funcname_not_containing_a_dot 659 | linenumber 660 | ( [ any_filename ] `:' ( any_funcname | linenumber ) ) 661 662 Here are some sample symspecs: 663 664'main.c' 665 Selects everything in file 'main.c'--the dot in the string tells 666 'gprof' to interpret the string as a filename, rather than as a 667 function name. To select a file whose name does not contain a dot, 668 a trailing colon should be specified. For example, 'odd:' is 669 interpreted as the file named 'odd'. 670 671'main' 672 Selects all functions named 'main'. 673 674 Note that there may be multiple instances of the same function name 675 because some of the definitions may be local (i.e., static). 676 Unless a function name is unique in a program, you must use the 677 colon notation explained below to specify a function from a 678 specific source file. 679 680 Sometimes, function names contain dots. In such cases, it is 681 necessary to add a leading colon to the name. For example, ':.mul' 682 selects function '.mul'. 683 684 In some object file formats, symbols have a leading underscore. 685 'gprof' will normally not print these underscores. When you name a 686 symbol in a symspec, you should type it exactly as 'gprof' prints 687 it in its output. For example, if the compiler produces a symbol 688 '_main' from your 'main' function, 'gprof' still prints it as 689 'main' in its output, so you should use 'main' in symspecs. 690 691'main.c:main' 692 Selects function 'main' in file 'main.c'. 693 694'main.c:134' 695 Selects line 134 in file 'main.c'. 696 697 698File: gprof.info, Node: Output, Next: Inaccuracy, Prev: Invoking, Up: Top 699 7005 Interpreting 'gprof''s Output 701******************************* 702 703'gprof' can produce several different output styles, the most important 704of which are described below. The simplest output styles (file 705information, execution count, and function and file ordering) are not 706described here, but are documented with the respective options that 707trigger them. *Note Output Options: Output Options. 708 709* Menu: 710 711* Flat Profile:: The flat profile shows how much time was spent 712 executing directly in each function. 713* Call Graph:: The call graph shows which functions called which 714 others, and how much time each function used 715 when its subroutine calls are included. 716* Line-by-line:: 'gprof' can analyze individual source code lines 717* Annotated Source:: The annotated source listing displays source code 718 labeled with execution counts 719 720 721File: gprof.info, Node: Flat Profile, Next: Call Graph, Up: Output 722 7235.1 The Flat Profile 724==================== 725 726The "flat profile" shows the total amount of time your program spent 727executing each function. Unless the '-z' option is given, functions 728with no apparent time spent in them, and no apparent calls to them, are 729not mentioned. Note that if a function was not compiled for profiling, 730and didn't run long enough to show up on the program counter histogram, 731it will be indistinguishable from a function that was never called. 732 733 This is part of a flat profile for a small program: 734 735 Flat profile: 736 737 Each sample counts as 0.01 seconds. 738 % cumulative self self total 739 time seconds seconds calls ms/call ms/call name 740 33.34 0.02 0.02 7208 0.00 0.00 open 741 16.67 0.03 0.01 244 0.04 0.12 offtime 742 16.67 0.04 0.01 8 1.25 1.25 memccpy 743 16.67 0.05 0.01 7 1.43 1.43 write 744 16.67 0.06 0.01 mcount 745 0.00 0.06 0.00 236 0.00 0.00 tzset 746 0.00 0.06 0.00 192 0.00 0.00 tolower 747 0.00 0.06 0.00 47 0.00 0.00 strlen 748 0.00 0.06 0.00 45 0.00 0.00 strchr 749 0.00 0.06 0.00 1 0.00 50.00 main 750 0.00 0.06 0.00 1 0.00 0.00 memcpy 751 0.00 0.06 0.00 1 0.00 10.11 print 752 0.00 0.06 0.00 1 0.00 0.00 profil 753 0.00 0.06 0.00 1 0.00 50.00 report 754 ... 755 756The functions are sorted first by decreasing run-time spent in them, 757then by decreasing number of calls, then alphabetically by name. The 758functions 'mcount' and 'profil' are part of the profiling apparatus and 759appear in every flat profile; their time gives a measure of the amount 760of overhead due to profiling. 761 762 Just before the column headers, a statement appears indicating how 763much time each sample counted as. This "sampling period" estimates the 764margin of error in each of the time figures. A time figure that is not 765much larger than this is not reliable. In this example, each sample 766counted as 0.01 seconds, suggesting a 100 Hz sampling rate. The 767program's total execution time was 0.06 seconds, as indicated by the 768'cumulative seconds' field. Since each sample counted for 0.01 seconds, 769this means only six samples were taken during the run. Two of the 770samples occurred while the program was in the 'open' function, as 771indicated by the 'self seconds' field. Each of the other four samples 772occurred one each in 'offtime', 'memccpy', 'write', and 'mcount'. Since 773only six samples were taken, none of these values can be regarded as 774particularly reliable. In another run, the 'self seconds' field for 775'mcount' might well be '0.00' or '0.02'. *Note Statistical Sampling 776Error: Sampling Error, for a complete discussion. 777 778 The remaining functions in the listing (those whose 'self seconds' 779field is '0.00') didn't appear in the histogram samples at all. 780However, the call graph indicated that they were called, so therefore 781they are listed, sorted in decreasing order by the 'calls' field. 782Clearly some time was spent executing these functions, but the paucity 783of histogram samples prevents any determination of how much time each 784took. 785 786 Here is what the fields in each line mean: 787 788'% time' 789 This is the percentage of the total execution time your program 790 spent in this function. These should all add up to 100%. 791 792'cumulative seconds' 793 This is the cumulative total number of seconds the computer spent 794 executing this functions, plus the time spent in all the functions 795 above this one in this table. 796 797'self seconds' 798 This is the number of seconds accounted for by this function alone. 799 The flat profile listing is sorted first by this number. 800 801'calls' 802 This is the total number of times the function was called. If the 803 function was never called, or the number of times it was called 804 cannot be determined (probably because the function was not 805 compiled with profiling enabled), the "calls" field is blank. 806 807'self ms/call' 808 This represents the average number of milliseconds spent in this 809 function per call, if this function is profiled. Otherwise, this 810 field is blank for this function. 811 812'total ms/call' 813 This represents the average number of milliseconds spent in this 814 function and its descendants per call, if this function is 815 profiled. Otherwise, this field is blank for this function. This 816 is the only field in the flat profile that uses call graph 817 analysis. 818 819'name' 820 This is the name of the function. The flat profile is sorted by 821 this field alphabetically after the "self seconds" and "calls" 822 fields are sorted. 823 824 825File: gprof.info, Node: Call Graph, Next: Line-by-line, Prev: Flat Profile, Up: Output 826 8275.2 The Call Graph 828================== 829 830The "call graph" shows how much time was spent in each function and its 831children. From this information, you can find functions that, while 832they themselves may not have used much time, called other functions that 833did use unusual amounts of time. 834 835 Here is a sample call from a small program. This call came from the 836same 'gprof' run as the flat profile example in the previous section. 837 838 granularity: each sample hit covers 2 byte(s) for 20.00% of 0.05 seconds 839 840 index % time self children called name 841 <spontaneous> 842 [1] 100.0 0.00 0.05 start [1] 843 0.00 0.05 1/1 main [2] 844 0.00 0.00 1/2 on_exit [28] 845 0.00 0.00 1/1 exit [59] 846 ----------------------------------------------- 847 0.00 0.05 1/1 start [1] 848 [2] 100.0 0.00 0.05 1 main [2] 849 0.00 0.05 1/1 report [3] 850 ----------------------------------------------- 851 0.00 0.05 1/1 main [2] 852 [3] 100.0 0.00 0.05 1 report [3] 853 0.00 0.03 8/8 timelocal [6] 854 0.00 0.01 1/1 print [9] 855 0.00 0.01 9/9 fgets [12] 856 0.00 0.00 12/34 strncmp <cycle 1> [40] 857 0.00 0.00 8/8 lookup [20] 858 0.00 0.00 1/1 fopen [21] 859 0.00 0.00 8/8 chewtime [24] 860 0.00 0.00 8/16 skipspace [44] 861 ----------------------------------------------- 862 [4] 59.8 0.01 0.02 8+472 <cycle 2 as a whole> [4] 863 0.01 0.02 244+260 offtime <cycle 2> [7] 864 0.00 0.00 236+1 tzset <cycle 2> [26] 865 ----------------------------------------------- 866 867 The lines full of dashes divide this table into "entries", one for 868each function. Each entry has one or more lines. 869 870 In each entry, the primary line is the one that starts with an index 871number in square brackets. The end of this line says which function the 872entry is for. The preceding lines in the entry describe the callers of 873this function and the following lines describe its subroutines (also 874called "children" when we speak of the call graph). 875 876 The entries are sorted by time spent in the function and its 877subroutines. 878 879 The internal profiling function 'mcount' (*note The Flat Profile: 880Flat Profile.) is never mentioned in the call graph. 881 882* Menu: 883 884* Primary:: Details of the primary line's contents. 885* Callers:: Details of caller-lines' contents. 886* Subroutines:: Details of subroutine-lines' contents. 887* Cycles:: When there are cycles of recursion, 888 such as 'a' calls 'b' calls 'a'... 889 890 891File: gprof.info, Node: Primary, Next: Callers, Up: Call Graph 892 8935.2.1 The Primary Line 894---------------------- 895 896The "primary line" in a call graph entry is the line that describes the 897function which the entry is about and gives the overall statistics for 898this function. 899 900 For reference, we repeat the primary line from the entry for function 901'report' in our main example, together with the heading line that shows 902the names of the fields: 903 904 index % time self children called name 905 ... 906 [3] 100.0 0.00 0.05 1 report [3] 907 908 Here is what the fields in the primary line mean: 909 910'index' 911 Entries are numbered with consecutive integers. Each function 912 therefore has an index number, which appears at the beginning of 913 its primary line. 914 915 Each cross-reference to a function, as a caller or subroutine of 916 another, gives its index number as well as its name. The index 917 number guides you if you wish to look for the entry for that 918 function. 919 920'% time' 921 This is the percentage of the total time that was spent in this 922 function, including time spent in subroutines called from this 923 function. 924 925 The time spent in this function is counted again for the callers of 926 this function. Therefore, adding up these percentages is 927 meaningless. 928 929'self' 930 This is the total amount of time spent in this function. This 931 should be identical to the number printed in the 'seconds' field 932 for this function in the flat profile. 933 934'children' 935 This is the total amount of time spent in the subroutine calls made 936 by this function. This should be equal to the sum of all the 937 'self' and 'children' entries of the children listed directly below 938 this function. 939 940'called' 941 This is the number of times the function was called. 942 943 If the function called itself recursively, there are two numbers, 944 separated by a '+'. The first number counts non-recursive calls, 945 and the second counts recursive calls. 946 947 In the example above, the function 'report' was called once from 948 'main'. 949 950'name' 951 This is the name of the current function. The index number is 952 repeated after it. 953 954 If the function is part of a cycle of recursion, the cycle number 955 is printed between the function's name and the index number (*note 956 How Mutually Recursive Functions Are Described: Cycles.). For 957 example, if function 'gnurr' is part of cycle number one, and has 958 index number twelve, its primary line would be end like this: 959 960 gnurr <cycle 1> [12] 961 962 963File: gprof.info, Node: Callers, Next: Subroutines, Prev: Primary, Up: Call Graph 964 9655.2.2 Lines for a Function's Callers 966------------------------------------ 967 968A function's entry has a line for each function it was called by. These 969lines' fields correspond to the fields of the primary line, but their 970meanings are different because of the difference in context. 971 972 For reference, we repeat two lines from the entry for the function 973'report', the primary line and one caller-line preceding it, together 974with the heading line that shows the names of the fields: 975 976 index % time self children called name 977 ... 978 0.00 0.05 1/1 main [2] 979 [3] 100.0 0.00 0.05 1 report [3] 980 981 Here are the meanings of the fields in the caller-line for 'report' 982called from 'main': 983 984'self' 985 An estimate of the amount of time spent in 'report' itself when it 986 was called from 'main'. 987 988'children' 989 An estimate of the amount of time spent in subroutines of 'report' 990 when 'report' was called from 'main'. 991 992 The sum of the 'self' and 'children' fields is an estimate of the 993 amount of time spent within calls to 'report' from 'main'. 994 995'called' 996 Two numbers: the number of times 'report' was called from 'main', 997 followed by the total number of non-recursive calls to 'report' 998 from all its callers. 999 1000'name and index number' 1001 The name of the caller of 'report' to which this line applies, 1002 followed by the caller's index number. 1003 1004 Not all functions have entries in the call graph; some options to 1005 'gprof' request the omission of certain functions. When a caller 1006 has no entry of its own, it still has caller-lines in the entries 1007 of the functions it calls. 1008 1009 If the caller is part of a recursion cycle, the cycle number is 1010 printed between the name and the index number. 1011 1012 If the identity of the callers of a function cannot be determined, a 1013dummy caller-line is printed which has '<spontaneous>' as the "caller's 1014name" and all other fields blank. This can happen for signal handlers. 1015 1016 1017File: gprof.info, Node: Subroutines, Next: Cycles, Prev: Callers, Up: Call Graph 1018 10195.2.3 Lines for a Function's Subroutines 1020---------------------------------------- 1021 1022A function's entry has a line for each of its subroutines--in other 1023words, a line for each other function that it called. These lines' 1024fields correspond to the fields of the primary line, but their meanings 1025are different because of the difference in context. 1026 1027 For reference, we repeat two lines from the entry for the function 1028'main', the primary line and a line for a subroutine, together with the 1029heading line that shows the names of the fields: 1030 1031 index % time self children called name 1032 ... 1033 [2] 100.0 0.00 0.05 1 main [2] 1034 0.00 0.05 1/1 report [3] 1035 1036 Here are the meanings of the fields in the subroutine-line for 'main' 1037calling 'report': 1038 1039'self' 1040 An estimate of the amount of time spent directly within 'report' 1041 when 'report' was called from 'main'. 1042 1043'children' 1044 An estimate of the amount of time spent in subroutines of 'report' 1045 when 'report' was called from 'main'. 1046 1047 The sum of the 'self' and 'children' fields is an estimate of the 1048 total time spent in calls to 'report' from 'main'. 1049 1050'called' 1051 Two numbers, the number of calls to 'report' from 'main' followed 1052 by the total number of non-recursive calls to 'report'. This ratio 1053 is used to determine how much of 'report''s 'self' and 'children' 1054 time gets credited to 'main'. *Note Estimating 'children' Times: 1055 Assumptions. 1056 1057'name' 1058 The name of the subroutine of 'main' to which this line applies, 1059 followed by the subroutine's index number. 1060 1061 If the caller is part of a recursion cycle, the cycle number is 1062 printed between the name and the index number. 1063 1064 1065File: gprof.info, Node: Cycles, Prev: Subroutines, Up: Call Graph 1066 10675.2.4 How Mutually Recursive Functions Are Described 1068---------------------------------------------------- 1069 1070The graph may be complicated by the presence of "cycles of recursion" in 1071the call graph. A cycle exists if a function calls another function 1072that (directly or indirectly) calls (or appears to call) the original 1073function. For example: if 'a' calls 'b', and 'b' calls 'a', then 'a' 1074and 'b' form a cycle. 1075 1076 Whenever there are call paths both ways between a pair of functions, 1077they belong to the same cycle. If 'a' and 'b' call each other and 'b' 1078and 'c' call each other, all three make one cycle. Note that even if 1079'b' only calls 'a' if it was not called from 'a', 'gprof' cannot 1080determine this, so 'a' and 'b' are still considered a cycle. 1081 1082 The cycles are numbered with consecutive integers. When a function 1083belongs to a cycle, each time the function name appears in the call 1084graph it is followed by '<cycle NUMBER>'. 1085 1086 The reason cycles matter is that they make the time values in the 1087call graph paradoxical. The "time spent in children" of 'a' should 1088include the time spent in its subroutine 'b' and in 'b''s 1089subroutines--but one of 'b''s subroutines is 'a'! How much of 'a''s 1090time should be included in the children of 'a', when 'a' is indirectly 1091recursive? 1092 1093 The way 'gprof' resolves this paradox is by creating a single entry 1094for the cycle as a whole. The primary line of this entry describes the 1095total time spent directly in the functions of the cycle. The 1096"subroutines" of the cycle are the individual functions of the cycle, 1097and all other functions that were called directly by them. The 1098"callers" of the cycle are the functions, outside the cycle, that called 1099functions in the cycle. 1100 1101 Here is an example portion of a call graph which shows a cycle 1102containing functions 'a' and 'b'. The cycle was entered by a call to 1103'a' from 'main'; both 'a' and 'b' called 'c'. 1104 1105 index % time self children called name 1106 ---------------------------------------- 1107 1.77 0 1/1 main [2] 1108 [3] 91.71 1.77 0 1+5 <cycle 1 as a whole> [3] 1109 1.02 0 3 b <cycle 1> [4] 1110 0.75 0 2 a <cycle 1> [5] 1111 ---------------------------------------- 1112 3 a <cycle 1> [5] 1113 [4] 52.85 1.02 0 0 b <cycle 1> [4] 1114 2 a <cycle 1> [5] 1115 0 0 3/6 c [6] 1116 ---------------------------------------- 1117 1.77 0 1/1 main [2] 1118 2 b <cycle 1> [4] 1119 [5] 38.86 0.75 0 1 a <cycle 1> [5] 1120 3 b <cycle 1> [4] 1121 0 0 3/6 c [6] 1122 ---------------------------------------- 1123 1124(The entire call graph for this program contains in addition an entry 1125for 'main', which calls 'a', and an entry for 'c', with callers 'a' and 1126'b'.) 1127 1128 index % time self children called name 1129 <spontaneous> 1130 [1] 100.00 0 1.93 0 start [1] 1131 0.16 1.77 1/1 main [2] 1132 ---------------------------------------- 1133 0.16 1.77 1/1 start [1] 1134 [2] 100.00 0.16 1.77 1 main [2] 1135 1.77 0 1/1 a <cycle 1> [5] 1136 ---------------------------------------- 1137 1.77 0 1/1 main [2] 1138 [3] 91.71 1.77 0 1+5 <cycle 1 as a whole> [3] 1139 1.02 0 3 b <cycle 1> [4] 1140 0.75 0 2 a <cycle 1> [5] 1141 0 0 6/6 c [6] 1142 ---------------------------------------- 1143 3 a <cycle 1> [5] 1144 [4] 52.85 1.02 0 0 b <cycle 1> [4] 1145 2 a <cycle 1> [5] 1146 0 0 3/6 c [6] 1147 ---------------------------------------- 1148 1.77 0 1/1 main [2] 1149 2 b <cycle 1> [4] 1150 [5] 38.86 0.75 0 1 a <cycle 1> [5] 1151 3 b <cycle 1> [4] 1152 0 0 3/6 c [6] 1153 ---------------------------------------- 1154 0 0 3/6 b <cycle 1> [4] 1155 0 0 3/6 a <cycle 1> [5] 1156 [6] 0.00 0 0 6 c [6] 1157 ---------------------------------------- 1158 1159 The 'self' field of the cycle's primary line is the total time spent 1160in all the functions of the cycle. It equals the sum of the 'self' 1161fields for the individual functions in the cycle, found in the entry in 1162the subroutine lines for these functions. 1163 1164 The 'children' fields of the cycle's primary line and subroutine 1165lines count only subroutines outside the cycle. Even though 'a' calls 1166'b', the time spent in those calls to 'b' is not counted in 'a''s 1167'children' time. Thus, we do not encounter the problem of what to do 1168when the time in those calls to 'b' includes indirect recursive calls 1169back to 'a'. 1170 1171 The 'children' field of a caller-line in the cycle's entry estimates 1172the amount of time spent _in the whole cycle_, and its other 1173subroutines, on the times when that caller called a function in the 1174cycle. 1175 1176 The 'called' field in the primary line for the cycle has two numbers: 1177first, the number of times functions in the cycle were called by 1178functions outside the cycle; second, the number of times they were 1179called by functions in the cycle (including times when a function in the 1180cycle calls itself). This is a generalization of the usual split into 1181non-recursive and recursive calls. 1182 1183 The 'called' field of a subroutine-line for a cycle member in the 1184cycle's entry says how many time that function was called from functions 1185in the cycle. The total of all these is the second number in the 1186primary line's 'called' field. 1187 1188 In the individual entry for a function in a cycle, the other 1189functions in the same cycle can appear as subroutines and as callers. 1190These lines show how many times each function in the cycle called or was 1191called from each other function in the cycle. The 'self' and 'children' 1192fields in these lines are blank because of the difficulty of defining 1193meanings for them when recursion is going on. 1194 1195 1196File: gprof.info, Node: Line-by-line, Next: Annotated Source, Prev: Call Graph, Up: Output 1197 11985.3 Line-by-line Profiling 1199========================== 1200 1201'gprof''s '-l' option causes the program to perform "line-by-line" 1202profiling. In this mode, histogram samples are assigned not to 1203functions, but to individual lines of source code. This only works with 1204programs compiled with older versions of the 'gcc' compiler. Newer 1205versions of 'gcc' use a different program - 'gcov' - to display 1206line-by-line profiling information. 1207 1208 With the older versions of 'gcc' the program usually has to be 1209compiled with a '-g' option, in addition to '-pg', in order to generate 1210debugging symbols for tracking source code lines. Note, in much older 1211versions of 'gcc' the program had to be compiled with the '-a' 1212command-line option as well. 1213 1214 The flat profile is the most useful output table in line-by-line 1215mode. The call graph isn't as useful as normal, since the current 1216version of 'gprof' does not propagate call graph arcs from source code 1217lines to the enclosing function. The call graph does, however, show 1218each line of code that called each function, along with a count. 1219 1220 Here is a section of 'gprof''s output, without line-by-line 1221profiling. Note that 'ct_init' accounted for four histogram hits, and 122213327 calls to 'init_block'. 1223 1224 Flat profile: 1225 1226 Each sample counts as 0.01 seconds. 1227 % cumulative self self total 1228 time seconds seconds calls us/call us/call name 1229 30.77 0.13 0.04 6335 6.31 6.31 ct_init 1230 1231 1232 Call graph (explanation follows) 1233 1234 1235 granularity: each sample hit covers 4 byte(s) for 7.69% of 0.13 seconds 1236 1237 index % time self children called name 1238 1239 0.00 0.00 1/13496 name_too_long 1240 0.00 0.00 40/13496 deflate 1241 0.00 0.00 128/13496 deflate_fast 1242 0.00 0.00 13327/13496 ct_init 1243 [7] 0.0 0.00 0.00 13496 init_block 1244 1245 1246 Now let's look at some of 'gprof''s output from the same program run, 1247this time with line-by-line profiling enabled. Note that 'ct_init''s 1248four histogram hits are broken down into four lines of source code--one 1249hit occurred on each of lines 349, 351, 382 and 385. In the call graph, 1250note how 'ct_init''s 13327 calls to 'init_block' are broken down into 1251one call from line 396, 3071 calls from line 384, 3730 calls from line 1252385, and 6525 calls from 387. 1253 1254 Flat profile: 1255 1256 Each sample counts as 0.01 seconds. 1257 % cumulative self 1258 time seconds seconds calls name 1259 7.69 0.10 0.01 ct_init (trees.c:349) 1260 7.69 0.11 0.01 ct_init (trees.c:351) 1261 7.69 0.12 0.01 ct_init (trees.c:382) 1262 7.69 0.13 0.01 ct_init (trees.c:385) 1263 1264 1265 Call graph (explanation follows) 1266 1267 1268 granularity: each sample hit covers 4 byte(s) for 7.69% of 0.13 seconds 1269 1270 % time self children called name 1271 1272 0.00 0.00 1/13496 name_too_long (gzip.c:1440) 1273 0.00 0.00 1/13496 deflate (deflate.c:763) 1274 0.00 0.00 1/13496 ct_init (trees.c:396) 1275 0.00 0.00 2/13496 deflate (deflate.c:727) 1276 0.00 0.00 4/13496 deflate (deflate.c:686) 1277 0.00 0.00 5/13496 deflate (deflate.c:675) 1278 0.00 0.00 12/13496 deflate (deflate.c:679) 1279 0.00 0.00 16/13496 deflate (deflate.c:730) 1280 0.00 0.00 128/13496 deflate_fast (deflate.c:654) 1281 0.00 0.00 3071/13496 ct_init (trees.c:384) 1282 0.00 0.00 3730/13496 ct_init (trees.c:385) 1283 0.00 0.00 6525/13496 ct_init (trees.c:387) 1284 [6] 0.0 0.00 0.00 13496 init_block (trees.c:408) 1285 1286 1287 1288File: gprof.info, Node: Annotated Source, Prev: Line-by-line, Up: Output 1289 12905.4 The Annotated Source Listing 1291================================ 1292 1293'gprof''s '-A' option triggers an annotated source listing, which lists 1294the program's source code, each function labeled with the number of 1295times it was called. You may also need to specify the '-I' option, if 1296'gprof' can't find the source code files. 1297 1298 With older versions of 'gcc' compiling with 'gcc ... -g -pg -a' 1299augments your program with basic-block counting code, in addition to 1300function counting code. This enables 'gprof' to determine how many 1301times each line of code was executed. With newer versions of 'gcc' 1302support for displaying basic-block counts is provided by the 'gcov' 1303program. 1304 1305 For example, consider the following function, taken from gzip, with 1306line numbers added: 1307 1308 1 ulg updcrc(s, n) 1309 2 uch *s; 1310 3 unsigned n; 1311 4 { 1312 5 register ulg c; 1313 6 1314 7 static ulg crc = (ulg)0xffffffffL; 1315 8 1316 9 if (s == NULL) { 1317 10 c = 0xffffffffL; 1318 11 } else { 1319 12 c = crc; 1320 13 if (n) do { 1321 14 c = crc_32_tab[...]; 1322 15 } while (--n); 1323 16 } 1324 17 crc = c; 1325 18 return c ^ 0xffffffffL; 1326 19 } 1327 1328 1329 'updcrc' has at least five basic-blocks. One is the function itself. 1330The 'if' statement on line 9 generates two more basic-blocks, one for 1331each branch of the 'if'. A fourth basic-block results from the 'if' on 1332line 13, and the contents of the 'do' loop form the fifth basic-block. 1333The compiler may also generate additional basic-blocks to handle various 1334special cases. 1335 1336 A program augmented for basic-block counting can be analyzed with 1337'gprof -l -A'. The '-x' option is also helpful, to ensure that each 1338line of code is labeled at least once. Here is 'updcrc''s annotated 1339source listing for a sample 'gzip' run: 1340 1341 ulg updcrc(s, n) 1342 uch *s; 1343 unsigned n; 1344 2 ->{ 1345 register ulg c; 1346 1347 static ulg crc = (ulg)0xffffffffL; 1348 1349 2 -> if (s == NULL) { 1350 1 -> c = 0xffffffffL; 1351 1 -> } else { 1352 1 -> c = crc; 1353 1 -> if (n) do { 1354 26312 -> c = crc_32_tab[...]; 1355 26312,1,26311 -> } while (--n); 1356 } 1357 2 -> crc = c; 1358 2 -> return c ^ 0xffffffffL; 1359 2 ->} 1360 1361 In this example, the function was called twice, passing once through 1362each branch of the 'if' statement. The body of the 'do' loop was 1363executed a total of 26312 times. Note how the 'while' statement is 1364annotated. It began execution 26312 times, once for each iteration 1365through the loop. One of those times (the last time) it exited, while 1366it branched back to the beginning of the loop 26311 times. 1367 1368 1369File: gprof.info, Node: Inaccuracy, Next: How do I?, Prev: Output, Up: Top 1370 13716 Inaccuracy of 'gprof' Output 1372****************************** 1373 1374* Menu: 1375 1376* Sampling Error:: Statistical margins of error 1377* Assumptions:: Estimating children times 1378 1379 1380File: gprof.info, Node: Sampling Error, Next: Assumptions, Up: Inaccuracy 1381 13826.1 Statistical Sampling Error 1383============================== 1384 1385The run-time figures that 'gprof' gives you are based on a sampling 1386process, so they are subject to statistical inaccuracy. If a function 1387runs only a small amount of time, so that on the average the sampling 1388process ought to catch that function in the act only once, there is a 1389pretty good chance it will actually find that function zero times, or 1390twice. 1391 1392 By contrast, the number-of-calls and basic-block figures are derived 1393by counting, not sampling. They are completely accurate and will not 1394vary from run to run if your program is deterministic and single 1395threaded. In multi-threaded applications, or single threaded 1396applications that link with multi-threaded libraries, the counts are 1397only deterministic if the counting function is thread-safe. (Note: 1398beware that the mcount counting function in glibc is _not_ thread-safe). 1399*Note Implementation of Profiling: Implementation. 1400 1401 The "sampling period" that is printed at the beginning of the flat 1402profile says how often samples are taken. The rule of thumb is that a 1403run-time figure is accurate if it is considerably bigger than the 1404sampling period. 1405 1406 The actual amount of error can be predicted. For N samples, the 1407_expected_ error is the square-root of N. For example, if the sampling 1408period is 0.01 seconds and 'foo''s run-time is 1 second, N is 100 1409samples (1 second/0.01 seconds), sqrt(N) is 10 samples, so the expected 1410error in 'foo''s run-time is 0.1 seconds (10*0.01 seconds), or ten 1411percent of the observed value. Again, if the sampling period is 0.01 1412seconds and 'bar''s run-time is 100 seconds, N is 10000 samples, sqrt(N) 1413is 100 samples, so the expected error in 'bar''s run-time is 1 second, 1414or one percent of the observed value. It is likely to vary this much 1415_on the average_ from one profiling run to the next. (_Sometimes_ it 1416will vary more.) 1417 1418 This does not mean that a small run-time figure is devoid of 1419information. If the program's _total_ run-time is large, a small 1420run-time for one function does tell you that that function used an 1421insignificant fraction of the whole program's time. Usually this means 1422it is not worth optimizing. 1423 1424 One way to get more accuracy is to give your program more (but 1425similar) input data so it will take longer. Another way is to combine 1426the data from several runs, using the '-s' option of 'gprof'. Here is 1427how: 1428 1429 1. Run your program once. 1430 1431 2. Issue the command 'mv gmon.out gmon.sum'. 1432 1433 3. Run your program again, the same as before. 1434 1435 4. Merge the new data in 'gmon.out' into 'gmon.sum' with this command: 1436 1437 gprof -s EXECUTABLE-FILE gmon.out gmon.sum 1438 1439 5. Repeat the last two steps as often as you wish. 1440 1441 6. Analyze the cumulative data using this command: 1442 1443 gprof EXECUTABLE-FILE gmon.sum > OUTPUT-FILE 1444 1445 1446File: gprof.info, Node: Assumptions, Prev: Sampling Error, Up: Inaccuracy 1447 14486.2 Estimating 'children' Times 1449=============================== 1450 1451Some of the figures in the call graph are estimates--for example, the 1452'children' time values and all the time figures in caller and subroutine 1453lines. 1454 1455 There is no direct information about these measurements in the 1456profile data itself. Instead, 'gprof' estimates them by making an 1457assumption about your program that might or might not be true. 1458 1459 The assumption made is that the average time spent in each call to 1460any function 'foo' is not correlated with who called 'foo'. If 'foo' 1461used 5 seconds in all, and 2/5 of the calls to 'foo' came from 'a', then 1462'foo' contributes 2 seconds to 'a''s 'children' time, by assumption. 1463 1464 This assumption is usually true enough, but for some programs it is 1465far from true. Suppose that 'foo' returns very quickly when its 1466argument is zero; suppose that 'a' always passes zero as an argument, 1467while other callers of 'foo' pass other arguments. In this program, all 1468the time spent in 'foo' is in the calls from callers other than 'a'. 1469But 'gprof' has no way of knowing this; it will blindly and incorrectly 1470charge 2 seconds of time in 'foo' to the children of 'a'. 1471 1472 We hope some day to put more complete data into 'gmon.out', so that 1473this assumption is no longer needed, if we can figure out how. For the 1474novice, the estimated figures are usually more useful than misleading. 1475 1476 1477File: gprof.info, Node: How do I?, Next: Incompatibilities, Prev: Inaccuracy, Up: Top 1478 14797 Answers to Common Questions 1480***************************** 1481 1482How can I get more exact information about hot spots in my program? 1483 1484 Looking at the per-line call counts only tells part of the story. 1485 Because 'gprof' can only report call times and counts by function, 1486 the best way to get finer-grained information on where the program 1487 is spending its time is to re-factor large functions into sequences 1488 of calls to smaller ones. Beware however that this can introduce 1489 artificial hot spots since compiling with '-pg' adds a significant 1490 overhead to function calls. An alternative solution is to use a 1491 non-intrusive profiler, e.g. oprofile. 1492 1493How do I find which lines in my program were executed the most times? 1494 1495 Use the 'gcov' program. 1496 1497How do I find which lines in my program called a particular function? 1498 1499 Use 'gprof -l' and lookup the function in the call graph. The 1500 callers will be broken down by function and line number. 1501 1502How do I analyze a program that runs for less than a second? 1503 1504 Try using a shell script like this one: 1505 1506 for i in `seq 1 100`; do 1507 fastprog 1508 mv gmon.out gmon.out.$i 1509 done 1510 1511 gprof -s fastprog gmon.out.* 1512 1513 gprof fastprog gmon.sum 1514 1515 If your program is completely deterministic, all the call counts 1516 will be simple multiples of 100 (i.e., a function called once in 1517 each run will appear with a call count of 100). 1518 1519 1520File: gprof.info, Node: Incompatibilities, Next: Details, Prev: How do I?, Up: Top 1521 15228 Incompatibilities with Unix 'gprof' 1523************************************* 1524 1525GNU 'gprof' and Berkeley Unix 'gprof' use the same data file 'gmon.out', 1526and provide essentially the same information. But there are a few 1527differences. 1528 1529 * GNU 'gprof' uses a new, generalized file format with support for 1530 basic-block execution counts and non-realtime histograms. A magic 1531 cookie and version number allows 'gprof' to easily identify new 1532 style files. Old BSD-style files can still be read. *Note 1533 Profiling Data File Format: File Format. 1534 1535 * For a recursive function, Unix 'gprof' lists the function as a 1536 parent and as a child, with a 'calls' field that lists the number 1537 of recursive calls. GNU 'gprof' omits these lines and puts the 1538 number of recursive calls in the primary line. 1539 1540 * When a function is suppressed from the call graph with '-e', GNU 1541 'gprof' still lists it as a subroutine of functions that call it. 1542 1543 * GNU 'gprof' accepts the '-k' with its argument in the form 1544 'from/to', instead of 'from to'. 1545 1546 * In the annotated source listing, if there are multiple basic blocks 1547 on the same line, GNU 'gprof' prints all of their counts, separated 1548 by commas. 1549 1550 * The blurbs, field widths, and output formats are different. GNU 1551 'gprof' prints blurbs after the tables, so that you can see the 1552 tables without skipping the blurbs. 1553 1554 1555File: gprof.info, Node: Details, Next: GNU Free Documentation License, Prev: Incompatibilities, Up: Top 1556 15579 Details of Profiling 1558********************** 1559 1560* Menu: 1561 1562* Implementation:: How a program collects profiling information 1563* File Format:: Format of 'gmon.out' files 1564* Internals:: 'gprof''s internal operation 1565* Debugging:: Using 'gprof''s '-d' option 1566 1567 1568File: gprof.info, Node: Implementation, Next: File Format, Up: Details 1569 15709.1 Implementation of Profiling 1571=============================== 1572 1573Profiling works by changing how every function in your program is 1574compiled so that when it is called, it will stash away some information 1575about where it was called from. From this, the profiler can figure out 1576what function called it, and can count how many times it was called. 1577This change is made by the compiler when your program is compiled with 1578the '-pg' option, which causes every function to call 'mcount' (or 1579'_mcount', or '__mcount', depending on the OS and compiler) as one of 1580its first operations. 1581 1582 The 'mcount' routine, included in the profiling library, is 1583responsible for recording in an in-memory call graph table both its 1584parent routine (the child) and its parent's parent. This is typically 1585done by examining the stack frame to find both the address of the child, 1586and the return address in the original parent. Since this is a very 1587machine-dependent operation, 'mcount' itself is typically a short 1588assembly-language stub routine that extracts the required information, 1589and then calls '__mcount_internal' (a normal C function) with two 1590arguments--'frompc' and 'selfpc'. '__mcount_internal' is responsible 1591for maintaining the in-memory call graph, which records 'frompc', 1592'selfpc', and the number of times each of these call arcs was traversed. 1593 1594 GCC Version 2 provides a magical function 1595('__builtin_return_address'), which allows a generic 'mcount' function 1596to extract the required information from the stack frame. However, on 1597some architectures, most notably the SPARC, using this builtin can be 1598very computationally expensive, and an assembly language version of 1599'mcount' is used for performance reasons. 1600 1601 Number-of-calls information for library routines is collected by 1602using a special version of the C library. The programs in it are the 1603same as in the usual C library, but they were compiled with '-pg'. If 1604you link your program with 'gcc ... -pg', it automatically uses the 1605profiling version of the library. 1606 1607 Profiling also involves watching your program as it runs, and keeping 1608a histogram of where the program counter happens to be every now and 1609then. Typically the program counter is looked at around 100 times per 1610second of run time, but the exact frequency may vary from system to 1611system. 1612 1613 This is done is one of two ways. Most UNIX-like operating systems 1614provide a 'profil()' system call, which registers a memory array with 1615the kernel, along with a scale factor that determines how the program's 1616address space maps into the array. Typical scaling values cause every 2 1617to 8 bytes of address space to map into a single array slot. On every 1618tick of the system clock (assuming the profiled program is running), the 1619value of the program counter is examined and the corresponding slot in 1620the memory array is incremented. Since this is done in the kernel, 1621which had to interrupt the process anyway to handle the clock interrupt, 1622very little additional system overhead is required. 1623 1624 However, some operating systems, most notably Linux 2.0 (and 1625earlier), do not provide a 'profil()' system call. On such a system, 1626arrangements are made for the kernel to periodically deliver a signal to 1627the process (typically via 'setitimer()'), which then performs the same 1628operation of examining the program counter and incrementing a slot in 1629the memory array. Since this method requires a signal to be delivered 1630to user space every time a sample is taken, it uses considerably more 1631overhead than kernel-based profiling. Also, due to the added delay 1632required to deliver the signal, this method is less accurate as well. 1633 1634 A special startup routine allocates memory for the histogram and 1635either calls 'profil()' or sets up a clock signal handler. This routine 1636('monstartup') can be invoked in several ways. On Linux systems, a 1637special profiling startup file 'gcrt0.o', which invokes 'monstartup' 1638before 'main', is used instead of the default 'crt0.o'. Use of this 1639special startup file is one of the effects of using 'gcc ... -pg' to 1640link. On SPARC systems, no special startup files are used. Rather, the 1641'mcount' routine, when it is invoked for the first time (typically when 1642'main' is called), calls 'monstartup'. 1643 1644 If the compiler's '-a' option was used, basic-block counting is also 1645enabled. Each object file is then compiled with a static array of 1646counts, initially zero. In the executable code, every time a new 1647basic-block begins (i.e., when an 'if' statement appears), an extra 1648instruction is inserted to increment the corresponding count in the 1649array. At compile time, a paired array was constructed that recorded 1650the starting address of each basic-block. Taken together, the two 1651arrays record the starting address of every basic-block, along with the 1652number of times it was executed. 1653 1654 The profiling library also includes a function ('mcleanup') which is 1655typically registered using 'atexit()' to be called as the program exits, 1656and is responsible for writing the file 'gmon.out'. Profiling is turned 1657off, various headers are output, and the histogram is written, followed 1658by the call-graph arcs and the basic-block counts. 1659 1660 The output from 'gprof' gives no indication of parts of your program 1661that are limited by I/O or swapping bandwidth. This is because samples 1662of the program counter are taken at fixed intervals of the program's run 1663time. Therefore, the time measurements in 'gprof' output say nothing 1664about time that your program was not running. For example, a part of 1665the program that creates so much data that it cannot all fit in physical 1666memory at once may run very slowly due to thrashing, but 'gprof' will 1667say it uses little time. On the other hand, sampling by run time has 1668the advantage that the amount of load due to other users won't directly 1669affect the output you get. 1670 1671 1672File: gprof.info, Node: File Format, Next: Internals, Prev: Implementation, Up: Details 1673 16749.2 Profiling Data File Format 1675============================== 1676 1677The old BSD-derived file format used for profile data does not contain a 1678magic cookie that allows to check whether a data file really is a 1679'gprof' file. Furthermore, it does not provide a version number, thus 1680rendering changes to the file format almost impossible. GNU 'gprof' 1681uses a new file format that provides these features. For backward 1682compatibility, GNU 'gprof' continues to support the old BSD-derived 1683format, but not all features are supported with it. For example, 1684basic-block execution counts cannot be accommodated by the old file 1685format. 1686 1687 The new file format is defined in header file 'gmon_out.h'. It 1688consists of a header containing the magic cookie and a version number, 1689as well as some spare bytes available for future extensions. All data 1690in a profile data file is in the native format of the target for which 1691the profile was collected. GNU 'gprof' adapts automatically to the 1692byte-order in use. 1693 1694 In the new file format, the header is followed by a sequence of 1695records. Currently, there are three different record types: histogram 1696records, call-graph arc records, and basic-block execution count 1697records. Each file can contain any number of each record type. When 1698reading a file, GNU 'gprof' will ensure records of the same type are 1699compatible with each other and compute the union of all records. For 1700example, for basic-block execution counts, the union is simply the sum 1701of all execution counts for each basic-block. 1702 17039.2.1 Histogram Records 1704----------------------- 1705 1706Histogram records consist of a header that is followed by an array of 1707bins. The header contains the text-segment range that the histogram 1708spans, the size of the histogram in bytes (unlike in the old BSD format, 1709this does not include the size of the header), the rate of the profiling 1710clock, and the physical dimension that the bin counts represent after 1711being scaled by the profiling clock rate. The physical dimension is 1712specified in two parts: a long name of up to 15 characters and a single 1713character abbreviation. For example, a histogram representing real-time 1714would specify the long name as "seconds" and the abbreviation as "s". 1715This feature is useful for architectures that support performance 1716monitor hardware (which, fortunately, is becoming increasingly common). 1717For example, under DEC OSF/1, the "uprofile" command can be used to 1718produce a histogram of, say, instruction cache misses. In this case, 1719the dimension in the histogram header could be set to "i-cache misses" 1720and the abbreviation could be set to "1" (because it is simply a count, 1721not a physical dimension). Also, the profiling rate would have to be 1722set to 1 in this case. 1723 1724 Histogram bins are 16-bit numbers and each bin represent an equal 1725amount of text-space. For example, if the text-segment is one thousand 1726bytes long and if there are ten bins in the histogram, each bin 1727represents one hundred bytes. 1728 17299.2.2 Call-Graph Records 1730------------------------ 1731 1732Call-graph records have a format that is identical to the one used in 1733the BSD-derived file format. It consists of an arc in the call graph 1734and a count indicating the number of times the arc was traversed during 1735program execution. Arcs are specified by a pair of addresses: the first 1736must be within caller's function and the second must be within the 1737callee's function. When performing profiling at the function level, 1738these addresses can point anywhere within the respective function. 1739However, when profiling at the line-level, it is better if the addresses 1740are as close to the call-site/entry-point as possible. This will ensure 1741that the line-level call-graph is able to identify exactly which line of 1742source code performed calls to a function. 1743 17449.2.3 Basic-Block Execution Count Records 1745----------------------------------------- 1746 1747Basic-block execution count records consist of a header followed by a 1748sequence of address/count pairs. The header simply specifies the length 1749of the sequence. In an address/count pair, the address identifies a 1750basic-block and the count specifies the number of times that basic-block 1751was executed. Any address within the basic-address can be used. 1752 1753 1754File: gprof.info, Node: Internals, Next: Debugging, Prev: File Format, Up: Details 1755 17569.3 'gprof''s Internal Operation 1757================================ 1758 1759Like most programs, 'gprof' begins by processing its options. During 1760this stage, it may building its symspec list ('sym_ids.c:sym_id_add'), 1761if options are specified which use symspecs. 'gprof' maintains a single 1762linked list of symspecs, which will eventually get turned into 12 symbol 1763tables, organized into six include/exclude pairs--one pair each for the 1764flat profile (INCL_FLAT/EXCL_FLAT), the call graph arcs 1765(INCL_ARCS/EXCL_ARCS), printing in the call graph 1766(INCL_GRAPH/EXCL_GRAPH), timing propagation in the call graph 1767(INCL_TIME/EXCL_TIME), the annotated source listing 1768(INCL_ANNO/EXCL_ANNO), and the execution count listing 1769(INCL_EXEC/EXCL_EXEC). 1770 1771 After option processing, 'gprof' finishes building the symspec list 1772by adding all the symspecs in 'default_excluded_list' to the exclude 1773lists EXCL_TIME and EXCL_GRAPH, and if line-by-line profiling is 1774specified, EXCL_FLAT as well. These default excludes are not added to 1775EXCL_ANNO, EXCL_ARCS, and EXCL_EXEC. 1776 1777 Next, the BFD library is called to open the object file, verify that 1778it is an object file, and read its symbol table ('core.c:core_init'), 1779using 'bfd_canonicalize_symtab' after mallocing an appropriately sized 1780array of symbols. At this point, function mappings are read (if the 1781'--file-ordering' option has been specified), and the core text space is 1782read into memory (if the '-c' option was given). 1783 1784 'gprof''s own symbol table, an array of Sym structures, is now built. 1785This is done in one of two ways, by one of two routines, depending on 1786whether line-by-line profiling ('-l' option) has been enabled. For 1787normal profiling, the BFD canonical symbol table is scanned. For 1788line-by-line profiling, every text space address is examined, and a new 1789symbol table entry gets created every time the line number changes. In 1790either case, two passes are made through the symbol table--one to count 1791the size of the symbol table required, and the other to actually read 1792the symbols. In between the two passes, a single array of type 'Sym' is 1793created of the appropriate length. Finally, 'symtab.c:symtab_finalize' 1794is called to sort the symbol table and remove duplicate entries (entries 1795with the same memory address). 1796 1797 The symbol table must be a contiguous array for two reasons. First, 1798the 'qsort' library function (which sorts an array) will be used to sort 1799the symbol table. Also, the symbol lookup routine 1800('symtab.c:sym_lookup'), which finds symbols based on memory address, 1801uses a binary search algorithm which requires the symbol table to be a 1802sorted array. Function symbols are indicated with an 'is_func' flag. 1803Line number symbols have no special flags set. Additionally, a symbol 1804can have an 'is_static' flag to indicate that it is a local symbol. 1805 1806 With the symbol table read, the symspecs can now be translated into 1807Syms ('sym_ids.c:sym_id_parse'). Remember that a single symspec can 1808match multiple symbols. An array of symbol tables ('syms') is created, 1809each entry of which is a symbol table of Syms to be included or excluded 1810from a particular listing. The master symbol table and the symspecs are 1811examined by nested loops, and every symbol that matches a symspec is 1812inserted into the appropriate syms table. This is done twice, once to 1813count the size of each required symbol table, and again to build the 1814tables, which have been malloced between passes. From now on, to 1815determine whether a symbol is on an include or exclude symspec list, 1816'gprof' simply uses its standard symbol lookup routine on the 1817appropriate table in the 'syms' array. 1818 1819 Now the profile data file(s) themselves are read 1820('gmon_io.c:gmon_out_read'), first by checking for a new-style 1821'gmon.out' header, then assuming this is an old-style BSD 'gmon.out' if 1822the magic number test failed. 1823 1824 New-style histogram records are read by 'hist.c:hist_read_rec'. For 1825the first histogram record, allocate a memory array to hold all the 1826bins, and read them in. When multiple profile data files (or files with 1827multiple histogram records) are read, the memory ranges of each pair of 1828histogram records must be either equal, or non-overlapping. For each 1829pair of histogram records, the resolution (memory region size divided by 1830the number of bins) must be the same. The time unit must be the same 1831for all histogram records. If the above containts are met, all 1832histograms for the same memory range are merged. 1833 1834 As each call graph record is read ('call_graph.c:cg_read_rec'), the 1835parent and child addresses are matched to symbol table entries, and a 1836call graph arc is created by 'cg_arcs.c:arc_add', unless the arc fails a 1837symspec check against INCL_ARCS/EXCL_ARCS. As each arc is added, a 1838linked list is maintained of the parent's child arcs, and of the child's 1839parent arcs. Both the child's call count and the arc's call count are 1840incremented by the record's call count. 1841 1842 Basic-block records are read ('basic_blocks.c:bb_read_rec'), but only 1843if line-by-line profiling has been selected. Each basic-block address 1844is matched to a corresponding line symbol in the symbol table, and an 1845entry made in the symbol's bb_addr and bb_calls arrays. Again, if 1846multiple basic-block records are present for the same address, the call 1847counts are cumulative. 1848 1849 A gmon.sum file is dumped, if requested ('gmon_io.c:gmon_out_write'). 1850 1851 If histograms were present in the data files, assign them to symbols 1852('hist.c:hist_assign_samples') by iterating over all the sample bins and 1853assigning them to symbols. Since the symbol table is sorted in order of 1854ascending memory addresses, we can simple follow along in the symbol 1855table as we make our pass over the sample bins. This step includes a 1856symspec check against INCL_FLAT/EXCL_FLAT. Depending on the histogram 1857scale factor, a sample bin may span multiple symbols, in which case a 1858fraction of the sample count is allocated to each symbol, proportional 1859to the degree of overlap. This effect is rare for normal profiling, but 1860overlaps are more common during line-by-line profiling, and can cause 1861each of two adjacent lines to be credited with half a hit, for example. 1862 1863 If call graph data is present, 'cg_arcs.c:cg_assemble' is called. 1864First, if '-c' was specified, a machine-dependent routine ('find_call') 1865scans through each symbol's machine code, looking for subroutine call 1866instructions, and adding them to the call graph with a zero call count. 1867A topological sort is performed by depth-first numbering all the symbols 1868('cg_dfn.c:cg_dfn'), so that children are always numbered less than 1869their parents, then making a array of pointers into the symbol table and 1870sorting it into numerical order, which is reverse topological order 1871(children appear before parents). Cycles are also detected at this 1872point, all members of which are assigned the same topological number. 1873Two passes are now made through this sorted array of symbol pointers. 1874The first pass, from end to beginning (parents to children), computes 1875the fraction of child time to propagate to each parent and a print flag. 1876The print flag reflects symspec handling of INCL_GRAPH/EXCL_GRAPH, with 1877a parent's include or exclude (print or no print) property being 1878propagated to its children, unless they themselves explicitly appear in 1879INCL_GRAPH or EXCL_GRAPH. A second pass, from beginning to end (children 1880to parents) actually propagates the timings along the call graph, 1881subject to a check against INCL_TIME/EXCL_TIME. With the print flag, 1882fractions, and timings now stored in the symbol structures, the 1883topological sort array is now discarded, and a new array of pointers is 1884assembled, this time sorted by propagated time. 1885 1886 Finally, print the various outputs the user requested, which is now 1887fairly straightforward. The call graph ('cg_print.c:cg_print') and flat 1888profile ('hist.c:hist_print') are regurgitations of values already 1889computed. The annotated source listing 1890('basic_blocks.c:print_annotated_source') uses basic-block information, 1891if present, to label each line of code with call counts, otherwise only 1892the function call counts are presented. 1893 1894 The function ordering code is marginally well documented in the 1895source code itself ('cg_print.c'). Basically, the functions with the 1896most use and the most parents are placed first, followed by other 1897functions with the most use, followed by lower use functions, followed 1898by unused functions at the end. 1899 1900 1901File: gprof.info, Node: Debugging, Prev: Internals, Up: Details 1902 19039.4 Debugging 'gprof' 1904===================== 1905 1906If 'gprof' was compiled with debugging enabled, the '-d' option triggers 1907debugging output (to stdout) which can be helpful in understanding its 1908operation. The debugging number specified is interpreted as a sum of 1909the following options: 1910 19112 - Topological sort 1912 Monitor depth-first numbering of symbols during call graph analysis 19134 - Cycles 1914 Shows symbols as they are identified as cycle heads 191516 - Tallying 1916 As the call graph arcs are read, show each arc and how the total 1917 calls to each function are tallied 191832 - Call graph arc sorting 1919 Details sorting individual parents/children within each call graph 1920 entry 192164 - Reading histogram and call graph records 1922 Shows address ranges of histograms as they are read, and each call 1923 graph arc 1924128 - Symbol table 1925 Reading, classifying, and sorting the symbol table from the object 1926 file. For line-by-line profiling ('-l' option), also shows line 1927 numbers being assigned to memory addresses. 1928256 - Static call graph 1929 Trace operation of '-c' option 1930512 - Symbol table and arc table lookups 1931 Detail operation of lookup routines 19321024 - Call graph propagation 1933 Shows how function times are propagated along the call graph 19342048 - Basic-blocks 1935 Shows basic-block records as they are read from profile data (only 1936 meaningful with '-l' option) 19374096 - Symspecs 1938 Shows symspec-to-symbol pattern matching operation 19398192 - Annotate source 1940 Tracks operation of '-A' option 1941 1942 1943File: gprof.info, Node: GNU Free Documentation License, Prev: Details, Up: Top 1944 1945Appendix A GNU Free Documentation License 1946***************************************** 1947 1948 Version 1.3, 3 November 2008 1949 1950 Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc. 1951 <http://fsf.org/> 1952 1953 Everyone is permitted to copy and distribute verbatim copies 1954 of this license document, but changing it is not allowed. 1955 1956 0. PREAMBLE 1957 1958 The purpose of this License is to make a manual, textbook, or other 1959 functional and useful document "free" in the sense of freedom: to 1960 assure everyone the effective freedom to copy and redistribute it, 1961 with or without modifying it, either commercially or 1962 noncommercially. Secondarily, this License preserves for the 1963 author and publisher a way to get credit for their work, while not 1964 being considered responsible for modifications made by others. 1965 1966 This License is a kind of "copyleft", which means that derivative 1967 works of the document must themselves be free in the same sense. 1968 It complements the GNU General Public License, which is a copyleft 1969 license designed for free software. 1970 1971 We have designed this License in order to use it for manuals for 1972 free software, because free software needs free documentation: a 1973 free program should come with manuals providing the same freedoms 1974 that the software does. But this License is not limited to 1975 software manuals; it can be used for any textual work, regardless 1976 of subject matter or whether it is published as a printed book. We 1977 recommend this License principally for works whose purpose is 1978 instruction or reference. 1979 1980 1. APPLICABILITY AND DEFINITIONS 1981 1982 This License applies to any manual or other work, in any medium, 1983 that contains a notice placed by the copyright holder saying it can 1984 be distributed under the terms of this License. Such a notice 1985 grants a world-wide, royalty-free license, unlimited in duration, 1986 to use that work under the conditions stated herein. The 1987 "Document", below, refers to any such manual or work. Any member 1988 of the public is a licensee, and is addressed as "you". You accept 1989 the license if you copy, modify or distribute the work in a way 1990 requiring permission under copyright law. 1991 1992 A "Modified Version" of the Document means any work containing the 1993 Document or a portion of it, either copied verbatim, or with 1994 modifications and/or translated into another language. 1995 1996 A "Secondary Section" is a named appendix or a front-matter section 1997 of the Document that deals exclusively with the relationship of the 1998 publishers or authors of the Document to the Document's overall 1999 subject (or to related matters) and contains nothing that could 2000 fall directly within that overall subject. (Thus, if the Document 2001 is in part a textbook of mathematics, a Secondary Section may not 2002 explain any mathematics.) The relationship could be a matter of 2003 historical connection with the subject or with related matters, or 2004 of legal, commercial, philosophical, ethical or political position 2005 regarding them. 2006 2007 The "Invariant Sections" are certain Secondary Sections whose 2008 titles are designated, as being those of Invariant Sections, in the 2009 notice that says that the Document is released under this License. 2010 If a section does not fit the above definition of Secondary then it 2011 is not allowed to be designated as Invariant. The Document may 2012 contain zero Invariant Sections. If the Document does not identify 2013 any Invariant Sections then there are none. 2014 2015 The "Cover Texts" are certain short passages of text that are 2016 listed, as Front-Cover Texts or Back-Cover Texts, in the notice 2017 that says that the Document is released under this License. A 2018 Front-Cover Text may be at most 5 words, and a Back-Cover Text may 2019 be at most 25 words. 2020 2021 A "Transparent" copy of the Document means a machine-readable copy, 2022 represented in a format whose specification is available to the 2023 general public, that is suitable for revising the document 2024 straightforwardly with generic text editors or (for images composed 2025 of pixels) generic paint programs or (for drawings) some widely 2026 available drawing editor, and that is suitable for input to text 2027 formatters or for automatic translation to a variety of formats 2028 suitable for input to text formatters. A copy made in an otherwise 2029 Transparent file format whose markup, or absence of markup, has 2030 been arranged to thwart or discourage subsequent modification by 2031 readers is not Transparent. An image format is not Transparent if 2032 used for any substantial amount of text. A copy that is not 2033 "Transparent" is called "Opaque". 2034 2035 Examples of suitable formats for Transparent copies include plain 2036 ASCII without markup, Texinfo input format, LaTeX input format, 2037 SGML or XML using a publicly available DTD, and standard-conforming 2038 simple HTML, PostScript or PDF designed for human modification. 2039 Examples of transparent image formats include PNG, XCF and JPG. 2040 Opaque formats include proprietary formats that can be read and 2041 edited only by proprietary word processors, SGML or XML for which 2042 the DTD and/or processing tools are not generally available, and 2043 the machine-generated HTML, PostScript or PDF produced by some word 2044 processors for output purposes only. 2045 2046 The "Title Page" means, for a printed book, the title page itself, 2047 plus such following pages as are needed to hold, legibly, the 2048 material this License requires to appear in the title page. For 2049 works in formats which do not have any title page as such, "Title 2050 Page" means the text near the most prominent appearance of the 2051 work's title, preceding the beginning of the body of the text. 2052 2053 The "publisher" means any person or entity that distributes copies 2054 of the Document to the public. 2055 2056 A section "Entitled XYZ" means a named subunit of the Document 2057 whose title either is precisely XYZ or contains XYZ in parentheses 2058 following text that translates XYZ in another language. (Here XYZ 2059 stands for a specific section name mentioned below, such as 2060 "Acknowledgements", "Dedications", "Endorsements", or "History".) 2061 To "Preserve the Title" of such a section when you modify the 2062 Document means that it remains a section "Entitled XYZ" according 2063 to this definition. 2064 2065 The Document may include Warranty Disclaimers next to the notice 2066 which states that this License applies to the Document. These 2067 Warranty Disclaimers are considered to be included by reference in 2068 this License, but only as regards disclaiming warranties: any other 2069 implication that these Warranty Disclaimers may have is void and 2070 has no effect on the meaning of this License. 2071 2072 2. VERBATIM COPYING 2073 2074 You may copy and distribute the Document in any medium, either 2075 commercially or noncommercially, provided that this License, the 2076 copyright notices, and the license notice saying this License 2077 applies to the Document are reproduced in all copies, and that you 2078 add no other conditions whatsoever to those of this License. You 2079 may not use technical measures to obstruct or control the reading 2080 or further copying of the copies you make or distribute. However, 2081 you may accept compensation in exchange for copies. If you 2082 distribute a large enough number of copies you must also follow the 2083 conditions in section 3. 2084 2085 You may also lend copies, under the same conditions stated above, 2086 and you may publicly display copies. 2087 2088 3. COPYING IN QUANTITY 2089 2090 If you publish printed copies (or copies in media that commonly 2091 have printed covers) of the Document, numbering more than 100, and 2092 the Document's license notice requires Cover Texts, you must 2093 enclose the copies in covers that carry, clearly and legibly, all 2094 these Cover Texts: Front-Cover Texts on the front cover, and 2095 Back-Cover Texts on the back cover. Both covers must also clearly 2096 and legibly identify you as the publisher of these copies. The 2097 front cover must present the full title with all words of the title 2098 equally prominent and visible. You may add other material on the 2099 covers in addition. Copying with changes limited to the covers, as 2100 long as they preserve the title of the Document and satisfy these 2101 conditions, can be treated as verbatim copying in other respects. 2102 2103 If the required texts for either cover are too voluminous to fit 2104 legibly, you should put the first ones listed (as many as fit 2105 reasonably) on the actual cover, and continue the rest onto 2106 adjacent pages. 2107 2108 If you publish or distribute Opaque copies of the Document 2109 numbering more than 100, you must either include a machine-readable 2110 Transparent copy along with each Opaque copy, or state in or with 2111 each Opaque copy a computer-network location from which the general 2112 network-using public has access to download using public-standard 2113 network protocols a complete Transparent copy of the Document, free 2114 of added material. If you use the latter option, you must take 2115 reasonably prudent steps, when you begin distribution of Opaque 2116 copies in quantity, to ensure that this Transparent copy will 2117 remain thus accessible at the stated location until at least one 2118 year after the last time you distribute an Opaque copy (directly or 2119 through your agents or retailers) of that edition to the public. 2120 2121 It is requested, but not required, that you contact the authors of 2122 the Document well before redistributing any large number of copies, 2123 to give them a chance to provide you with an updated version of the 2124 Document. 2125 2126 4. MODIFICATIONS 2127 2128 You may copy and distribute a Modified Version of the Document 2129 under the conditions of sections 2 and 3 above, provided that you 2130 release the Modified Version under precisely this License, with the 2131 Modified Version filling the role of the Document, thus licensing 2132 distribution and modification of the Modified Version to whoever 2133 possesses a copy of it. In addition, you must do these things in 2134 the Modified Version: 2135 2136 A. Use in the Title Page (and on the covers, if any) a title 2137 distinct from that of the Document, and from those of previous 2138 versions (which should, if there were any, be listed in the 2139 History section of the Document). You may use the same title 2140 as a previous version if the original publisher of that 2141 version gives permission. 2142 2143 B. List on the Title Page, as authors, one or more persons or 2144 entities responsible for authorship of the modifications in 2145 the Modified Version, together with at least five of the 2146 principal authors of the Document (all of its principal 2147 authors, if it has fewer than five), unless they release you 2148 from this requirement. 2149 2150 C. State on the Title page the name of the publisher of the 2151 Modified Version, as the publisher. 2152 2153 D. Preserve all the copyright notices of the Document. 2154 2155 E. Add an appropriate copyright notice for your modifications 2156 adjacent to the other copyright notices. 2157 2158 F. Include, immediately after the copyright notices, a license 2159 notice giving the public permission to use the Modified 2160 Version under the terms of this License, in the form shown in 2161 the Addendum below. 2162 2163 G. Preserve in that license notice the full lists of Invariant 2164 Sections and required Cover Texts given in the Document's 2165 license notice. 2166 2167 H. Include an unaltered copy of this License. 2168 2169 I. Preserve the section Entitled "History", Preserve its Title, 2170 and add to it an item stating at least the title, year, new 2171 authors, and publisher of the Modified Version as given on the 2172 Title Page. If there is no section Entitled "History" in the 2173 Document, create one stating the title, year, authors, and 2174 publisher of the Document as given on its Title Page, then add 2175 an item describing the Modified Version as stated in the 2176 previous sentence. 2177 2178 J. Preserve the network location, if any, given in the Document 2179 for public access to a Transparent copy of the Document, and 2180 likewise the network locations given in the Document for 2181 previous versions it was based on. These may be placed in the 2182 "History" section. You may omit a network location for a work 2183 that was published at least four years before the Document 2184 itself, or if the original publisher of the version it refers 2185 to gives permission. 2186 2187 K. For any section Entitled "Acknowledgements" or "Dedications", 2188 Preserve the Title of the section, and preserve in the section 2189 all the substance and tone of each of the contributor 2190 acknowledgements and/or dedications given therein. 2191 2192 L. Preserve all the Invariant Sections of the Document, unaltered 2193 in their text and in their titles. Section numbers or the 2194 equivalent are not considered part of the section titles. 2195 2196 M. Delete any section Entitled "Endorsements". Such a section 2197 may not be included in the Modified Version. 2198 2199 N. Do not retitle any existing section to be Entitled 2200 "Endorsements" or to conflict in title with any Invariant 2201 Section. 2202 2203 O. Preserve any Warranty Disclaimers. 2204 2205 If the Modified Version includes new front-matter sections or 2206 appendices that qualify as Secondary Sections and contain no 2207 material copied from the Document, you may at your option designate 2208 some or all of these sections as invariant. To do this, add their 2209 titles to the list of Invariant Sections in the Modified Version's 2210 license notice. These titles must be distinct from any other 2211 section titles. 2212 2213 You may add a section Entitled "Endorsements", provided it contains 2214 nothing but endorsements of your Modified Version by various 2215 parties--for example, statements of peer review or that the text 2216 has been approved by an organization as the authoritative 2217 definition of a standard. 2218 2219 You may add a passage of up to five words as a Front-Cover Text, 2220 and a passage of up to 25 words as a Back-Cover Text, to the end of 2221 the list of Cover Texts in the Modified Version. Only one passage 2222 of Front-Cover Text and one of Back-Cover Text may be added by (or 2223 through arrangements made by) any one entity. If the Document 2224 already includes a cover text for the same cover, previously added 2225 by you or by arrangement made by the same entity you are acting on 2226 behalf of, you may not add another; but you may replace the old 2227 one, on explicit permission from the previous publisher that added 2228 the old one. 2229 2230 The author(s) and publisher(s) of the Document do not by this 2231 License give permission to use their names for publicity for or to 2232 assert or imply endorsement of any Modified Version. 2233 2234 5. COMBINING DOCUMENTS 2235 2236 You may combine the Document with other documents released under 2237 this License, under the terms defined in section 4 above for 2238 modified versions, provided that you include in the combination all 2239 of the Invariant Sections of all of the original documents, 2240 unmodified, and list them all as Invariant Sections of your 2241 combined work in its license notice, and that you preserve all 2242 their Warranty Disclaimers. 2243 2244 The combined work need only contain one copy of this License, and 2245 multiple identical Invariant Sections may be replaced with a single 2246 copy. If there are multiple Invariant Sections with the same name 2247 but different contents, make the title of each such section unique 2248 by adding at the end of it, in parentheses, the name of the 2249 original author or publisher of that section if known, or else a 2250 unique number. Make the same adjustment to the section titles in 2251 the list of Invariant Sections in the license notice of the 2252 combined work. 2253 2254 In the combination, you must combine any sections Entitled 2255 "History" in the various original documents, forming one section 2256 Entitled "History"; likewise combine any sections Entitled 2257 "Acknowledgements", and any sections Entitled "Dedications". You 2258 must delete all sections Entitled "Endorsements." 2259 2260 6. COLLECTIONS OF DOCUMENTS 2261 2262 You may make a collection consisting of the Document and other 2263 documents released under this License, and replace the individual 2264 copies of this License in the various documents with a single copy 2265 that is included in the collection, provided that you follow the 2266 rules of this License for verbatim copying of each of the documents 2267 in all other respects. 2268 2269 You may extract a single document from such a collection, and 2270 distribute it individually under this License, provided you insert 2271 a copy of this License into the extracted document, and follow this 2272 License in all other respects regarding verbatim copying of that 2273 document. 2274 2275 7. AGGREGATION WITH INDEPENDENT WORKS 2276 2277 A compilation of the Document or its derivatives with other 2278 separate and independent documents or works, in or on a volume of a 2279 storage or distribution medium, is called an "aggregate" if the 2280 copyright resulting from the compilation is not used to limit the 2281 legal rights of the compilation's users beyond what the individual 2282 works permit. When the Document is included in an aggregate, this 2283 License does not apply to the other works in the aggregate which 2284 are not themselves derivative works of the Document. 2285 2286 If the Cover Text requirement of section 3 is applicable to these 2287 copies of the Document, then if the Document is less than one half 2288 of the entire aggregate, the Document's Cover Texts may be placed 2289 on covers that bracket the Document within the aggregate, or the 2290 electronic equivalent of covers if the Document is in electronic 2291 form. Otherwise they must appear on printed covers that bracket 2292 the whole aggregate. 2293 2294 8. TRANSLATION 2295 2296 Translation is considered a kind of modification, so you may 2297 distribute translations of the Document under the terms of section 2298 4. Replacing Invariant Sections with translations requires special 2299 permission from their copyright holders, but you may include 2300 translations of some or all Invariant Sections in addition to the 2301 original versions of these Invariant Sections. You may include a 2302 translation of this License, and all the license notices in the 2303 Document, and any Warranty Disclaimers, provided that you also 2304 include the original English version of this License and the 2305 original versions of those notices and disclaimers. In case of a 2306 disagreement between the translation and the original version of 2307 this License or a notice or disclaimer, the original version will 2308 prevail. 2309 2310 If a section in the Document is Entitled "Acknowledgements", 2311 "Dedications", or "History", the requirement (section 4) to 2312 Preserve its Title (section 1) will typically require changing the 2313 actual title. 2314 2315 9. TERMINATION 2316 2317 You may not copy, modify, sublicense, or distribute the Document 2318 except as expressly provided under this License. Any attempt 2319 otherwise to copy, modify, sublicense, or distribute it is void, 2320 and will automatically terminate your rights under this License. 2321 2322 However, if you cease all violation of this License, then your 2323 license from a particular copyright holder is reinstated (a) 2324 provisionally, unless and until the copyright holder explicitly and 2325 finally terminates your license, and (b) permanently, if the 2326 copyright holder fails to notify you of the violation by some 2327 reasonable means prior to 60 days after the cessation. 2328 2329 Moreover, your license from a particular copyright holder is 2330 reinstated permanently if the copyright holder notifies you of the 2331 violation by some reasonable means, this is the first time you have 2332 received notice of violation of this License (for any work) from 2333 that copyright holder, and you cure the violation prior to 30 days 2334 after your receipt of the notice. 2335 2336 Termination of your rights under this section does not terminate 2337 the licenses of parties who have received copies or rights from you 2338 under this License. If your rights have been terminated and not 2339 permanently reinstated, receipt of a copy of some or all of the 2340 same material does not give you any rights to use it. 2341 2342 10. FUTURE REVISIONS OF THIS LICENSE 2343 2344 The Free Software Foundation may publish new, revised versions of 2345 the GNU Free Documentation License from time to time. Such new 2346 versions will be similar in spirit to the present version, but may 2347 differ in detail to address new problems or concerns. See 2348 <http://www.gnu.org/copyleft/>. 2349 2350 Each version of the License is given a distinguishing version 2351 number. If the Document specifies that a particular numbered 2352 version of this License "or any later version" applies to it, you 2353 have the option of following the terms and conditions either of 2354 that specified version or of any later version that has been 2355 published (not as a draft) by the Free Software Foundation. If the 2356 Document does not specify a version number of this License, you may 2357 choose any version ever published (not as a draft) by the Free 2358 Software Foundation. If the Document specifies that a proxy can 2359 decide which future versions of this License can be used, that 2360 proxy's public statement of acceptance of a version permanently 2361 authorizes you to choose that version for the Document. 2362 2363 11. RELICENSING 2364 2365 "Massive Multiauthor Collaboration Site" (or "MMC Site") means any 2366 World Wide Web server that publishes copyrightable works and also 2367 provides prominent facilities for anybody to edit those works. A 2368 public wiki that anybody can edit is an example of such a server. 2369 A "Massive Multiauthor Collaboration" (or "MMC") contained in the 2370 site means any set of copyrightable works thus published on the MMC 2371 site. 2372 2373 "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0 2374 license published by Creative Commons Corporation, a not-for-profit 2375 corporation with a principal place of business in San Francisco, 2376 California, as well as future copyleft versions of that license 2377 published by that same organization. 2378 2379 "Incorporate" means to publish or republish a Document, in whole or 2380 in part, as part of another Document. 2381 2382 An MMC is "eligible for relicensing" if it is licensed under this 2383 License, and if all works that were first published under this 2384 License somewhere other than this MMC, and subsequently 2385 incorporated in whole or in part into the MMC, (1) had no cover 2386 texts or invariant sections, and (2) were thus incorporated prior 2387 to November 1, 2008. 2388 2389 The operator of an MMC Site may republish an MMC contained in the 2390 site under CC-BY-SA on the same site at any time before August 1, 2391 2009, provided the MMC is eligible for relicensing. 2392 2393ADDENDUM: How to use this License for your documents 2394==================================================== 2395 2396To use this License in a document you have written, include a copy of 2397the License in the document and put the following copyright and license 2398notices just after the title page: 2399 2400 Copyright (C) YEAR YOUR NAME. 2401 Permission is granted to copy, distribute and/or modify this document 2402 under the terms of the GNU Free Documentation License, Version 1.3 2403 or any later version published by the Free Software Foundation; 2404 with no Invariant Sections, no Front-Cover Texts, and no Back-Cover 2405 Texts. A copy of the license is included in the section entitled ``GNU 2406 Free Documentation License''. 2407 2408 If you have Invariant Sections, Front-Cover Texts and Back-Cover 2409Texts, replace the "with...Texts." line with this: 2410 2411 with the Invariant Sections being LIST THEIR TITLES, with 2412 the Front-Cover Texts being LIST, and with the Back-Cover Texts 2413 being LIST. 2414 2415 If you have Invariant Sections without Cover Texts, or some other 2416combination of the three, merge those two alternatives to suit the 2417situation. 2418 2419 If your document contains nontrivial examples of program code, we 2420recommend releasing these examples in parallel under your choice of free 2421software license, such as the GNU General Public License, to permit 2422their use in free software. 2423 2424 2425 2426Tag Table: 2427Node: Top719 2428Node: Introduction2042 2429Node: Compiling4533 2430Node: Executing8589 2431Node: Invoking11377 2432Node: Output Options12792 2433Node: Analysis Options19884 2434Node: Miscellaneous Options23804 2435Node: Deprecated Options25058 2436Node: Symspecs27121 2437Node: Output28947 2438Node: Flat Profile29987 2439Node: Call Graph34940 2440Node: Primary38172 2441Node: Callers40760 2442Node: Subroutines42878 2443Node: Cycles44719 2444Node: Line-by-line51496 2445Node: Annotated Source55572 2446Node: Inaccuracy58570 2447Node: Sampling Error58828 2448Node: Assumptions61732 2449Node: How do I?63202 2450Node: Incompatibilities64759 2451Node: Details66253 2452Node: Implementation66646 2453Node: File Format72545 2454Node: Internals76833 2455Node: Debugging85323 2456Node: GNU Free Documentation License86913 2457 2458End Tag Table 2459