Lines Matching full:calls
99 function calls that use a lot of time. *Note The Call Graph: Call
150 time seconds seconds calls Ts/call Ts/call name
161 you number-of-calls information for standard library functions such as
172 (except that the `calls' field for the functions will be blank), but
185 `-finstrument-functions' command line option which will insert calls to
223 directory_ at the time it exits. This means that if your program calls
474 spent in these functions, calls to/from them, etc., will all be
483 object file and identifies function calls in the binary machine
486 have been called, but never were. Calls to functions that were
488 if symbol table entries are present for them. Calls to dynamic
700 when its subroutine calls are included.
713 with no apparent time spent in them, and no apparent calls to them, are
724 time seconds seconds calls ms/call ms/call name
742 then by decreasing number of calls, then alphabetically by name. The
766 they are listed, sorted in decreasing order by the `calls' field.
786 `calls'
790 compiled with profiling enabled), the "calls" field is blank.
806 this field alphabetically after the "self seconds" and "calls"
873 such as `a' calls `b' calls `a'...
920 This is the total amount of time spent in the subroutine calls
929 separated by a `+'. The first number counts non-recursive calls,
930 and the second counts recursive calls.
978 amount of time spent within calls to `report' from `main'.
982 followed by the total number of non-recursive calls to `report'
992 of the functions it calls.
1033 total time spent in calls to `report' from `main'.
1036 Two numbers, the number of calls to `report' from `main' followed
1037 by the total number of non-recursive calls to `report'. This
1056 in the call graph. A cycle exists if a function calls another function
1057 that (directly or indirectly) calls (or appears to call) the original
1058 function. For example: if `a' calls `b', and `b' calls `a', then `a'
1064 `b' only calls `a' if it was not called from `a', `gprof' cannot
1110 for `main', which calls `a', and an entry for `c', with callers `a' and
1150 lines count only subroutines outside the cycle. Even though `a' calls
1151 `b', the time spent in those calls to `b' is not counted in `a''s
1153 calls to `b' includes indirect recursive calls
1165 the cycle calls itself). This is a generalization of the usual split
1166 into non-recursive and recursive calls.
1207 13327 calls to `init_block'.
1213 time seconds seconds calls us/call us/call name
1234 note how `ct_init''s 13327 calls to `init_block' are broken down into
1235 one call from line 396, 3071 calls from line 384, 3730 calls from line
1236 385, and 6525 calls from 387.
1242 time seconds seconds calls name
1374 By contrast, the number-of-calls and basic-block figures are derived
1438 used 5 seconds in all, and 2/5 of the calls to `foo' came from `a',
1446 all the time spent in `foo' is in the calls from callers other than `a'.
1465 of calls to smaller ones. Beware however that this can introduce
1467 overhead to function calls. An alternative solution is to use a
1511 parent and as a child, with a `calls' field that lists the number
1512 of recursive calls. GNU `gprof' omits these lines and puts the
1513 number of recursive calls in the primary line.
1564 and then calls `__mcount_internal' (a normal C function) with two
1576 Number-of-calls information for library routines is collected by
1611 either calls `profil()' or sets up a clock signal handler. This
1618 (typically when `main' is called), calls `monstartup'.
1718 exactly which line of source code performed calls to a function.
1898 calls to each function are tallied
