Lines Matching refs:function

46   to ensure that all functions referenced by function pointers have
53 - Function entry annotation -- annotates function entries, enabling
54   kernel function tracing
102 For each function, it recursively follows all possible code paths and
117    chain of function call sites that led to the currently executing
133    and update the frame pointer.  If a first function doesn't properly
134    create a stack frame before calling a second function, the *caller*
135    of the first function will be skipped on the stack trace.
173        beginning of a function before the stack frame has been created,
174        or at the very end of the function after the stack frame has been
198 1. Each callable function must be annotated as such with the ELF
199    function type.  In asm code, this is typically done using the
201    outside of a function, it flags an error since that usually indicates
205    callable function in order to analyze its stack metadata.
208    be annotated as an ELF function.  The ENDPROC macro shouldn't be used
214 3. Each callable function which calls another function must have the
220    designed.  If function A doesn't create a stack frame before calling
221    function B, the _caller_ of function A will be skipped on the stack
229       the same value it had on function entry.
232    function's code paths.  If a function jumps to code in another file,
236 5. A callable function may not execute kernel entry/exit instructions.
268    The func() function made a function call without first saving and/or
272    function, add proper frame pointer logic using the FRAME_BEGIN and
273    FRAME_END macros.  Otherwise, if it's not a callable function, remove
274    its ELF function annotation by changing ENDPROC to END, and instead
277    If it's a GCC-compiled .c file, the error may be because the function
287    objtool can help with pinpointing the exact function where it happens:
312    reachable from) a callable function, the function should be annotated
322    If it's not actually in a callable function (e.g. kernel entry code),
328    __noreturn annotation.  NOTE: In addition to annotating the function
340 5. file.o: warning: objtool: func()+0x6: unsupported instruction in callable function
343    instructions aren't allowed in a callable function, and are most
345    the callable function annotation (ENDPROC) and should always be
358    If the instruction is not actually in a callable function (e.g.
368    Make sure that, when CONFIG_FRAME_POINTER is enabled, the function
370    the beginning of the function and pops it at the end of the function.
371    Also make sure that no other code in the function touches the frame
380 8. file.o: warning: objtool: funcA() falls through to next function funcB()
383    unconditional jump, and that objtool has determined that the function
384    can fall through into the next function.  There could be different
387    1) funcA()'s last instruction is a call to a "noreturn" function like
388       panic().  In this case the noreturn function needs to be added to
395    3) If funcA() calls an inline function, the object code for funcA()
401    This means that an unexpected call to a non-whitelisted function exists
422       function tracing inserts additional calls, which is not obvious from the
435 11. file.o: warning: unannotated intra-function call
438    is not at the beginning of a function. If this is a legit call, you
444    This means that objtool is running with --ibt and a function expected
462 - To skip validation of a function, use the STACK_FRAME_NON_STANDARD