Static Call Graph for image .\Objects\rtthread.axf

Function Pointers

• BusFault_Handler from startup.o(.text.Default_Handler) referenced from startup.o(.fixed_vectors)
• DebugMon_Handler from startup.o(.text.Default_Handler) referenced from startup.o(.fixed_vectors)
• HardFault_Handler from context_rvds.o(.text) referenced from startup.o(.fixed_vectors)
• MemManage_Handler from startup.o(.text.Default_Handler) referenced from startup.o(.fixed_vectors)
• NMI_Handler from bsp_group_irq.o(.text.NMI_Handler) referenced from startup.o(.fixed_vectors)
• PendSV_Handler from context_rvds.o(.text) referenced from startup.o(.fixed_vectors)
• R_BSP_IrqEnable from bsp_irq.o(.text.R_BSP_IrqEnable) referenced from r_sci_uart.o(.text.R_SCI_UART_Open)
• R_BSP_WarmStart from drv_common.o(.text.R_BSP_WarmStart) referenced from system.o(.text.SystemInit)
• R_IOPORT_Close from r_ioport.o(.text.R_IOPORT_Close) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_Open from r_ioport.o(.text.R_IOPORT_Open) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PinCfg from r_ioport.o(.text.R_IOPORT_PinCfg) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PinEventInputRead from r_ioport.o(.text.R_IOPORT_PinEventInputRead) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PinEventOutputWrite from r_ioport.o(.text.R_IOPORT_PinEventOutputWrite) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PinRead from r_ioport.o(.text.R_IOPORT_PinRead) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PinWrite from r_ioport.o(.text.R_IOPORT_PinWrite) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PinsCfg from r_ioport.o(.text.R_IOPORT_PinsCfg) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PortDirectionSet from r_ioport.o(.text.R_IOPORT_PortDirectionSet) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PortEventInputRead from r_ioport.o(.text.R_IOPORT_PortEventInputRead) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PortEventOutputWrite from r_ioport.o(.text.R_IOPORT_PortEventOutputWrite) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PortRead from r_ioport.o(.text.R_IOPORT_PortRead) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• R_IOPORT_PortWrite from r_ioport.o(.text.R_IOPORT_PortWrite) referenced from r_ioport.o(.rodata.g_ioport_on_ioport)
• Reset_Handler from startup.o(.text.Reset_Handler) referenced from startup.o(.fixed_vectors)
• SVC_Handler from startup.o(.text.Default_Handler) referenced from startup.o(.fixed_vectors)
• SecureFault_Handler from startup.o(.text.Default_Handler) referenced from startup.o(.fixed_vectors)
• SysTick_Handler from drv_common.o(.text.SysTick_Handler) referenced from startup.o(.fixed_vectors)
• UsageFault_Handler from startup.o(.text.Default_Handler) referenced from startup.o(.fixed_vectors)
• _get_lc_ctype from lc_ctype_c.o(locale$$code) referenced from rt_ctype_table.o(.text)
• _match_name from object.o(.text._match_name) referenced from object.o(.text.rt_object_find)
• _pin_cmd from dev_pin.o(.text._pin_cmd) referenced from dev_pin.o(FSymTab)
• _pin_control from dev_pin.o(.text._pin_control) referenced from dev_pin.o(.text.rt_device_pin_register)
• _pin_read from dev_pin.o(.text._pin_read) referenced from dev_pin.o(.text.rt_device_pin_register)
• _pin_write from dev_pin.o(.text._pin_write) referenced from dev_pin.o(.text.rt_device_pin_register)
• _serial_fifo_rx from dev_serial_v2.o(.text._serial_fifo_rx) referenced from dev_serial_v2.o(.text.rt_serial_open)
• _serial_fifo_tx_blocking_buf from dev_serial_v2.o(.text._serial_fifo_tx_blocking_buf) referenced from dev_serial_v2.o(.text.rt_serial_open)
• _serial_fifo_tx_blocking_nbuf from dev_serial_v2.o(.text._serial_fifo_tx_blocking_nbuf) referenced from dev_serial_v2.o(.text.rt_serial_open)
• _serial_fifo_tx_nonblocking from dev_serial_v2.o(.text._serial_fifo_tx_nonblocking) referenced from dev_serial_v2.o(.text.rt_serial_open)
• _serial_poll_rx from dev_serial_v2.o(.text._serial_poll_rx) referenced from dev_serial_v2.o(.text.rt_serial_open)
• _serial_poll_tx from dev_serial_v2.o(.text._serial_poll_tx) referenced from dev_serial_v2.o(.text.rt_serial_open)
• _thread_exit from thread.o(.text._thread_exit) referenced from thread.o(.text._thread_init)
• _thread_timeout from thread.o(.text._thread_timeout) referenced from thread.o(.text._thread_init)
• _timer_thread_entry from timer.o(.text._timer_thread_entry) referenced from timer.o(.text.rt_system_timer_thread_init)
• clear from cmd.o(.text.clear) referenced from cmd.o(FSymTab)
• cmd_backtrace from kservice.o(.text.cmd_backtrace) referenced from kservice.o(FSymTab)
• cmd_free from msh.o(.text.cmd_free) referenced from msh.o(FSymTab)
• cmd_list from cmd.o(.text.cmd_list) referenced from cmd.o(FSymTab)
• cmd_ps from msh.o(.text.cmd_ps) referenced from msh.o(FSymTab)
• finsh_rx_ind from shell.o(.text.finsh_rx_ind) referenced from shell.o(.text.finsh_set_device)
• finsh_system_init from shell.o(.text.finsh_system_init) referenced from shell.o(.rti_fn.6)
• finsh_thread_entry from shell.o(.text.finsh_thread_entry) referenced from shell.o(.text.finsh_system_init)
• idle_thread_entry from idle.o(.text.idle_thread_entry) referenced from idle.o(.text.rt_thread_idle_init)
• main_thread_entry from components.o(.text.main_thread_entry) referenced from components.o(.text.rt_application_init)
• msh_help from msh.o(.text.msh_help) referenced from msh.o(FSymTab)
• object_split from cmd.o(.text.object_split) referenced from cmd.o(.text.list_thread)
• r_sci_irq_cfg from r_sci_uart.o(.text.r_sci_irq_cfg) referenced from r_sci_uart.o(.text.R_SCI_UART_Open)
• ra_pin_attach_irq from drv_gpio.o(.text.ra_pin_attach_irq) referenced from drv_gpio.o(.rodata._ra_pin_ops)
• ra_pin_dettach_irq from drv_gpio.o(.text.ra_pin_dettach_irq) referenced from drv_gpio.o(.rodata._ra_pin_ops)
• ra_pin_get from drv_gpio.o(.text.ra_pin_get) referenced from drv_gpio.o(.rodata._ra_pin_ops)
• ra_pin_irq_enable from drv_gpio.o(.text.ra_pin_irq_enable) referenced from drv_gpio.o(.rodata._ra_pin_ops)
• ra_pin_mode from drv_gpio.o(.text.ra_pin_mode) referenced from drv_gpio.o(.rodata._ra_pin_ops)
• ra_pin_read from drv_gpio.o(.text.ra_pin_read) referenced from drv_gpio.o(.rodata._ra_pin_ops)
• ra_pin_write from drv_gpio.o(.text.ra_pin_write) referenced from drv_gpio.o(.rodata._ra_pin_ops)
• ra_uart_configure from drv_usart_v2.o(.text.ra_uart_configure) referenced from drv_usart_v2.o(.rodata.ra_uart_ops)
• ra_uart_control from drv_usart_v2.o(.text.ra_uart_control) referenced from drv_usart_v2.o(.rodata.ra_uart_ops)
• ra_uart_getc from drv_usart_v2.o(.text.ra_uart_getc) referenced from drv_usart_v2.o(.rodata.ra_uart_ops)
• ra_uart_putc from drv_usart_v2.o(.text.ra_uart_putc) referenced from drv_usart_v2.o(.rodata.ra_uart_ops)
• ra_uart_transmit from drv_usart_v2.o(.text.ra_uart_transmit) referenced from drv_usart_v2.o(.rodata.ra_uart_ops)
• reboot from drv_common.o(.text.reboot) referenced from drv_common.o(FSymTab)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from cstdlib.o(.text.__rt_libc_exit)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from dev_pin.o(.text._pin_cmd_print_usage)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from msh.o(.text.cmd_free)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from cmd.o(.text.list_thread)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from drv_gpio.o(.text.ra_pin_get)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from drv_gpio.o(.text.ra_pin_mode)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from device.o(.text.rt_device_open)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from kservice.o(.text.rt_hw_backtrace_frame_get)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from kservice.o(.text.rt_hw_backtrace_frame_unwind)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from cpuport.o(.text.rt_hw_hard_fault_exception)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from dev_serial_v2.o(.text.rt_hw_serial_isr)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from object.o(.text.rt_object_init)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from scheduler_comm.o(.text.rt_scheduler_stack_check)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from dev_serial_v2.o(.text.rt_serial_control)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from dev_serial_v2.o(.text.rt_serial_open)
• rt_kprintf from kservice.o(.text.rt_kprintf) referenced from kservice.o(.text.rt_show_version)
• rt_serial_close from dev_serial_v2.o(.text.rt_serial_close) referenced from dev_serial_v2.o(.text.rt_hw_serial_register)
• rt_serial_control from dev_serial_v2.o(.text.rt_serial_control) referenced from dev_serial_v2.o(.text.rt_hw_serial_register)
• rt_serial_init from dev_serial_v2.o(.text.rt_serial_init) referenced from dev_serial_v2.o(.text.rt_hw_serial_register)
• rt_serial_open from dev_serial_v2.o(.text.rt_serial_open) referenced from dev_serial_v2.o(.text.rt_hw_serial_register)
• rti_board_end from components.o(.text.rti_board_end) referenced from components.o(.rti_fn.1.end)
• rti_board_start from components.o(.text.rti_board_start) referenced from components.o(.rti_fn.0.end)
• rti_end from components.o(.text.rti_end) referenced from components.o(.rti_fn.6.end)
• rti_start from components.o(.text.rti_start) referenced from components.o(.rti_fn.0)
• sci_uart_eri_isr from r_sci_uart.o(.text.sci_uart_eri_isr) referenced from vector_data.o(.application_vectors)
• sci_uart_rxi_isr from r_sci_uart.o(.text.sci_uart_rxi_isr) referenced from vector_data.o(.application_vectors)
• sci_uart_tei_isr from r_sci_uart.o(.text.sci_uart_tei_isr) referenced from vector_data.o(.application_vectors)
• sci_uart_txi_isr from r_sci_uart.o(.text.sci_uart_txi_isr) referenced from vector_data.o(.application_vectors)
• user_uart0_callback from drv_usart_v2.o(.text.user_uart0_callback) referenced from hal_data.o(.rodata.g_uart0_cfg)
• version from cmd.o(.text.version) referenced from cmd.o(FSymTab)

Global Symbols

Reset_Handler (Thumb, 10 bytes, Stack size 0 bytes, startup.o(.text.Reset_Handler))

[Stack]

• Max Depth = 576
• Call Chain = Reset_Handler ⇒ main ⇒ rtthread_startup ⇒ rt_application_init ⇒ rt_thread_create ⇒ rt_object_allocate ⇒ rt_malloc ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   main
• >>   SystemInit

• startup.o(.fixed_vectors)

SystemInit (Thumb, 180 bytes, Stack size 24 bytes, system.o(.text.SystemInit))

[Stack]

• Max Depth = 48
• Call Chain = SystemInit ⇒ bsp_clock_init

• >>   bsp_init
• >>   bsp_irq_cfg
• >>   R_BSP_Init_RTC
• >>   SystemCoreClockUpdate
• >>   R_BSP_RegisterProtectEnable
• >>   R_BSP_RegisterProtectDisable
• >>   bsp_clock_init
• >>   SystemRuntimeInit

• >>   Reset_Handler

__main (Thumb, 8 bytes, Stack size 0 bytes, __main.o(!!!main))

[Calls]

• >>   __rt_entry
• >>   __scatterload

__scatterload (Thumb, 0 bytes, Stack size unknown bytes, __scatter.o(!!!scatter))

[Called By]

• >>   __main

__scatterload_rt2 (Thumb, 74 bytes, Stack size unknown bytes, __scatter.o(!!!scatter), UNUSED)

[Calls]

• >>   __rt_entry

__scatterload_rt2_thumb_only (Thumb, 0 bytes, Stack size unknown bytes, __scatter.o(!!!scatter), UNUSED)

__scatterload_loop (Thumb, 0 bytes, Stack size unknown bytes, __scatter.o(!!!scatter), UNUSED)

__scatterload_copy (Thumb, 26 bytes, Stack size unknown bytes, __scatter_copy.o(!!handler_copy), UNUSED)

[Calls]

• >>   __scatterload_copy

• >>   __scatterload_copy

__scatterload_null (Thumb, 2 bytes, Stack size unknown bytes, __scatter.o(!!handler_null), UNUSED)

__scatterload_zeroinit (Thumb, 28 bytes, Stack size unknown bytes, __scatter_zi.o(!!handler_zi), UNUSED)

__rt_lib_init (Thumb, 0 bytes, Stack size unknown bytes, libinit.o(.ARM.Collect$$libinit$$00000000))

[Called By]

• >>   __rt_entry_li

__rt_lib_init_fp_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000002))

__rt_lib_init_heap_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$0000000C))

__rt_lib_init_lc_common (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000011))

[Calls]

• >>   __rt_locale

__rt_lib_init_preinit_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000006))

__rt_lib_init_rand_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000010))

__rt_lib_init_relocate_pie_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000004))

__rt_lib_init_user_alloc_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$0000000E))

__rt_lib_init_lc_collate_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000013))

__rt_lib_init_lc_ctype_2 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000014))

[Stack]

• Max Depth = 24 + Unknown Stack Size
• Call Chain = __rt_lib_init_lc_ctype_2 ⇒ _get_lc_ctype ⇒ strcmp

• >>   _get_lc_ctype

__rt_lib_init_alloca_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000030))

__rt_lib_init_argv_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$0000002E))

__rt_lib_init_atexit_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$0000001D))

__rt_lib_init_clock_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000023))

__rt_lib_init_cpp_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000034))

__rt_lib_init_exceptions_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000032))

__rt_lib_init_fp_trap_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000021))

__rt_lib_init_getenv_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000025))

__rt_lib_init_lc_ctype_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000015))

__rt_lib_init_lc_monetary_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000017))

__rt_lib_init_lc_numeric_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000019))

__rt_lib_init_lc_time_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$0000001B))

__rt_lib_init_return (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000035))

__rt_lib_init_signal_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$0000001F))

__rt_lib_init_stdio_1 (Thumb, 0 bytes, Stack size unknown bytes, libinit2.o(.ARM.Collect$$libinit$$00000027))

__rt_lib_shutdown (Thumb, 0 bytes, Stack size unknown bytes, libshutdown.o(.ARM.Collect$$libshutdown$$00000000))

[Called By]

• >>   __rt_exit_ls

__rt_lib_shutdown_cpp_1 (Thumb, 0 bytes, Stack size unknown bytes, libshutdown2.o(.ARM.Collect$$libshutdown$$00000002))

__rt_lib_shutdown_fp_trap_1 (Thumb, 0 bytes, Stack size unknown bytes, libshutdown2.o(.ARM.Collect$$libshutdown$$00000007))

__rt_lib_shutdown_heap_1 (Thumb, 0 bytes, Stack size unknown bytes, libshutdown2.o(.ARM.Collect$$libshutdown$$0000000F))

__rt_lib_shutdown_return (Thumb, 0 bytes, Stack size unknown bytes, libshutdown2.o(.ARM.Collect$$libshutdown$$00000010))

__rt_lib_shutdown_signal_1 (Thumb, 0 bytes, Stack size unknown bytes, libshutdown2.o(.ARM.Collect$$libshutdown$$0000000A))

__rt_lib_shutdown_stdio_1 (Thumb, 0 bytes, Stack size unknown bytes, libshutdown2.o(.ARM.Collect$$libshutdown$$00000004))

__rt_lib_shutdown_user_alloc_1 (Thumb, 0 bytes, Stack size unknown bytes, libshutdown2.o(.ARM.Collect$$libshutdown$$0000000C))

__rt_entry (Thumb, 0 bytes, Stack size unknown bytes, __rtentry.o(.ARM.Collect$$rtentry$$00000000))

[Called By]

• >>   __main
• >>   __scatterload_rt2

__rt_entry_presh_1 (Thumb, 0 bytes, Stack size unknown bytes, __rtentry2.o(.ARM.Collect$$rtentry$$00000002))

__rt_entry_sh (Thumb, 0 bytes, Stack size unknown bytes, __rtentry7.o(.ARM.Collect$$rtentry$$00000007))

__rt_entry_li (Thumb, 0 bytes, Stack size unknown bytes, __rtentry2.o(.ARM.Collect$$rtentry$$0000000A))

[Calls]

• >>   __rt_lib_init

__rt_entry_postsh_1 (Thumb, 0 bytes, Stack size unknown bytes, __rtentry2.o(.ARM.Collect$$rtentry$$00000009))

__rt_entry_main (Thumb, 0 bytes, Stack size unknown bytes, __rtentry2.o(.ARM.Collect$$rtentry$$0000000D))

[Stack]

• Max Depth = 576 + Unknown Stack Size
• Call Chain = __rt_entry_main ⇒ main ⇒ rtthread_startup ⇒ rt_application_init ⇒ rt_thread_create ⇒ rt_object_allocate ⇒ rt_malloc ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   main
• >>   exit

__rt_entry_postli_1 (Thumb, 0 bytes, Stack size unknown bytes, __rtentry2.o(.ARM.Collect$$rtentry$$0000000C))

__rt_exit (Thumb, 0 bytes, Stack size unknown bytes, rtexit.o(.ARM.Collect$$rtexit$$00000000))

[Called By]

• >>   exit

__rt_exit_ls (Thumb, 0 bytes, Stack size unknown bytes, rtexit2.o(.ARM.Collect$$rtexit$$00000003))

[Calls]

• >>   __rt_lib_shutdown

__rt_exit_prels_1 (Thumb, 0 bytes, Stack size unknown bytes, rtexit2.o(.ARM.Collect$$rtexit$$00000002))

__rt_exit_exit (Thumb, 0 bytes, Stack size unknown bytes, rtexit2.o(.ARM.Collect$$rtexit$$00000004))

[Stack]

• Max Depth = 528 + Unknown Stack Size
• Call Chain = __rt_exit_exit ⇒ _sys_exit ⇒ __rt_libc_exit ⇒ rt_thread_control ⇒ rt_thread_delete ⇒ _thread_detach ⇒ _thread_detach_from_mutex ⇒ rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   _sys_exit

__aeabi_memcpy4 (Thumb, 56 bytes, Stack size 0 bytes, rt_memcpy.o(.emb_text))

[Called By]

• >>   SystemRuntimeInit
• >>   __aeabi_memcpy

__aeabi_memcpy8 (Thumb, 0 bytes, Stack size 0 bytes, rt_memcpy.o(.emb_text), UNUSED)

rt_hw_interrupt_disable (Thumb, 8 bytes, Stack size 0 bytes, context_rvds.o(.text))

[Called By]

• >>   rt_exit_critical
• >>   rt_schedule
• >>   rt_spin_lock_irqsave
• >>   rt_interrupt_get_nest
• >>   rt_sched_lock
• >>   rtthread_startup
• >>   rt_sched_remove_thread
• >>   rt_sched_insert_thread

rt_hw_interrupt_enable (Thumb, 6 bytes, Stack size 0 bytes, context_rvds.o(.text))

[Called By]

• >>   rt_exit_critical
• >>   rt_schedule
• >>   rt_spin_unlock_irqrestore
• >>   rt_interrupt_get_nest
• >>   rt_sched_unlock_n_resched
• >>   rt_sched_unlock
• >>   rt_sched_remove_thread
• >>   rt_sched_insert_thread

rt_hw_context_switch (Thumb, 28 bytes, Stack size 0 bytes, context_rvds.o(.text))

[Called By]

• >>   rt_schedule

rt_hw_context_switch_interrupt (Thumb, 0 bytes, Stack size 0 bytes, context_rvds.o(.text))

[Called By]

• >>   rt_schedule

PendSV_Handler (Thumb, 84 bytes, Stack size 0 bytes, context_rvds.o(.text))
[Address Reference Count : 1]

• startup.o(.fixed_vectors)

rt_hw_context_switch_to (Thumb, 52 bytes, Stack size 0 bytes, context_rvds.o(.text))

[Called By]

• >>   rt_system_scheduler_start

rt_hw_interrupt_thread_switch (Thumb, 2 bytes, Stack size 0 bytes, context_rvds.o(.text), UNUSED)

HardFault_Handler (Thumb, 12 bytes, Stack size 0 bytes, context_rvds.o(.text))

[Stack]

• Max Depth = 488
• Call Chain = HardFault_Handler ⇒ rt_hw_hard_fault_exception ⇒ list_thread ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_hw_hard_fault_exception

• startup.o(.fixed_vectors)

__use_no_semihosting (Thumb, 2 bytes, Stack size 0 bytes, use_no_semi_2.o(.text), UNUSED)

__rt_ctype_table (Thumb, 16 bytes, Stack size 8 bytes, rt_ctype_table.o(.text))

[Stack]

• Max Depth = 8
• Call Chain = __rt_ctype_table

• >>   __rt_locale

• >>   msh_isint
• >>   strtol
• >>   strtoul

atoi (Thumb, 26 bytes, Stack size 16 bytes, atoi.o(.text))

[Stack]

• Max Depth = 88
• Call Chain = atoi ⇒ strtol ⇒ _strtoul

• >>   strtol
• >>   __aeabi_errno_addr

• >>   _pin_cmd

strtoul (Thumb, 118 bytes, Stack size 40 bytes, strtoul.o(.text))

[Stack]

• Max Depth = 80
• Call Chain = strtoul ⇒ _strtoul

• >>   _strtoul
• >>   __aeabi_errno_addr
• >>   __rt_ctype_table

• >>   cmd_backtrace

strchr (Thumb, 20 bytes, Stack size 0 bytes, strchr.o(.text))

[Called By]

• >>   msh_get_cmd_opt

memcmp (Thumb, 90 bytes, Stack size 8 bytes, memcmp.o(.text))

[Stack]

• Max Depth = 8
• Call Chain = memcmp

• >>   finsh_thread_entry

strlen (Thumb, 62 bytes, Stack size 12 bytes, strlen.o(.text))

[Stack]

• Max Depth = 12
• Call Chain = strlen

• >>   msh_get_cmd_opt
• >>   msh_opt_auto_complete
• >>   msh_auto_complete
• >>   finsh_thread_entry

strncmp (Thumb, 154 bytes, Stack size 20 bytes, strncmp.o(.text))

[Stack]

• Max Depth = 20
• Call Chain = strncmp

• >>   msh_get_cmd_opt
• >>   msh_get_cmd
• >>   msh_opt_auto_complete
• >>   msh_auto_complete

__aeabi_memcpy (Thumb, 130 bytes, Stack size 24 bytes, rt_memcpy.o(.text))

[Stack]

• Max Depth = 24
• Call Chain = __aeabi_memcpy

• >>   __aeabi_memcpy4

• >>   finsh_get_prompt
• >>   sci_uart_rxi_isr

__rt_memcpy (Thumb, 0 bytes, Stack size 24 bytes, rt_memcpy.o(.text), UNUSED)

_memset_w (Thumb, 26 bytes, Stack size 0 bytes, rt_memclr.o(.text), UNUSED)

[Called By]

• >>   __rt_memclr_w
• >>   _memset

_memset (Thumb, 30 bytes, Stack size 0 bytes, rt_memclr.o(.text), UNUSED)

[Calls]

• >>   _memset_w

• >>   __aeabi_memclr

__aeabi_memclr (Thumb, 4 bytes, Stack size 0 bytes, rt_memclr.o(.text), UNUSED)

[Calls]

• >>   _memset

__rt_memclr (Thumb, 0 bytes, Stack size 0 bytes, rt_memclr.o(.text))

[Called By]

• >>   strncpy

__aeabi_memclr4 (Thumb, 0 bytes, Stack size 0 bytes, rt_memclr.o(.text))

[Called By]

• >>   rt_device_pin_register
• >>   SystemRuntimeInit
• >>   print_number

__aeabi_memclr8 (Thumb, 0 bytes, Stack size 0 bytes, rt_memclr.o(.text), UNUSED)

__rt_memclr_w (Thumb, 4 bytes, Stack size 0 bytes, rt_memclr.o(.text), UNUSED)

[Calls]

• >>   _memset_w

strncpy (Thumb, 104 bytes, Stack size 24 bytes, strncpy.o(.text))

[Stack]

• Max Depth = 24
• Call Chain = strncpy

• >>   __rt_memclr

• >>   msh_opt_auto_complete
• >>   finsh_get_prompt

strcmp (Thumb, 132 bytes, Stack size 16 bytes, strcmp.o(.text))

[Stack]

• Max Depth = 16
• Call Chain = strcmp

• >>   msh_cmd_opt_id_get
• >>   _get_lc_ctype

__I$use$semihosting (Thumb, 0 bytes, Stack size 0 bytes, use_no_semi.o(.text), UNUSED)

__use_no_semihosting_swi (Thumb, 2 bytes, Stack size 0 bytes, use_no_semi.o(.text), UNUSED)

__rt_locale (Thumb, 8 bytes, Stack size 0 bytes, rt_locale_intlibspace.o(.text))

[Called By]

• >>   __rt_lib_init_lc_common
• >>   __rt_ctype_table

__aeabi_errno_addr (Thumb, 8 bytes, Stack size 0 bytes, rt_errno_addr_intlibspace.o(.text))

[Called By]

• >>   strtol
• >>   _strtoul
• >>   strtoul
• >>   atoi

__errno$intlibspace (Thumb, 0 bytes, Stack size 0 bytes, rt_errno_addr_intlibspace.o(.text), UNUSED)

__rt_errno_addr$intlibspace (Thumb, 0 bytes, Stack size 0 bytes, rt_errno_addr_intlibspace.o(.text), UNUSED)

_strtoul (Thumb, 166 bytes, Stack size 40 bytes, _strtoul.o(.text))

[Stack]

• Max Depth = 40
• Call Chain = _strtoul

• >>   _chval
• >>   __aeabi_errno_addr

• >>   strtol
• >>   strtoul

strtol (Thumb, 108 bytes, Stack size 32 bytes, strtol.o(.text))

[Stack]

• Max Depth = 72
• Call Chain = strtol ⇒ _strtoul

• >>   _strtoul
• >>   __aeabi_errno_addr
• >>   __rt_ctype_table

• >>   atoi

_chval (Thumb, 30 bytes, Stack size 0 bytes, _chval.o(.text))

[Called By]

• >>   _strtoul

exit (Thumb, 16 bytes, Stack size 8 bytes, exit.o(.text))

[Stack]

• Max Depth = 8 + Unknown Stack Size
• Call Chain = exit

• >>   __rt_exit
• >>   _call_atexit_fns (Weak Reference)

• >>   __rt_entry_main

main (Thumb, 10 bytes, Stack size 8 bytes, components.o(.text.$Sub$$main))

[Stack]

• Max Depth = 576
• Call Chain = main ⇒ rtthread_startup ⇒ rt_application_init ⇒ rt_thread_create ⇒ rt_object_allocate ⇒ rt_malloc ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rtthread_startup

• >>   __rt_entry_main
• >>   Reset_Handler

BusFault_Handler (Thumb, 4 bytes, Stack size 0 bytes, startup.o(.text.Default_Handler))
[Address Reference Count : 1]

• startup.o(.fixed_vectors)

DebugMon_Handler (Thumb, 4 bytes, Stack size 0 bytes, startup.o(.text.Default_Handler))
[Address Reference Count : 1]

• startup.o(.fixed_vectors)

Default_Handler (Thumb, 4 bytes, Stack size 0 bytes, startup.o(.text.Default_Handler), UNUSED)

MemManage_Handler (Thumb, 4 bytes, Stack size 0 bytes, startup.o(.text.Default_Handler))
[Address Reference Count : 1]

• startup.o(.fixed_vectors)

SVC_Handler (Thumb, 4 bytes, Stack size 0 bytes, startup.o(.text.Default_Handler))
[Address Reference Count : 1]

• startup.o(.fixed_vectors)

SecureFault_Handler (Thumb, 4 bytes, Stack size 0 bytes, startup.o(.text.Default_Handler))
[Address Reference Count : 1]

• startup.o(.fixed_vectors)

UsageFault_Handler (Thumb, 4 bytes, Stack size 0 bytes, startup.o(.text.Default_Handler))
[Address Reference Count : 1]

• startup.o(.fixed_vectors)

NMI_Handler (Thumb, 48 bytes, Stack size 24 bytes, bsp_group_irq.o(.text.NMI_Handler))

[Stack]

• Max Depth = 24
• Call Chain = NMI_Handler

• startup.o(.fixed_vectors)

R_BSP_Init_RTC (Thumb, 52 bytes, Stack size 16 bytes, bsp_clocks.o(.text.R_BSP_Init_RTC))

[Stack]

• Max Depth = 16
• Call Chain = R_BSP_Init_RTC

• >>   R_BSP_SoftwareDelay

• >>   SystemInit

R_BSP_IrqCfg (Thumb, 40 bytes, Stack size 16 bytes, bsp_irq.o(.text.R_BSP_IrqCfg))

[Stack]

• Max Depth = 16
• Call Chain = R_BSP_IrqCfg

• >>   r_sci_irq_cfg

R_BSP_IrqClearPending (Thumb, 40 bytes, Stack size 16 bytes, bsp_irq.o(.text.R_BSP_IrqClearPending))

[Stack]

• Max Depth = 16
• Call Chain = R_BSP_IrqClearPending

• >>   R_BSP_IrqEnable

R_BSP_IrqDisable (Thumb, 28 bytes, Stack size 0 bytes, bsp_irq.o(.text.R_BSP_IrqDisable))

[Called By]

• >>   r_sci_irq_cfg

R_BSP_IrqEnable (Thumb, 28 bytes, Stack size 8 bytes, bsp_irq.o(.text.R_BSP_IrqEnable))

[Stack]

• Max Depth = 24
• Call Chain = R_BSP_IrqEnable ⇒ R_BSP_IrqClearPending

• >>   R_BSP_IrqClearPending

• r_sci_uart.o(.text.R_SCI_UART_Open)

R_BSP_IrqStatusClear (Thumb, 20 bytes, Stack size 0 bytes, bsp_irq.o(.text.R_BSP_IrqStatusClear))

[Called By]

• >>   sci_uart_eri_isr
• >>   sci_uart_tei_isr
• >>   sci_uart_rxi_isr
• >>   sci_uart_txi_isr
• >>   r_sci_irq_cfg

R_BSP_RegisterProtectDisable (Thumb, 52 bytes, Stack size 8 bytes, bsp_register_protection.o(.text.R_BSP_RegisterProtectDisable))

[Stack]

• Max Depth = 8
• Call Chain = R_BSP_RegisterProtectDisable

• >>   SystemInit

R_BSP_RegisterProtectEnable (Thumb, 56 bytes, Stack size 8 bytes, bsp_register_protection.o(.text.R_BSP_RegisterProtectEnable))

[Stack]

• Max Depth = 8
• Call Chain = R_BSP_RegisterProtectEnable

• >>   SystemInit

R_BSP_SoftwareDelay (Thumb, 64 bytes, Stack size 0 bytes, bsp_delay.o(.text.R_BSP_SoftwareDelay))

[Calls]

• >>   bsp_prv_software_delay_loop

• >>   R_BSP_Init_RTC
• >>   bsp_clock_init

R_BSP_SubClockStabilizeWaitAfterReset (Thumb, 2 bytes, Stack size 0 bytes, bsp_clocks.o(.text.R_BSP_SubClockStabilizeWaitAfterReset))

[Called By]

• >>   bsp_clock_init

R_BSP_WarmStart (Thumb, 24 bytes, Stack size 0 bytes, drv_common.o(.text.R_BSP_WarmStart))

[Stack]

• Max Depth = 44
• Call Chain = R_BSP_WarmStart ⇒ R_IOPORT_Open ⇒ r_ioport_pins_config ⇒ r_ioport_pfs_write

• >>   R_IOPORT_Open

• system.o(.text.SystemInit)

R_IOPORT_Close (Thumb, 8 bytes, Stack size 0 bytes, r_ioport.o(.text.R_IOPORT_Close))
[Address Reference Count : 1]

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_Open (Thumb, 16 bytes, Stack size 8 bytes, r_ioport.o(.text.R_IOPORT_Open))

[Stack]

• Max Depth = 44
• Call Chain = R_IOPORT_Open ⇒ r_ioport_pins_config ⇒ r_ioport_pfs_write

• >>   r_ioport_pins_config

• >>   ra_pin_mode
• >>   R_BSP_WarmStart

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PinCfg (Thumb, 26 bytes, Stack size 16 bytes, r_ioport.o(.text.R_IOPORT_PinCfg))

[Stack]

• Max Depth = 36
• Call Chain = R_IOPORT_PinCfg ⇒ r_ioport_pfs_write

• >>   R_BSP_PinAccessDisable
• >>   r_ioport_pfs_write
• >>   R_BSP_PinAccessEnable

• >>   ra_pin_mode

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PinEventInputRead (Thumb, 32 bytes, Stack size 0 bytes, r_ioport.o(.text.R_IOPORT_PinEventInputRead))
[Address Reference Count : 1]

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PinEventOutputWrite (Thumb, 48 bytes, Stack size 16 bytes, r_ioport.o(.text.R_IOPORT_PinEventOutputWrite))

[Stack]

• Max Depth = 16
• Call Chain = R_IOPORT_PinEventOutputWrite

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PinRead (Thumb, 24 bytes, Stack size 0 bytes, r_ioport.o(.text.R_IOPORT_PinRead))
[Address Reference Count : 1]

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PinWrite (Thumb, 32 bytes, Stack size 0 bytes, r_ioport.o(.text.R_IOPORT_PinWrite))
[Address Reference Count : 1]

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PinsCfg (Thumb, 12 bytes, Stack size 8 bytes, r_ioport.o(.text.R_IOPORT_PinsCfg))

[Stack]

• Max Depth = 44
• Call Chain = R_IOPORT_PinsCfg ⇒ r_ioport_pins_config ⇒ r_ioport_pfs_write

• >>   r_ioport_pins_config

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PortDirectionSet (Thumb, 32 bytes, Stack size 16 bytes, r_ioport.o(.text.R_IOPORT_PortDirectionSet))

[Stack]

• Max Depth = 16
• Call Chain = R_IOPORT_PortDirectionSet

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PortEventInputRead (Thumb, 20 bytes, Stack size 0 bytes, r_ioport.o(.text.R_IOPORT_PortEventInputRead))
[Address Reference Count : 1]

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PortEventOutputWrite (Thumb, 28 bytes, Stack size 0 bytes, r_ioport.o(.text.R_IOPORT_PortEventOutputWrite))
[Address Reference Count : 1]

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PortRead (Thumb, 20 bytes, Stack size 0 bytes, r_ioport.o(.text.R_IOPORT_PortRead))
[Address Reference Count : 1]

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_IOPORT_PortWrite (Thumb, 28 bytes, Stack size 0 bytes, r_ioport.o(.text.R_IOPORT_PortWrite))
[Address Reference Count : 1]

• r_ioport.o(.rodata.g_ioport_on_ioport)

R_SCI_UART_Open (Thumb, 360 bytes, Stack size 32 bytes, r_sci_uart.o(.text.R_SCI_UART_Open))

[Stack]

• Max Depth = 40
• Call Chain = R_SCI_UART_Open ⇒ r_sci_uart_baud_set

• >>   r_sci_uart_baud_set

• >>   ra_uart_configure

SysTick_Handler (Thumb, 20 bytes, Stack size 8 bytes, drv_common.o(.text.SysTick_Handler))

[Stack]

• Max Depth = 456
• Call Chain = SysTick_Handler ⇒ rt_tick_increase ⇒ rt_timer_check ⇒ rt_sem_release ⇒ rt_susp_list_dequeue ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_tick_increase
• >>   rt_interrupt_leave
• >>   rt_interrupt_enter

• startup.o(.fixed_vectors)

SystemCoreClockUpdate (Thumb, 24 bytes, Stack size 0 bytes, bsp_clocks.o(.text.SystemCoreClockUpdate))

[Called By]

• >>   bsp_clock_init
• >>   SystemInit

__rt_ffs (Thumb, 56 bytes, Stack size 0 bytes, kservice.o(.text.__rt_ffs))

[Called By]

• >>   _scheduler_get_highest_priority_thread

__rt_libc_exit (Thumb, 48 bytes, Stack size 16 bytes, cstdlib.o(.text.__rt_libc_exit))

[Stack]

• Max Depth = 520
• Call Chain = __rt_libc_exit ⇒ rt_thread_control ⇒ rt_thread_delete ⇒ _thread_detach ⇒ _thread_detach_from_mutex ⇒ rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_control
• >>   rt_thread_self

• >>   _sys_exit

_serial_poll_rx (Thumb, 76 bytes, Stack size 32 bytes, dev_serial_v2.o(.text._serial_poll_rx))

[Stack]

• Max Depth = 296
• Call Chain = _serial_poll_rx ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• dev_serial_v2.o(.text.rt_serial_open)

_serial_poll_tx (Thumb, 84 bytes, Stack size 24 bytes, dev_serial_v2.o(.text._serial_poll_tx))

[Stack]

• Max Depth = 288
• Call Chain = _serial_poll_tx ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_tx_blocking_nbuf

• dev_serial_v2.o(.text.rt_serial_open)

_sys_exit (Thumb, 8 bytes, Stack size 8 bytes, syscalls.o(.text._sys_exit))

[Stack]

• Max Depth = 528
• Call Chain = _sys_exit ⇒ __rt_libc_exit ⇒ rt_thread_control ⇒ rt_thread_delete ⇒ _thread_detach ⇒ _thread_detach_from_mutex ⇒ rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   __rt_libc_exit

• >>   __rt_exit_exit

bsp_clock_init (Thumb, 148 bytes, Stack size 24 bytes, bsp_clocks.o(.text.bsp_clock_init))

[Stack]

• Max Depth = 24
• Call Chain = bsp_clock_init

• >>   R_BSP_SubClockStabilizeWaitAfterReset
• >>   bsp_prv_operating_mode_opccr_set
• >>   SystemCoreClockUpdate
• >>   R_BSP_SoftwareDelay

• >>   SystemInit

bsp_init (Thumb, 2 bytes, Stack size 0 bytes, bsp_common.o(.text.bsp_init_internal))

[Called By]

• >>   SystemInit

bsp_init_internal (Thumb, 2 bytes, Stack size 0 bytes, bsp_common.o(.text.bsp_init_internal), UNUSED)

bsp_irq_cfg (Thumb, 24 bytes, Stack size 0 bytes, bsp_irq.o(.text.bsp_irq_cfg))

[Called By]

• >>   SystemInit

bsp_prv_software_delay_loop (Thumb, 8 bytes, Stack size 0 bytes, bsp_delay.o(.text.bsp_prv_software_delay_loop))

[Calls]

• >>   bsp_prv_software_delay_loop

• >>   bsp_prv_software_delay_loop
• >>   R_BSP_SoftwareDelay

finsh_get_prompt (Thumb, 84 bytes, Stack size 8 bytes, shell.o(.text.finsh_get_prompt))

[Stack]

• Max Depth = 32
• Call Chain = finsh_get_prompt ⇒ strncpy

• >>   rt_strlen
• >>   strncpy
• >>   __aeabi_memcpy

• >>   shell_handle_history
• >>   finsh_thread_entry

finsh_getchar (Thumb, 92 bytes, Stack size 24 bytes, shell.o(.text.finsh_getchar))

[Stack]

• Max Depth = 464
• Call Chain = finsh_getchar ⇒ rt_sem_take ⇒ _rt_sem_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_sem_take
• >>   rt_device_read
• >>   rt_assert_handler

• >>   finsh_thread_entry

finsh_set_device (Thumb, 140 bytes, Stack size 16 bytes, shell.o(.text.finsh_set_device))

[Stack]

• Max Depth = 408
• Call Chain = finsh_set_device ⇒ rt_device_find ⇒ rt_object_find ⇒ rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_device_set_rx_indicate
• >>   rt_device_close
• >>   rt_device_open
• >>   rt_assert_handler
• >>   rt_device_find
• >>   rt_memset
• >>   rt_kprintf

• >>   finsh_thread_entry

finsh_set_prompt_mode (Thumb, 40 bytes, Stack size 16 bytes, shell.o(.text.finsh_set_prompt_mode))

[Stack]

• Max Depth = 280
• Call Chain = finsh_set_prompt_mode ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   finsh_system_init

finsh_system_init (Thumb, 96 bytes, Stack size 24 bytes, shell.o(.text.finsh_system_init))

[Stack]

• Max Depth = 568
• Call Chain = finsh_system_init ⇒ rt_thread_create ⇒ rt_object_allocate ⇒ rt_malloc ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_startup
• >>   rt_thread_create
• >>   rt_sem_init
• >>   rt_calloc
• >>   rt_kprintf
• >>   finsh_set_prompt_mode

• shell.o(.rti_fn.6)

hal_entry (Thumb, 52 bytes, Stack size 0 bytes, hal_entry.o(.text.hal_entry))

[Stack]

• Max Depth = 440
• Call Chain = hal_entry ⇒ rt_thread_mdelay ⇒ _thread_sleep ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_mdelay
• >>   rt_pin_write
• >>   rt_kprintf

• >>   $Super$$main

list_device (Thumb, 184 bytes, Stack size 104 bytes, cmd.o(.text.list_device))

[Stack]

• Max Depth = 472
• Call Chain = list_device ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_kprintf
• >>   rt_object_get_information
• >>   object_split
• >>   list_get_next

• >>   cmd_list

list_event (Thumb, 212 bytes, Stack size 104 bytes, cmd.o(.text.list_event))

[Stack]

• Max Depth = 472
• Call Chain = list_event ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_kprintf
• >>   rt_susp_list_print
• >>   rt_object_get_information
• >>   rt_list_len
• >>   object_split
• >>   list_get_next

• >>   cmd_list

list_mailbox (Thumb, 232 bytes, Stack size 120 bytes, cmd.o(.text.list_mailbox))

[Stack]

• Max Depth = 488
• Call Chain = list_mailbox ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_kprintf
• >>   rt_susp_list_print
• >>   rt_object_get_information
• >>   rt_list_len
• >>   object_split
• >>   list_get_next

• >>   cmd_list

list_msgqueue (Thumb, 220 bytes, Stack size 112 bytes, cmd.o(.text.list_msgqueue))

[Stack]

• Max Depth = 480
• Call Chain = list_msgqueue ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_kprintf
• >>   rt_susp_list_print
• >>   rt_object_get_information
• >>   rt_list_len
• >>   object_split
• >>   list_get_next

• >>   cmd_list

list_mutex (Thumb, 256 bytes, Stack size 136 bytes, cmd.o(.text.list_mutex))

[Stack]

• Max Depth = 504
• Call Chain = list_mutex ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_kprintf
• >>   rt_susp_list_print
• >>   rt_object_get_information
• >>   rt_list_len
• >>   object_split
• >>   list_get_next

• >>   cmd_list

list_sem (Thumb, 220 bytes, Stack size 112 bytes, cmd.o(.text.list_sem))

[Stack]

• Max Depth = 480
• Call Chain = list_sem ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_kprintf
• >>   rt_susp_list_print
• >>   rt_object_get_information
• >>   rt_list_len
• >>   object_split
• >>   list_get_next

• >>   cmd_list

list_thread (Thumb, 300 bytes, Stack size 120 bytes, cmd.o(.text.list_thread))

[Stack]

• Max Depth = 488
• Call Chain = list_thread ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_kprintf
• >>   rt_strerror
• >>   rt_object_get_information
• >>   list_get_next

• >>   cmd_list
• >>   cmd_ps
• >>   rt_hw_hard_fault_exception

list_timer (Thumb, 216 bytes, Stack size 96 bytes, cmd.o(.text.list_timer))

[Stack]

• Max Depth = 464
• Call Chain = list_timer ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_tick_get
• >>   rt_kprintf
• >>   rt_object_get_information
• >>   object_split
• >>   list_get_next

• >>   cmd_list

$Super$$main (Thumb, 10 bytes, Stack size 8 bytes, main.o(.text.main))

[Stack]

• Max Depth = 448
• Call Chain = $Super$$main ⇒ hal_entry ⇒ rt_thread_mdelay ⇒ _thread_sleep ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   hal_entry

• >>   main_thread_entry

msh_auto_complete (Thumb, 132 bytes, Stack size 32 bytes, msh.o(.text.msh_auto_complete))

[Stack]

• Max Depth = 248
• Call Chain = msh_auto_complete ⇒ msh_help ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf
• >>   rt_strncpy
• >>   str_common
• >>   msh_help
• >>   strncmp
• >>   strlen

• >>   finsh_thread_entry

msh_cmd_opt_id_get (Thumb, 40 bytes, Stack size 24 bytes, msh.o(.text.msh_cmd_opt_id_get))

[Stack]

• Max Depth = 40
• Call Chain = msh_cmd_opt_id_get ⇒ strcmp

• >>   strcmp

• >>   cmd_list

msh_exec (Thumb, 328 bytes, Stack size 72 bytes, msh.o(.text.msh_exec))

[Stack]

• Max Depth = 272
• Call Chain = msh_exec ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_memset
• >>   rt_kprintf
• >>   msh_get_cmd

• >>   finsh_thread_entry

msh_isint (Thumb, 54 bytes, Stack size 24 bytes, msh_parse.o(.text.msh_isint))

[Stack]

• Max Depth = 32
• Call Chain = msh_isint ⇒ __rt_ctype_table

• >>   __rt_ctype_table

• >>   _pin_cmd

msh_opt_auto_complete (Thumb, 256 bytes, Stack size 32 bytes, msh.o(.text.msh_opt_auto_complete))

[Stack]

• Max Depth = 232
• Call Chain = msh_opt_auto_complete ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf
• >>   msh_get_cmd_opt
• >>   str_common
• >>   msh_get_cmd
• >>   strncpy
• >>   strncmp
• >>   strlen

• >>   finsh_thread_entry

msh_opt_list_dump (Thumb, 28 bytes, Stack size 16 bytes, msh.o(.text.msh_opt_list_dump))

[Stack]

• Max Depth = 216
• Call Chain = msh_opt_list_dump ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf

• >>   cmd_list

rt_application_init (Thumb, 52 bytes, Stack size 16 bytes, components.o(.text.rt_application_init))

[Stack]

• Max Depth = 560
• Call Chain = rt_application_init ⇒ rt_thread_create ⇒ rt_object_allocate ⇒ rt_malloc ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_startup
• >>   rt_thread_create
• >>   rt_assert_handler

• >>   rtthread_startup

rt_assert_handler (Thumb, 60 bytes, Stack size 16 bytes, kservice.o(.text.rt_assert_handler))

[Stack]

• Max Depth = 264
• Call Chain = rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf
• >>   rt_backtrace

• >>   rt_hw_serial_isr
• >>   rt_hw_serial_control_isr
• >>   rt_hw_serial_register
• >>   _serial_poll_tx
• >>   _serial_poll_rx
• >>   rt_serial_get_linear_buffer
• >>   rt_serial_update_read_index
• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_tx_blocking_nbuf
• >>   _serial_fifo_tx_nonblocking
• >>   _serial_fifo_rx
• >>   rt_serial_init
• >>   rt_serial_open
• >>   rt_serial_close
• >>   rt_serial_control
• >>   rt_pin_get
• >>   rt_pin_read
• >>   rt_pin_mode
• >>   _pin_read
• >>   _pin_write
• >>   _pin_control
• >>   rt_thread_delete
• >>   rt_sem_release
• >>   rt_thread_startup
• >>   rt_thread_create
• >>   rt_sem_init
• >>   rt_ringbuffer_reset
• >>   rt_ringbuffer_getchar
• >>   rt_ringbuffer_putchar_force
• >>   rt_ringbuffer_peek
• >>   rt_ringbuffer_put_force
• >>   rt_ringbuffer_init
• >>   rt_mutex_init
• >>   rt_ringbuffer_put
• >>   rt_ringbuffer_get
• >>   rt_susp_list_dequeue
• >>   rt_thread_suspend_to_list
• >>   rt_mutex_release
• >>   rt_thread_resume
• >>   rt_timer_start
• >>   rt_timer_control
• >>   rt_completion_init
• >>   rt_completion_wait_flags
• >>   rt_completion_wakeup_by_errno
• >>   rt_device_set_rx_indicate
• >>   rt_device_read
• >>   rt_device_close
• >>   rt_device_open
• >>   rt_object_detach
• >>   rt_object_is_systemobject
• >>   rt_object_get_type
• >>   rt_object_find
• >>   rt_object_init
• >>   rt_thread_control
• >>   rt_device_write
• >>   rt_pin_write
• >>   _heap_unlock
• >>   rt_mutex_drop_thread
• >>   rt_sem_control
• >>   rt_object_allocate
• >>   rt_susp_list_enqueue
• >>   _rt_mutex_take
• >>   _rt_sem_take
• >>   rt_thread_init
• >>   rt_object_delete
• >>   rt_application_init
• >>   rt_timer_check
• >>   finsh_set_device
• >>   finsh_getchar
• >>   finsh_set_prompt_mode
• >>   finsh_rx_ind
• >>   rt_tick_increase
• >>   rt_hw_usart_init
• >>   ra_uart_transmit
• >>   ra_uart_putc
• >>   ra_uart_configure
• >>   rt_thread_detach
• >>   rt_timer_detach
• >>   rt_thread_close
• >>   rt_timer_init
• >>   _thread_sleep
• >>   _thread_timeout
• >>   rt_scheduler_stack_check
• >>   rt_sched_remove_thread
• >>   rt_sched_insert_thread
• >>   rt_timer_stop
• >>   rt_sched_thread_init_priv
• >>   _rt_sched_update_priority
• >>   rt_object_for_each
• >>   plug_holes
• >>   rt_smem_free
• >>   rt_smem_alloc
• >>   rt_system_heap_init_generic

rt_backtrace (Thumb, 44 bytes, Stack size 24 bytes, kservice.o(.text.rt_backtrace))

[Stack]

• Max Depth = 248
• Call Chain = rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_self
• >>   rt_backtrace_frame
• >>   rt_hw_backtrace_frame_unwind

• >>   rt_assert_handler
• >>   cmd_backtrace

rt_backtrace_frame (Thumb, 52 bytes, Stack size 24 bytes, kservice.o(.text.rt_backtrace_frame))

[Stack]

• Max Depth = 224
• Call Chain = rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf
• >>   rt_hw_backtrace_frame_unwind

• >>   rt_backtrace_thread
• >>   rt_backtrace

rt_backtrace_thread (Thumb, 32 bytes, Stack size 16 bytes, kservice.o(.text.rt_backtrace_thread))

[Stack]

• Max Depth = 240
• Call Chain = rt_backtrace_thread ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_backtrace_frame
• >>   rt_hw_backtrace_frame_get

• >>   cmd_backtrace

rt_calloc (Thumb, 30 bytes, Stack size 16 bytes, kservice.o(.text.rt_calloc))

[Stack]

• Max Depth = 496
• Call Chain = rt_calloc ⇒ rt_malloc ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_memset
• >>   rt_malloc

• >>   finsh_system_init

rt_completion_done (Thumb, 8 bytes, Stack size 0 bytes, completion_comm.o(.text.rt_completion_done))

[Stack]

• Max Depth = 424
• Call Chain = rt_completion_done ⇒ rt_completion_wakeup_by_errno ⇒ rt_thread_resume ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_completion_wakeup_by_errno

• >>   rt_hw_serial_isr
• >>   rt_serial_close

rt_completion_init (Thumb, 24 bytes, Stack size 8 bytes, completion_up.o(.text.rt_completion_init))

[Stack]

• Max Depth = 272
• Call Chain = rt_completion_init ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   rt_serial_open

rt_completion_wait (Thumb, 6 bytes, Stack size 0 bytes, completion_comm.o(.text.rt_completion_wait))

[Stack]

• Max Depth = 448
• Call Chain = rt_completion_wait ⇒ rt_completion_wait_flags ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_completion_wait_flags

• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_tx_blocking_nbuf
• >>   _serial_fifo_tx_nonblocking
• >>   _serial_fifo_rx
• >>   rt_serial_control

rt_completion_wait_flags (Thumb, 320 bytes, Stack size 48 bytes, completion_up.o(.text.rt_completion_wait_flags))

[Stack]

• Max Depth = 448
• Call Chain = rt_completion_wait_flags ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_schedule
• >>   rt_spin_unlock_irqrestore
• >>   rt_timer_start
• >>   rt_timer_control
• >>   rt_thread_suspend_with_flag
• >>   rt_spin_lock_irqsave
• >>   rt_interrupt_get_nest
• >>   rt_critical_level
• >>   rt_assert_handler
• >>   rt_thread_self
• >>   rt_kprintf

• >>   rt_completion_wait

rt_completion_wakeup_by_errno (Thumb, 72 bytes, Stack size 24 bytes, completion_up.o(.text.rt_completion_wakeup_by_errno))

[Stack]

• Max Depth = 424
• Call Chain = rt_completion_wakeup_by_errno ⇒ rt_thread_resume ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_resume
• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_assert_handler

• >>   rt_completion_done

rt_components_board_init (Thumb, 20 bytes, Stack size 16 bytes, components.o(.text.rt_components_board_init))

[Stack]

• Max Depth = 16
• Call Chain = rt_components_board_init

• >>   rt_hw_board_init

rt_components_init (Thumb, 20 bytes, Stack size 16 bytes, components.o(.text.rt_components_init))

[Stack]

• Max Depth = 16
• Call Chain = rt_components_init

• >>   main_thread_entry

rt_console_get_device (Thumb, 8 bytes, Stack size 0 bytes, kservice.o(.text.rt_console_get_device))

[Called By]

• >>   finsh_thread_entry

rt_console_set_device (Thumb, 40 bytes, Stack size 16 bytes, kservice.o(.text.rt_console_set_device))

[Stack]

• Max Depth = 408
• Call Chain = rt_console_set_device ⇒ rt_device_find ⇒ rt_object_find ⇒ rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_device_close
• >>   rt_device_open
• >>   rt_device_find

• >>   rt_hw_board_init

rt_cpu_index (Thumb, 12 bytes, Stack size 0 bytes, cpu_up.o(.text.rt_cpu_index))

[Called By]

• >>   rt_thread_idle_init

rt_cpu_self (Thumb, 4 bytes, Stack size 0 bytes, cpu_up.o(.text.rt_cpu_self))

[Called By]

• >>   rt_schedule
• >>   rt_thread_self
• >>   rt_system_scheduler_start

rt_critical_level (Thumb, 16 bytes, Stack size 8 bytes, scheduler_up.o(.text.rt_critical_level))

[Stack]

• Max Depth = 8
• Call Chain = rt_critical_level

• >>   rt_hw_atomic_load

• >>   rt_completion_wait_flags
• >>   _rt_mutex_take
• >>   _rt_sem_take
• >>   rt_thread_close
• >>   _thread_sleep

rt_defunct_execute (Thumb, 54 bytes, Stack size 16 bytes, defunct.o(.text.rt_defunct_execute))

[Stack]

• Max Depth = 504
• Call Chain = rt_defunct_execute ⇒ rt_object_delete ⇒ rt_free ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_detach
• >>   rt_object_is_systemobject
• >>   rt_free
• >>   rt_object_delete
• >>   rt_thread_defunct_dequeue

• >>   idle_thread_entry

rt_device_close (Thumb, 88 bytes, Stack size 16 bytes, device.o(.text.rt_device_close))

[Stack]

• Max Depth = 280
• Call Chain = rt_device_close ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_get_type
• >>   rt_assert_handler

• >>   finsh_set_device
• >>   rt_console_set_device

rt_device_find (Thumb, 6 bytes, Stack size 0 bytes, device.o(.text.rt_device_find))

[Stack]

• Max Depth = 392
• Call Chain = rt_device_find ⇒ rt_object_find ⇒ rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_find

• >>   rt_device_register
• >>   finsh_set_device
• >>   rt_console_set_device

rt_device_open (Thumb, 192 bytes, Stack size 16 bytes, device.o(.text.rt_device_open))

[Stack]

• Max Depth = 280
• Call Chain = rt_device_open ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_get_type
• >>   rt_assert_handler

• >>   finsh_set_device
• >>   rt_console_set_device

rt_device_pin_register (Thumb, 56 bytes, Stack size 24 bytes, dev_pin.o(.text.rt_device_pin_register))

[Stack]

• Max Depth = 440
• Call Chain = rt_device_pin_register ⇒ rt_device_register ⇒ rt_device_find ⇒ rt_object_find ⇒ rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_device_register
• >>   __aeabi_memclr4

• >>   rt_hw_pin_init

rt_device_read (Thumb, 88 bytes, Stack size 24 bytes, device.o(.text.rt_device_read))

[Stack]

• Max Depth = 288
• Call Chain = rt_device_read ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_set_errno

• >>   finsh_getchar

rt_device_register (Thumb, 44 bytes, Stack size 24 bytes, device.o(.text.rt_device_register))

[Stack]

• Max Depth = 416
• Call Chain = rt_device_register ⇒ rt_device_find ⇒ rt_object_find ⇒ rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_init
• >>   rt_device_find

• >>   rt_hw_serial_register
• >>   rt_device_pin_register

rt_device_set_rx_indicate (Thumb, 52 bytes, Stack size 16 bytes, device.o(.text.rt_device_set_rx_indicate))

[Stack]

• Max Depth = 280
• Call Chain = rt_device_set_rx_indicate ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_get_type
• >>   rt_assert_handler

• >>   finsh_set_device

rt_device_write (Thumb, 88 bytes, Stack size 24 bytes, device.o(.text.rt_device_write))

[Stack]

• Max Depth = 48 + In Cycle
• Call Chain = rt_device_write ⇒ rt_assert_handler (Cycle)

• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_set_errno

• >>   _kputs

rt_enter_critical (Thumb, 16 bytes, Stack size 8 bytes, scheduler_up.o(.text.rt_enter_critical))

[Stack]

• Max Depth = 16
• Call Chain = rt_enter_critical ⇒ rt_hw_atomic_add

• >>   rt_hw_atomic_add

• >>   rt_spin_lock
• >>   rt_spin_lock_irqsave
• >>   _thread_sleep
• >>   _thread_detach
• >>   _thread_exit

rt_exit_critical (Thumb, 56 bytes, Stack size 16 bytes, scheduler_up.o(.text.rt_exit_critical))

[Stack]

• Max Depth = 328
• Call Chain = rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_schedule
• >>   rt_hw_interrupt_enable
• >>   rt_hw_interrupt_disable

• >>   rt_exit_critical_safe

rt_exit_critical_safe (Thumb, 4 bytes, Stack size 0 bytes, scheduler_up.o(.text.rt_exit_critical_safe))

[Stack]

• Max Depth = 328
• Call Chain = rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_exit_critical

• >>   rt_spin_unlock
• >>   rt_spin_unlock_irqrestore
• >>   _thread_sleep
• >>   _thread_detach
• >>   _thread_exit

rt_free (Thumb, 40 bytes, Stack size 16 bytes, kservice.o(.text.rt_free))

[Stack]

• Max Depth = 472
• Call Chain = rt_free ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   _heap_unlock
• >>   _heap_lock
• >>   rt_smem_free

• >>   rt_serial_close
• >>   rt_object_delete
• >>   rt_defunct_execute

rt_hw_atomic_add (Thumb, 20 bytes, Stack size 8 bytes, atomic_arm.o(.text.rt_hw_atomic_add))

[Stack]

• Max Depth = 8
• Call Chain = rt_hw_atomic_add

• >>   rt_enter_critical
• >>   rt_tick_increase
• >>   rt_interrupt_enter

rt_hw_atomic_flag_clear (Thumb, 16 bytes, Stack size 0 bytes, atomic_arm.o(.text.rt_hw_atomic_flag_clear))

[Called By]

• >>   rt_hw_serial_isr
• >>   rt_serial_open

rt_hw_atomic_flag_test_and_set (Thumb, 18 bytes, Stack size 0 bytes, atomic_arm.o(.text.rt_hw_atomic_flag_test_and_set))

[Called By]

• >>   rt_hw_serial_isr
• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_tx_blocking_nbuf
• >>   _serial_fifo_tx_nonblocking

rt_hw_atomic_load (Thumb, 16 bytes, Stack size 0 bytes, atomic_arm.o(.text.rt_hw_atomic_load))

[Calls]

• >>   rt_hw_atomic_load

• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_tx_blocking_nbuf
• >>   _serial_fifo_rx
• >>   rt_serial_control
• >>   rt_hw_atomic_load
• >>   rt_interrupt_get_nest
• >>   rt_critical_level
• >>   rt_tick_get

rt_hw_atomic_store (Thumb, 14 bytes, Stack size 0 bytes, atomic_arm.o(.text.rt_hw_atomic_store))

[Calls]

• >>   rt_hw_atomic_store

• >>   rt_serial_open
• >>   rt_serial_control
• >>   rt_hw_atomic_store

rt_hw_atomic_sub (Thumb, 20 bytes, Stack size 8 bytes, atomic_arm.o(.text.rt_hw_atomic_sub))

[Stack]

• Max Depth = 8
• Call Chain = rt_hw_atomic_sub

• >>   rt_interrupt_leave

rt_hw_backtrace_frame_get (Thumb, 24 bytes, Stack size 8 bytes, kservice.o(.text.rt_hw_backtrace_frame_get))

[Stack]

• Max Depth = 8
• Call Chain = rt_hw_backtrace_frame_get

• >>   rt_backtrace_thread

rt_hw_backtrace_frame_unwind (Thumb, 24 bytes, Stack size 8 bytes, kservice.o(.text.rt_hw_backtrace_frame_unwind))

[Stack]

• Max Depth = 8
• Call Chain = rt_hw_backtrace_frame_unwind

• >>   rt_backtrace_frame
• >>   rt_backtrace

rt_hw_board_init (Thumb, 40 bytes, Stack size 8 bytes, drv_common.o(.text.rt_hw_board_init))

[Stack]

• Max Depth = 472
• Call Chain = rt_hw_board_init ⇒ rt_hw_usart_init ⇒ rt_hw_serial_register ⇒ rt_device_register ⇒ rt_device_find ⇒ rt_object_find ⇒ rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_components_board_init
• >>   rt_console_set_device
• >>   rt_system_heap_init
• >>   rt_hw_systick_init
• >>   rt_hw_usart_init
• >>   rt_hw_pin_init

• >>   rtthread_startup

rt_hw_console_output (Thumb, 2 bytes, Stack size 0 bytes, kservice.o(.text.rt_hw_console_output))

[Called By]

• >>   _kputs

rt_hw_hard_fault_exception (Thumb, 68 bytes, Stack size 0 bytes, cpuport.o(.text.rt_hw_hard_fault_exception))

[Stack]

• Max Depth = 488
• Call Chain = rt_hw_hard_fault_exception ⇒ list_thread ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_self
• >>   list_thread

• >>   HardFault_Handler

rt_hw_pin_init (Thumb, 12 bytes, Stack size 0 bytes, drv_gpio.o(.text.rt_hw_pin_init))

[Stack]

• Max Depth = 440
• Call Chain = rt_hw_pin_init ⇒ rt_device_pin_register ⇒ rt_device_register ⇒ rt_device_find ⇒ rt_object_find ⇒ rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_device_pin_register

• >>   rt_hw_board_init

rt_hw_serial_control_isr (Thumb, 128 bytes, Stack size 24 bytes, dev_serial_v2.o(.text.rt_hw_serial_control_isr))

[Stack]

• Max Depth = 304
• Call Chain = rt_hw_serial_control_isr ⇒ rt_ringbuffer_getchar ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_ringbuffer_getchar
• >>   rt_ringbuffer_putchar_force
• >>   rt_assert_handler

• >>   user_uart0_callback

rt_hw_serial_isr (Thumb, 520 bytes, Stack size 48 bytes, dev_serial_v2.o(.text.rt_hw_serial_isr))

[Stack]

• Max Depth = 472
• Call Chain = rt_hw_serial_isr ⇒ rt_completion_done ⇒ rt_completion_wakeup_by_errno ⇒ rt_thread_resume ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_hw_atomic_flag_test_and_set
• >>   rt_hw_atomic_flag_clear
• >>   rt_serial_get_linear_buffer
• >>   rt_serial_update_read_index
• >>   rt_ringbuffer_peek
• >>   rt_ringbuffer_put_force
• >>   rt_ringbuffer_data_len
• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_completion_done
• >>   rt_assert_handler

• >>   user_uart0_callback

rt_hw_serial_register (Thumb, 76 bytes, Stack size 24 bytes, dev_serial_v2.o(.text.rt_hw_serial_register))

[Stack]

• Max Depth = 440
• Call Chain = rt_hw_serial_register ⇒ rt_device_register ⇒ rt_device_find ⇒ rt_object_find ⇒ rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_lock_init
• >>   rt_assert_handler
• >>   rt_device_register

• >>   rt_hw_usart_init

rt_hw_stack_init (Thumb, 68 bytes, Stack size 20 bytes, cpuport.o(.text.rt_hw_stack_init))

[Stack]

• Max Depth = 20
• Call Chain = rt_hw_stack_init

• >>   _thread_init

rt_hw_systick_init (Thumb, 60 bytes, Stack size 8 bytes, drv_common.o(.text.rt_hw_systick_init))

[Stack]

• Max Depth = 8
• Call Chain = rt_hw_systick_init

• >>   rt_hw_board_init

rt_hw_usart_init (Thumb, 92 bytes, Stack size 24 bytes, drv_usart_v2.o(.text.rt_hw_usart_init))

[Stack]

• Max Depth = 464
• Call Chain = rt_hw_usart_init ⇒ rt_hw_serial_register ⇒ rt_device_register ⇒ rt_device_find ⇒ rt_object_find ⇒ rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_hw_serial_register
• >>   rt_assert_handler

• >>   rt_hw_board_init

rt_interrupt_enter (Thumb, 28 bytes, Stack size 8 bytes, irq.o(.text.rt_interrupt_enter))

[Stack]

• Max Depth = 16
• Call Chain = rt_interrupt_enter ⇒ rt_hw_atomic_add

• >>   rt_hw_atomic_add

• >>   SysTick_Handler
• >>   user_uart0_callback

rt_interrupt_get_nest (Thumb, 28 bytes, Stack size 16 bytes, irq.o(.text.rt_interrupt_get_nest))

[Stack]

• Max Depth = 16
• Call Chain = rt_interrupt_get_nest

• >>   rt_hw_atomic_load
• >>   rt_hw_interrupt_enable
• >>   rt_hw_interrupt_disable

• >>   rt_mutex_release
• >>   rt_completion_wait_flags
• >>   rt_object_find
• >>   rt_set_errno
• >>   rt_mutex_drop_thread
• >>   rt_object_allocate
• >>   _rt_mutex_take
• >>   _rt_sem_take
• >>   rt_timer_check
• >>   rt_tick_increase
• >>   _thread_sleep
• >>   rt_object_for_each

rt_interrupt_leave (Thumb, 28 bytes, Stack size 8 bytes, irq.o(.text.rt_interrupt_leave))

[Stack]

• Max Depth = 16
• Call Chain = rt_interrupt_leave ⇒ rt_hw_atomic_sub

• >>   rt_hw_atomic_sub

• >>   SysTick_Handler
• >>   user_uart0_callback

rt_kprintf (Thumb, 56 bytes, Stack size 32 bytes, kservice.o(.text.rt_kprintf))

[Stack]

• Max Depth = 200
• Call Chain = rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   _kputs
• >>   rt_vsnprintf

• >>   _pin_cmd
• >>   rt_mutex_release
• >>   rt_completion_wait_flags
• >>   rt_assert_handler
• >>   rt_object_find
• >>   msh_exec
• >>   hal_entry
• >>   cmd_backtrace
• >>   rt_mutex_drop_thread
• >>   rt_object_allocate
• >>   _rt_mutex_take
• >>   _rt_sem_take
• >>   list_device
• >>   list_timer
• >>   list_msgqueue
• >>   list_mailbox
• >>   list_mutex
• >>   list_event
• >>   rt_susp_list_print
• >>   list_sem
• >>   cmd_list
• >>   object_split
• >>   clear
• >>   msh_opt_list_dump
• >>   list_thread
• >>   msh_help
• >>   msh_opt_auto_complete
• >>   msh_auto_complete
• >>   finsh_system_init
• >>   finsh_set_device
• >>   shell_handle_history
• >>   finsh_thread_entry
• >>   _thread_sleep
• >>   rt_object_for_each
• >>   rt_smem_init
• >>   rt_backtrace_frame

• device.o(.text.rt_device_open)
• cstdlib.o(.text.__rt_libc_exit)
• dev_serial_v2.o(.text.rt_serial_open)
• dev_serial_v2.o(.text.rt_serial_control)
• drv_gpio.o(.text.ra_pin_get)
• dev_pin.o(.text._pin_cmd_print_usage)
• dev_serial_v2.o(.text.rt_hw_serial_isr)
• kservice.o(.text.rt_hw_backtrace_frame_get)
• kservice.o(.text.rt_hw_backtrace_frame_unwind)
• kservice.o(.text.rt_show_version)
• drv_gpio.o(.text.ra_pin_mode)
• msh.o(.text.cmd_free)
• cmd.o(.text.list_thread)
• scheduler_comm.o(.text.rt_scheduler_stack_check)
• object.o(.text.rt_object_init)
• cpuport.o(.text.rt_hw_hard_fault_exception)

rt_malloc (Thumb, 48 bytes, Stack size 24 bytes, kservice.o(.text.rt_malloc))

[Stack]

• Max Depth = 480
• Call Chain = rt_malloc ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   _heap_unlock
• >>   _heap_lock
• >>   rt_smem_alloc

• >>   rt_serial_open
• >>   rt_thread_create
• >>   rt_calloc
• >>   rt_object_allocate

rt_memcpy (Thumb, 86 bytes, Stack size 16 bytes, kstring.o(.text.rt_memcpy))

[Stack]

• Max Depth = 16
• Call Chain = rt_memcpy

• >>   rt_serial_control
• >>   rt_ringbuffer_put_force
• >>   rt_ringbuffer_put
• >>   rt_ringbuffer_get
• >>   rt_object_init
• >>   rt_object_allocate
• >>   finsh_thread_entry

rt_memmove (Thumb, 44 bytes, Stack size 8 bytes, kstring.o(.text.rt_memmove))

[Stack]

• Max Depth = 8
• Call Chain = rt_memmove

• >>   finsh_thread_entry

rt_memory_info (Thumb, 52 bytes, Stack size 16 bytes, kservice.o(.text.rt_memory_info))

[Stack]

• Max Depth = 472
• Call Chain = rt_memory_info ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   _heap_unlock
• >>   _heap_lock

• >>   cmd_free

rt_memset (Thumb, 76 bytes, Stack size 12 bytes, kstring.o(.text.rt_memset))

[Stack]

• Max Depth = 12
• Call Chain = rt_memset

• >>   rt_serial_open
• >>   rt_serial_close
• >>   msh_exec
• >>   rt_calloc
• >>   rt_object_allocate
• >>   rt_thread_init
• >>   finsh_set_device
• >>   finsh_thread_entry
• >>   _thread_init
• >>   rt_smem_init

rt_mutex_drop_thread (Thumb, 224 bytes, Stack size 32 bytes, ipc.o(.text.rt_mutex_drop_thread))

[Stack]

• Max Depth = 376
• Call Chain = rt_mutex_drop_thread ⇒ _thread_update_priority ⇒ rt_sched_thread_change_priority ⇒ _rt_sched_update_priority ⇒ rt_sched_insert_thread ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock
• >>   rt_spin_lock
• >>   rt_interrupt_get_nest
• >>   rt_assert_handler
• >>   rt_thread_self
• >>   rt_kprintf
• >>   rt_sched_thread_get_curr_prio
• >>   rt_sched_unlock
• >>   rt_sched_lock
• >>   _thread_update_priority
• >>   _thread_get_mutex_priority

• >>   _thread_detach_from_mutex

rt_mutex_init (Thumb, 72 bytes, Stack size 16 bytes, ipc.o(.text.rt_mutex_init))

[Stack]

• Max Depth = 392
• Call Chain = rt_mutex_init ⇒ rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_lock_init
• >>   rt_assert_handler
• >>   rt_object_init

• >>   rt_system_heap_init_generic

rt_mutex_release (Thumb, 356 bytes, Stack size 40 bytes, ipc.o(.text.rt_mutex_release))

[Stack]

• Max Depth = 416
• Call Chain = rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock
• >>   rt_spin_lock
• >>   rt_schedule
• >>   rt_interrupt_get_nest
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_thread_self
• >>   rt_kprintf
• >>   rt_sched_thread_is_suspended
• >>   rt_sched_thread_get_curr_prio
• >>   rt_sched_unlock
• >>   rt_sched_thread_ready
• >>   rt_sched_lock
• >>   _check_and_update_prio

• >>   _heap_unlock
• >>   _thread_detach_from_mutex

rt_mutex_take (Thumb, 6 bytes, Stack size 0 bytes, ipc.o(.text.rt_mutex_take))

[Stack]

• Max Depth = 448
• Call Chain = rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   _rt_mutex_take

• >>   _heap_lock

rt_object_allocate (Thumb, 200 bytes, Stack size 24 bytes, object.o(.text.rt_object_allocate))

[Stack]

• Max Depth = 504
• Call Chain = rt_object_allocate ⇒ rt_malloc ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_interrupt_get_nest
• >>   rt_assert_handler
• >>   rt_memcpy
• >>   rt_memset
• >>   rt_strlen
• >>   rt_malloc
• >>   rt_kprintf
• >>   rt_object_get_information

• >>   rt_thread_create

rt_object_delete (Thumb, 116 bytes, Stack size 16 bytes, object.o(.text.rt_object_delete))

[Stack]

• Max Depth = 488
• Call Chain = rt_object_delete ⇒ rt_free ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_assert_handler
• >>   rt_free
• >>   rt_object_get_information

• >>   rt_thread_create
• >>   rt_defunct_execute

rt_object_detach (Thumb, 92 bytes, Stack size 16 bytes, object.o(.text.rt_object_detach))

[Stack]

• Max Depth = 352
• Call Chain = rt_object_detach ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_assert_handler
• >>   rt_object_get_information

• >>   rt_defunct_execute
• >>   rt_timer_detach

rt_object_find (Thumb, 64 bytes, Stack size 24 bytes, object.o(.text.rt_object_find))

[Stack]

• Max Depth = 392
• Call Chain = rt_object_find ⇒ rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_interrupt_get_nest
• >>   rt_assert_handler
• >>   rt_kprintf
• >>   rt_object_get_information
• >>   rt_object_for_each

• >>   rt_device_find

rt_object_for_each (Thumb, 112 bytes, Stack size 32 bytes, object.o(.text.rt_object_for_each))

[Stack]

• Max Depth = 368
• Call Chain = rt_object_for_each ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_interrupt_get_nest
• >>   rt_assert_handler
• >>   rt_kprintf
• >>   rt_object_get_information

• >>   rt_object_find

rt_object_get_information (Thumb, 36 bytes, Stack size 8 bytes, object.o(.text.rt_object_get_information))

[Stack]

• Max Depth = 8
• Call Chain = rt_object_get_information

• >>   rt_object_detach
• >>   rt_object_find
• >>   rt_object_init
• >>   rt_object_allocate
• >>   rt_object_delete
• >>   list_device
• >>   list_timer
• >>   list_msgqueue
• >>   list_mailbox
• >>   list_mutex
• >>   list_event
• >>   list_sem
• >>   list_thread
• >>   rt_object_for_each

rt_object_get_type (Thumb, 24 bytes, Stack size 8 bytes, object.o(.text.rt_object_get_type))

[Stack]

• Max Depth = 8 + In Cycle
• Call Chain = rt_object_get_type ⇒ rt_assert_handler (Cycle)

• >>   rt_assert_handler

• >>   rt_thread_delete
• >>   rt_sem_release
• >>   rt_thread_startup
• >>   rt_thread_suspend_to_list
• >>   rt_mutex_release
• >>   rt_thread_resume
• >>   rt_timer_start
• >>   rt_timer_control
• >>   rt_device_set_rx_indicate
• >>   rt_device_read
• >>   rt_device_close
• >>   rt_device_open
• >>   rt_thread_control
• >>   rt_device_write
• >>   cmd_backtrace
• >>   rt_sem_control
• >>   _rt_mutex_take
• >>   _thread_update_priority
• >>   _rt_sem_take
• >>   rt_thread_detach
• >>   rt_timer_detach
• >>   _thread_sleep
• >>   _thread_detach_from_mutex
• >>   _thread_timeout
• >>   rt_timer_stop
• >>   rt_smem_free
• >>   rt_smem_alloc

rt_object_init (Thumb, 212 bytes, Stack size 40 bytes, object.o(.text.rt_object_init))

[Stack]

• Max Depth = 376
• Call Chain = rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_assert_handler
• >>   rt_memcpy
• >>   rt_strlen
• >>   rt_object_get_information

• >>   rt_sem_init
• >>   rt_mutex_init
• >>   rt_device_register
• >>   rt_thread_init
• >>   rt_timer_init
• >>   rt_smem_init

rt_object_is_systemobject (Thumb, 24 bytes, Stack size 8 bytes, object.o(.text.rt_object_is_systemobject))

[Stack]

• Max Depth = 272
• Call Chain = rt_object_is_systemobject ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   rt_thread_delete
• >>   rt_thread_control
• >>   rt_defunct_execute
• >>   rt_thread_detach
• >>   rt_timer_detach
• >>   rt_smem_free
• >>   rt_smem_alloc

rt_pin_get (Thumb, 44 bytes, Stack size 16 bytes, dev_pin.o(.text.rt_pin_get))

[Stack]

• Max Depth = 280
• Call Chain = rt_pin_get ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   _pin_cmd_print_usage
• >>   _pin_cmd

rt_pin_mode (Thumb, 44 bytes, Stack size 16 bytes, dev_pin.o(.text.rt_pin_mode))

[Stack]

• Max Depth = 280
• Call Chain = rt_pin_mode ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   _pin_cmd

rt_pin_read (Thumb, 36 bytes, Stack size 16 bytes, dev_pin.o(.text.rt_pin_read))

[Stack]

• Max Depth = 280
• Call Chain = rt_pin_read ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   _pin_cmd

rt_pin_write (Thumb, 44 bytes, Stack size 16 bytes, dev_pin.o(.text.rt_pin_write))

[Stack]

• Max Depth = 280
• Call Chain = rt_pin_write ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   _pin_cmd
• >>   hal_entry

rt_ringbuffer_data_len (Thumb, 54 bytes, Stack size 8 bytes, ringbuffer.o(.text.rt_ringbuffer_data_len))

[Stack]

• Max Depth = 8
• Call Chain = rt_ringbuffer_data_len

• >>   rt_hw_serial_isr
• >>   rt_serial_get_linear_buffer
• >>   rt_serial_update_read_index
• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_rx
• >>   rt_serial_control
• >>   rt_ringbuffer_getchar
• >>   rt_ringbuffer_peek
• >>   rt_ringbuffer_put_force
• >>   rt_ringbuffer_put
• >>   rt_ringbuffer_get

rt_ringbuffer_get (Thumb, 124 bytes, Stack size 24 bytes, ringbuffer.o(.text.rt_ringbuffer_get))

[Stack]

• Max Depth = 288
• Call Chain = rt_ringbuffer_get ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_ringbuffer_data_len
• >>   rt_assert_handler
• >>   rt_memcpy

• >>   _serial_fifo_rx

rt_ringbuffer_getchar (Thumb, 68 bytes, Stack size 16 bytes, ringbuffer.o(.text.rt_ringbuffer_getchar))

[Stack]

• Max Depth = 280
• Call Chain = rt_ringbuffer_getchar ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_ringbuffer_data_len
• >>   rt_assert_handler

• >>   rt_hw_serial_control_isr

rt_ringbuffer_init (Thumb, 52 bytes, Stack size 16 bytes, ringbuffer.o(.text.rt_ringbuffer_init))

[Stack]

• Max Depth = 280
• Call Chain = rt_ringbuffer_init ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   rt_serial_open

rt_ringbuffer_peek (Thumb, 76 bytes, Stack size 16 bytes, ringbuffer.o(.text.rt_ringbuffer_peek))

[Stack]

• Max Depth = 280
• Call Chain = rt_ringbuffer_peek ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_ringbuffer_data_len
• >>   rt_assert_handler

• >>   rt_hw_serial_isr

rt_ringbuffer_put (Thumb, 124 bytes, Stack size 24 bytes, ringbuffer.o(.text.rt_ringbuffer_put))

[Stack]

• Max Depth = 288
• Call Chain = rt_ringbuffer_put ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_ringbuffer_data_len
• >>   rt_assert_handler
• >>   rt_memcpy

• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_tx_nonblocking

rt_ringbuffer_put_force (Thumb, 176 bytes, Stack size 24 bytes, ringbuffer.o(.text.rt_ringbuffer_put_force))

[Stack]

• Max Depth = 288
• Call Chain = rt_ringbuffer_put_force ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_ringbuffer_data_len
• >>   rt_assert_handler
• >>   rt_memcpy

• >>   rt_hw_serial_isr

rt_ringbuffer_putchar_force (Thumb, 100 bytes, Stack size 16 bytes, ringbuffer.o(.text.rt_ringbuffer_putchar_force))

[Stack]

• Max Depth = 280
• Call Chain = rt_ringbuffer_putchar_force ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   rt_hw_serial_control_isr

rt_ringbuffer_reset (Thumb, 28 bytes, Stack size 8 bytes, ringbuffer.o(.text.rt_ringbuffer_reset))

[Stack]

• Max Depth = 272
• Call Chain = rt_ringbuffer_reset ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   rt_serial_control

rt_sched_insert_thread (Thumb, 120 bytes, Stack size 16 bytes, scheduler_up.o(.text.rt_sched_insert_thread))

[Stack]

• Max Depth = 280
• Call Chain = rt_sched_insert_thread ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler
• >>   rt_thread_self
• >>   rt_hw_interrupt_enable
• >>   rt_hw_interrupt_disable

• >>   rt_schedule
• >>   rt_sched_thread_ready
• >>   _thread_timeout
• >>   _rt_sched_update_priority

rt_sched_lock (Thumb, 22 bytes, Stack size 8 bytes, scheduler_up.o(.text.rt_sched_lock))

[Stack]

• Max Depth = 8
• Call Chain = rt_sched_lock

• >>   rt_hw_interrupt_disable

• >>   rt_susp_list_dequeue
• >>   rt_thread_suspend_to_list
• >>   rt_mutex_release
• >>   rt_thread_resume
• >>   rt_timer_start
• >>   rt_thread_control
• >>   rt_mutex_drop_thread
• >>   _rt_mutex_take
• >>   rt_sched_tick_increase
• >>   rt_susp_list_print
• >>   rt_thread_close
• >>   _thread_timeout

rt_sched_remove_thread (Thumb, 72 bytes, Stack size 8 bytes, scheduler_up.o(.text.rt_sched_remove_thread))

[Stack]

• Max Depth = 272
• Call Chain = rt_sched_remove_thread ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler
• >>   rt_hw_interrupt_enable
• >>   rt_hw_interrupt_disable

• >>   rt_thread_suspend_to_list
• >>   rt_schedule
• >>   rt_system_scheduler_start
• >>   rt_thread_close
• >>   _rt_sched_update_priority

rt_sched_thread_bind_cpu (Thumb, 6 bytes, Stack size 0 bytes, scheduler_up.o(.text.rt_sched_thread_bind_cpu))

[Called By]

• >>   rt_thread_control

rt_sched_thread_change_priority (Thumb, 14 bytes, Stack size 8 bytes, scheduler_comm.o(.text.rt_sched_thread_change_priority))

[Stack]

• Max Depth = 312
• Call Chain = rt_sched_thread_change_priority ⇒ _rt_sched_update_priority ⇒ rt_sched_insert_thread ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   _rt_sched_update_priority

• >>   rt_thread_control
• >>   _thread_update_priority
• >>   _check_and_update_prio

rt_sched_thread_close (Thumb, 10 bytes, Stack size 0 bytes, scheduler_comm.o(.text.rt_sched_thread_close))

[Called By]

• >>   rt_thread_close

rt_sched_thread_get_curr_prio (Thumb, 6 bytes, Stack size 0 bytes, scheduler_comm.o(.text.rt_sched_thread_get_curr_prio))

[Called By]

• >>   rt_mutex_release
• >>   rt_mutex_drop_thread
• >>   rt_susp_list_enqueue
• >>   _rt_mutex_take
• >>   _thread_update_priority
• >>   _check_and_update_prio

rt_sched_thread_get_init_prio (Thumb, 6 bytes, Stack size 0 bytes, scheduler_comm.o(.text.rt_sched_thread_get_init_prio))

[Called By]

• >>   _thread_get_mutex_priority

rt_sched_thread_get_stat (Thumb, 10 bytes, Stack size 0 bytes, scheduler_comm.o(.text.rt_sched_thread_get_stat))

[Called By]

• >>   rt_thread_suspend_to_list
• >>   rt_thread_close

rt_sched_thread_init_ctx (Thumb, 14 bytes, Stack size 8 bytes, scheduler_comm.o(.text.rt_sched_thread_init_ctx))

[Stack]

• Max Depth = 296
• Call Chain = rt_sched_thread_init_ctx ⇒ rt_sched_thread_init_priv ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_sched_thread_init_priv

• >>   _thread_init

rt_sched_thread_init_priv (Thumb, 48 bytes, Stack size 24 bytes, scheduler_up.o(.text.rt_sched_thread_init_priv))

[Stack]

• Max Depth = 288
• Call Chain = rt_sched_thread_init_priv ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   rt_sched_thread_init_ctx

rt_sched_thread_is_suspended (Thumb, 10 bytes, Stack size 0 bytes, scheduler_comm.o(.text.rt_sched_thread_is_suspended))

[Called By]

• >>   rt_mutex_release
• >>   _thread_update_priority
• >>   _thread_timeout

rt_sched_thread_ready (Thumb, 64 bytes, Stack size 8 bytes, scheduler_comm.o(.text.rt_sched_thread_ready))

[Stack]

• Max Depth = 376
• Call Chain = rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_sched_insert_thread
• >>   rt_sched_thread_timer_stop

• >>   rt_susp_list_dequeue
• >>   rt_mutex_release
• >>   rt_thread_resume

rt_sched_thread_reset_priority (Thumb, 12 bytes, Stack size 8 bytes, scheduler_comm.o(.text.rt_sched_thread_reset_priority))

[Stack]

• Max Depth = 312
• Call Chain = rt_sched_thread_reset_priority ⇒ _rt_sched_update_priority ⇒ rt_sched_insert_thread ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   _rt_sched_update_priority

• >>   rt_thread_control

rt_sched_thread_startup (Thumb, 20 bytes, Stack size 0 bytes, scheduler_up.o(.text.rt_sched_thread_startup))

[Called By]

• >>   rt_thread_startup

rt_sched_thread_timer_start (Thumb, 14 bytes, Stack size 0 bytes, scheduler_comm.o(.text.rt_sched_thread_timer_start))

[Called By]

• >>   rt_timer_start

rt_sched_thread_timer_stop (Thumb, 34 bytes, Stack size 8 bytes, scheduler_comm.o(.text.rt_sched_thread_timer_stop))

[Stack]

• Max Depth = 368
• Call Chain = rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_timer_stop

• >>   rt_thread_suspend_to_list
• >>   rt_sched_thread_ready

rt_sched_tick_increase (Thumb, 62 bytes, Stack size 24 bytes, scheduler_comm.o(.text.rt_sched_tick_increase))

[Stack]

• Max Depth = 344
• Call Chain = rt_sched_tick_increase ⇒ rt_sched_unlock_n_resched ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_self
• >>   rt_sched_unlock_n_resched
• >>   rt_sched_unlock
• >>   rt_sched_lock

• >>   rt_tick_increase

rt_sched_unlock (Thumb, 10 bytes, Stack size 8 bytes, scheduler_up.o(.text.rt_sched_unlock))

[Stack]

• Max Depth = 8
• Call Chain = rt_sched_unlock

• >>   rt_hw_interrupt_enable

• >>   rt_susp_list_dequeue
• >>   rt_thread_suspend_to_list
• >>   rt_mutex_release
• >>   rt_thread_resume
• >>   rt_timer_start
• >>   rt_thread_control
• >>   rt_mutex_drop_thread
• >>   _rt_mutex_take
• >>   rt_sched_tick_increase
• >>   rt_susp_list_print
• >>   rt_thread_close

rt_sched_unlock_n_resched (Thumb, 24 bytes, Stack size 8 bytes, scheduler_up.o(.text.rt_sched_unlock_n_resched))

[Stack]

• Max Depth = 320
• Call Chain = rt_sched_unlock_n_resched ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_schedule
• >>   rt_thread_self
• >>   rt_hw_interrupt_enable

• >>   rt_thread_resume
• >>   rt_sched_tick_increase
• >>   _thread_timeout

rt_schedule (Thumb, 224 bytes, Stack size 32 bytes, scheduler_up.o(.text.rt_schedule))

[Stack]

• Max Depth = 312
• Call Chain = rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_self
• >>   rt_cpu_self
• >>   rt_hw_interrupt_enable
• >>   rt_hw_interrupt_disable
• >>   rt_hw_context_switch
• >>   rt_hw_context_switch_interrupt
• >>   _scheduler_get_highest_priority_thread
• >>   rt_scheduler_stack_check
• >>   rt_sched_remove_thread
• >>   rt_sched_insert_thread

• >>   rt_sem_release
• >>   rt_exit_critical
• >>   rt_mutex_release
• >>   rt_completion_wait_flags
• >>   rt_thread_control
• >>   rt_sched_unlock_n_resched
• >>   rt_sem_control
• >>   _rt_mutex_take
• >>   _rt_sem_take
• >>   _thread_sleep
• >>   _thread_exit

rt_scheduler_stack_check (Thumb, 104 bytes, Stack size 16 bytes, scheduler_comm.o(.text.rt_scheduler_stack_check))

[Stack]

• Max Depth = 280
• Call Chain = rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   rt_schedule

rt_sem_control (Thumb, 160 bytes, Stack size 24 bytes, ipc.o(.text.rt_sem_control))

[Stack]

• Max Depth = 440
• Call Chain = rt_sem_control ⇒ rt_susp_list_resume_all ⇒ rt_susp_list_dequeue ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_schedule
• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_susp_list_resume_all

• >>   rt_system_timer_thread_init

rt_sem_init (Thumb, 88 bytes, Stack size 24 bytes, ipc.o(.text.rt_sem_init))

[Stack]

• Max Depth = 400
• Call Chain = rt_sem_init ⇒ rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler
• >>   rt_object_init
• >>   _sem_object_init

• >>   rt_system_timer_thread_init
• >>   finsh_system_init

rt_sem_release (Thumb, 132 bytes, Stack size 24 bytes, ipc.o(.text.rt_sem_release))

[Stack]

• Max Depth = 424
• Call Chain = rt_sem_release ⇒ rt_susp_list_dequeue ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_susp_list_dequeue
• >>   rt_schedule
• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_object_get_type
• >>   rt_assert_handler

• >>   rt_timer_check
• >>   finsh_rx_ind

rt_sem_take (Thumb, 6 bytes, Stack size 0 bytes, ipc.o(.text.rt_sem_take))

[Stack]

• Max Depth = 440
• Call Chain = rt_sem_take ⇒ _rt_sem_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   _rt_sem_take

• >>   finsh_getchar
• >>   _timer_thread_entry

rt_set_errno (Thumb, 28 bytes, Stack size 8 bytes, kerrno.o(.text.rt_set_errno))

[Stack]

• Max Depth = 24
• Call Chain = rt_set_errno ⇒ rt_interrupt_get_nest

• >>   rt_interrupt_get_nest
• >>   rt_thread_self

• >>   rt_device_read
• >>   rt_device_write

rt_show_version (Thumb, 44 bytes, Stack size 16 bytes, kservice.o(.text.rt_show_version))

[Stack]

• Max Depth = 16
• Call Chain = rt_show_version

• >>   rtthread_startup
• >>   version

rt_smem_alloc (Thumb, 328 bytes, Stack size 40 bytes, mem.o(.text.rt_smem_alloc))

[Stack]

• Max Depth = 312
• Call Chain = rt_smem_alloc ⇒ rt_object_is_systemobject ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_is_systemobject
• >>   rt_object_get_type
• >>   rt_assert_handler

• >>   rt_malloc

rt_smem_free (Thumb, 212 bytes, Stack size 24 bytes, mem.o(.text.rt_smem_free))

[Stack]

• Max Depth = 304
• Call Chain = rt_smem_free ⇒ plug_holes ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_is_systemobject
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   plug_holes

• >>   rt_free

rt_smem_init (Thumb, 120 bytes, Stack size 24 bytes, mem.o(.text.rt_smem_init))

[Stack]

• Max Depth = 400
• Call Chain = rt_smem_init ⇒ rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_init
• >>   rt_memset
• >>   rt_kprintf

• >>   rt_system_heap_init_generic

rt_snprintf (Thumb, 22 bytes, Stack size 16 bytes, kstdio.o(.text.rt_snprintf))

[Stack]

• Max Depth = 184
• Call Chain = rt_snprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_vsnprintf

• >>   rt_thread_idle_init

rt_spin_lock (Thumb, 4 bytes, Stack size 0 bytes, cpu_up.o(.text.rt_spin_lock))

[Stack]

• Max Depth = 16
• Call Chain = rt_spin_lock ⇒ rt_enter_critical ⇒ rt_hw_atomic_add

• >>   rt_enter_critical

• >>   rt_mutex_release
• >>   rt_mutex_drop_thread
• >>   _rt_mutex_take

rt_spin_lock_init (Thumb, 2 bytes, Stack size 0 bytes, cpu_up.o(.text.rt_spin_lock_init))

[Called By]

• >>   rt_hw_serial_register
• >>   rt_mutex_init
• >>   _sem_object_init
• >>   rt_thread_defunct_init
• >>   rt_thread_idle_init
• >>   rt_system_timer_thread_init
• >>   rt_system_timer_init
• >>   _thread_init

rt_spin_lock_irqsave (Thumb, 16 bytes, Stack size 8 bytes, cpu_up.o(.text.rt_spin_lock_irqsave))

[Stack]

• Max Depth = 24
• Call Chain = rt_spin_lock_irqsave ⇒ rt_enter_critical ⇒ rt_hw_atomic_add

• >>   rt_enter_critical
• >>   rt_hw_interrupt_disable

• >>   rt_hw_serial_isr
• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_tx_nonblocking
• >>   _serial_fifo_rx
• >>   rt_serial_control
• >>   rt_sem_release
• >>   rt_timer_start
• >>   rt_timer_control
• >>   rt_completion_wait_flags
• >>   rt_completion_wakeup_by_errno
• >>   rt_object_detach
• >>   rt_object_init
• >>   rt_sem_control
• >>   rt_object_allocate
• >>   _rt_sem_take
• >>   rt_object_delete
• >>   rt_thread_defunct_dequeue
• >>   rt_thread_defunct_enqueue
• >>   list_device
• >>   list_timer
• >>   list_msgqueue
• >>   list_mailbox
• >>   list_mutex
• >>   list_event
• >>   list_sem
• >>   list_get_next
• >>   list_thread
• >>   _timer_check
• >>   rt_timer_detach
• >>   _thread_detach_from_mutex
• >>   rt_timer_stop
• >>   rt_object_for_each

rt_spin_unlock (Thumb, 6 bytes, Stack size 0 bytes, cpu_up.o(.text.rt_spin_unlock))

[Stack]

• Max Depth = 328
• Call Chain = rt_spin_unlock ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_exit_critical_safe

• >>   rt_mutex_release
• >>   rt_mutex_drop_thread
• >>   _rt_mutex_take

rt_spin_unlock_irqrestore (Thumb, 22 bytes, Stack size 8 bytes, cpu_up.o(.text.rt_spin_unlock_irqrestore))

[Stack]

• Max Depth = 336
• Call Chain = rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_hw_interrupt_enable
• >>   rt_exit_critical_safe

• >>   rt_hw_serial_isr
• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_tx_nonblocking
• >>   _serial_fifo_rx
• >>   rt_serial_control
• >>   rt_sem_release
• >>   rt_timer_start
• >>   rt_timer_control
• >>   rt_completion_wait_flags
• >>   rt_completion_wakeup_by_errno
• >>   rt_object_detach
• >>   rt_object_init
• >>   rt_sem_control
• >>   rt_object_allocate
• >>   _rt_sem_take
• >>   rt_object_delete
• >>   rt_thread_defunct_dequeue
• >>   rt_thread_defunct_enqueue
• >>   list_device
• >>   list_timer
• >>   list_msgqueue
• >>   list_mailbox
• >>   list_mutex
• >>   list_event
• >>   list_sem
• >>   list_get_next
• >>   list_thread
• >>   _timer_check
• >>   rt_timer_detach
• >>   _thread_detach_from_mutex
• >>   rt_timer_stop
• >>   rt_object_for_each

rt_strcmp (Thumb, 20 bytes, Stack size 0 bytes, kstring.o(.text.rt_strcmp))

[Calls]

• >>   rt_strcmp

• >>   rt_strcmp
• >>   _pin_cmd
• >>   _match_name

rt_strerror (Thumb, 40 bytes, Stack size 16 bytes, kerrno.o(.text.rt_strerror))

[Stack]

• Max Depth = 16
• Call Chain = rt_strerror

• >>   list_thread

rt_strlen (Thumb, 14 bytes, Stack size 0 bytes, kstring.o(.text.rt_strlen))

[Called By]

• >>   ra_pin_get
• >>   rt_object_init
• >>   rt_object_allocate
• >>   finsh_get_prompt

rt_strncpy (Thumb, 38 bytes, Stack size 8 bytes, kstring.o(.text.rt_strncpy))

[Stack]

• Max Depth = 8
• Call Chain = rt_strncpy

• >>   msh_auto_complete
• >>   _match_name

rt_susp_list_dequeue (Thumb, 64 bytes, Stack size 24 bytes, ipc.o(.text.rt_susp_list_dequeue))

[Stack]

• Max Depth = 400
• Call Chain = rt_susp_list_dequeue ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler
• >>   rt_sched_unlock
• >>   rt_sched_thread_ready
• >>   rt_sched_lock

• >>   rt_sem_release
• >>   rt_susp_list_resume_all

rt_susp_list_enqueue (Thumb, 88 bytes, Stack size 24 bytes, ipc.o(.text.rt_susp_list_enqueue))

[Stack]

• Max Depth = 288
• Call Chain = rt_susp_list_enqueue ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler
• >>   rt_sched_thread_get_curr_prio

• >>   rt_thread_suspend_to_list
• >>   _thread_update_priority

rt_susp_list_print (Thumb, 56 bytes, Stack size 24 bytes, ipc.o(.text.rt_susp_list_print))

[Stack]

• Max Depth = 224
• Call Chain = rt_susp_list_print ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf
• >>   rt_sched_unlock
• >>   rt_sched_lock

• >>   list_msgqueue
• >>   list_mailbox
• >>   list_mutex
• >>   list_event
• >>   list_sem

rt_susp_list_resume_all (Thumb, 22 bytes, Stack size 16 bytes, ipc.o(.text.rt_susp_list_resume_all))

[Stack]

• Max Depth = 416
• Call Chain = rt_susp_list_resume_all ⇒ rt_susp_list_dequeue ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_susp_list_dequeue

• >>   rt_sem_control

rt_system_heap_init (Thumb, 4 bytes, Stack size 0 bytes, kservice.o(.text.rt_system_heap_init))

[Stack]

• Max Depth = 416
• Call Chain = rt_system_heap_init ⇒ rt_system_heap_init_generic ⇒ rt_smem_init ⇒ rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_system_heap_init_generic

• >>   rt_hw_board_init

rt_system_heap_init_generic (Thumb, 64 bytes, Stack size 16 bytes, kservice.o(.text.rt_system_heap_init_generic))

[Stack]

• Max Depth = 416
• Call Chain = rt_system_heap_init_generic ⇒ rt_smem_init ⇒ rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_mutex_init
• >>   rt_assert_handler
• >>   rt_smem_init

• >>   rt_system_heap_init

rt_system_scheduler_init (Thumb, 28 bytes, Stack size 0 bytes, scheduler_up.o(.text.rt_system_scheduler_init))

[Called By]

• >>   rtthread_startup

rt_system_scheduler_start (Thumb, 48 bytes, Stack size 16 bytes, scheduler_up.o(.text.rt_system_scheduler_start))

[Stack]

• Max Depth = 288
• Call Chain = rt_system_scheduler_start ⇒ rt_sched_remove_thread ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_cpu_self
• >>   rt_hw_context_switch_to
• >>   _scheduler_get_highest_priority_thread
• >>   rt_sched_remove_thread

• >>   rtthread_startup

rt_system_timer_init (Thumb, 16 bytes, Stack size 0 bytes, timer.o(.text.rt_system_timer_init))

[Calls]

• >>   rt_spin_lock_init

• >>   rtthread_startup

rt_system_timer_thread_init (Thumb, 96 bytes, Stack size 32 bytes, timer.o(.text.rt_system_timer_thread_init))

[Stack]

• Max Depth = 528
• Call Chain = rt_system_timer_thread_init ⇒ rt_thread_init ⇒ _thread_init ⇒ rt_timer_init ⇒ rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_startup
• >>   rt_sem_init
• >>   rt_spin_lock_init
• >>   rt_sem_control
• >>   rt_thread_init

• >>   rtthread_startup

rt_thread_close (Thumb, 80 bytes, Stack size 16 bytes, thread.o(.text.rt_thread_close))

[Stack]

• Max Depth = 384
• Call Chain = rt_thread_close ⇒ rt_timer_detach ⇒ rt_object_detach ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_critical_level
• >>   rt_assert_handler
• >>   rt_thread_self
• >>   rt_sched_unlock
• >>   rt_sched_lock
• >>   rt_timer_detach
• >>   rt_sched_remove_thread
• >>   rt_sched_thread_close
• >>   rt_sched_thread_get_stat

• >>   _thread_detach
• >>   _thread_exit

rt_thread_control (Thumb, 180 bytes, Stack size 32 bytes, thread.o(.text.rt_thread_control))

[Stack]

• Max Depth = 504
• Call Chain = rt_thread_control ⇒ rt_thread_delete ⇒ _thread_detach ⇒ _thread_detach_from_mutex ⇒ rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_delete
• >>   rt_thread_startup
• >>   rt_schedule
• >>   rt_object_is_systemobject
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_sched_thread_change_priority
• >>   rt_sched_unlock
• >>   rt_sched_lock
• >>   rt_thread_detach
• >>   rt_sched_thread_bind_cpu
• >>   rt_sched_thread_reset_priority

• >>   __rt_libc_exit

rt_thread_create (Thumb, 84 bytes, Stack size 40 bytes, thread.o(.text.rt_thread_create))

[Stack]

• Max Depth = 544
• Call Chain = rt_thread_create ⇒ rt_object_allocate ⇒ rt_malloc ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler
• >>   rt_malloc
• >>   rt_object_allocate
• >>   rt_object_delete
• >>   _thread_init

• >>   rt_application_init
• >>   finsh_system_init

rt_thread_defunct_dequeue (Thumb, 48 bytes, Stack size 8 bytes, defunct.o(.text.rt_thread_defunct_dequeue))

[Stack]

• Max Depth = 344
• Call Chain = rt_thread_defunct_dequeue ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave

• >>   rt_defunct_execute

rt_thread_defunct_enqueue (Thumb, 44 bytes, Stack size 16 bytes, defunct.o(.text.rt_thread_defunct_enqueue))

[Stack]

• Max Depth = 352
• Call Chain = rt_thread_defunct_enqueue ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave

• >>   _thread_detach
• >>   _thread_exit

rt_thread_defunct_init (Thumb, 8 bytes, Stack size 0 bytes, defunct.o(.text.rt_thread_defunct_init))

[Calls]

• >>   rt_spin_lock_init

• >>   rtthread_startup

rt_thread_delete (Thumb, 72 bytes, Stack size 16 bytes, thread.o(.text.rt_thread_delete))

[Stack]

• Max Depth = 472
• Call Chain = rt_thread_delete ⇒ _thread_detach ⇒ _thread_detach_from_mutex ⇒ rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_is_systemobject
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   _thread_detach

• >>   rt_thread_control

rt_thread_detach (Thumb, 72 bytes, Stack size 16 bytes, thread.o(.text.rt_thread_detach))

[Stack]

• Max Depth = 472
• Call Chain = rt_thread_detach ⇒ _thread_detach ⇒ _thread_detach_from_mutex ⇒ rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_is_systemobject
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   _thread_detach

• >>   rt_thread_control

rt_thread_idle_init (Thumb, 76 bytes, Stack size 40 bytes, idle.o(.text.rt_thread_idle_init))

[Stack]

• Max Depth = 536
• Call Chain = rt_thread_idle_init ⇒ rt_thread_init ⇒ _thread_init ⇒ rt_timer_init ⇒ rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_startup
• >>   rt_spin_lock_init
• >>   rt_snprintf
• >>   rt_thread_init
• >>   rt_cpu_index

• >>   rtthread_startup

rt_thread_init (Thumb, 116 bytes, Stack size 56 bytes, thread.o(.text.rt_thread_init))

[Stack]

• Max Depth = 496
• Call Chain = rt_thread_init ⇒ _thread_init ⇒ rt_timer_init ⇒ rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler
• >>   rt_object_init
• >>   rt_memset
• >>   _thread_init

• >>   rt_thread_idle_init
• >>   rt_system_timer_thread_init

rt_thread_mdelay (Thumb, 16 bytes, Stack size 8 bytes, thread.o(.text.rt_thread_mdelay))

[Stack]

• Max Depth = 440
• Call Chain = rt_thread_mdelay ⇒ _thread_sleep ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_tick_from_millisecond
• >>   _thread_sleep

• >>   hal_entry

rt_thread_resume (Thumb, 92 bytes, Stack size 24 bytes, thread.o(.text.rt_thread_resume))

[Stack]

• Max Depth = 400
• Call Chain = rt_thread_resume ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_sched_unlock_n_resched
• >>   rt_sched_unlock
• >>   rt_sched_thread_ready
• >>   rt_sched_lock

• >>   rt_thread_startup
• >>   rt_completion_wakeup_by_errno

rt_thread_self (Thumb, 10 bytes, Stack size 8 bytes, thread.o(.text.rt_thread_self))

[Stack]

• Max Depth = 8
• Call Chain = rt_thread_self

• >>   rt_cpu_self

• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_tx_blocking_nbuf
• >>   rt_thread_suspend_to_list
• >>   rt_mutex_release
• >>   rt_schedule
• >>   rt_completion_wait_flags
• >>   rt_set_errno
• >>   __rt_libc_exit
• >>   _heap_unlock
• >>   _heap_lock
• >>   cmd_backtrace
• >>   rt_mutex_drop_thread
• >>   rt_sched_unlock_n_resched
• >>   _rt_mutex_take
• >>   _rt_sem_take
• >>   rt_sched_tick_increase
• >>   rt_hw_hard_fault_exception
• >>   rt_thread_close
• >>   _thread_sleep
• >>   _thread_exit
• >>   rt_sched_insert_thread
• >>   rt_backtrace

rt_thread_startup (Thumb, 76 bytes, Stack size 16 bytes, thread.o(.text.rt_thread_startup))

[Stack]

• Max Depth = 416
• Call Chain = rt_thread_startup ⇒ rt_thread_resume ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_resume
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_sched_thread_startup

• >>   rt_thread_control
• >>   rt_thread_idle_init
• >>   rt_system_timer_thread_init
• >>   rt_application_init
• >>   finsh_system_init

rt_thread_suspend_to_list (Thumb, 216 bytes, Stack size 32 bytes, thread.o(.text.rt_thread_suspend_to_list))

[Stack]

• Max Depth = 400
• Call Chain = rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_thread_self
• >>   rt_susp_list_enqueue
• >>   rt_sched_unlock
• >>   rt_sched_lock
• >>   rt_sched_remove_thread
• >>   rt_sched_thread_get_stat
• >>   rt_sched_thread_timer_stop

• >>   rt_thread_suspend_with_flag
• >>   _rt_mutex_take
• >>   _rt_sem_take

rt_thread_suspend_with_flag (Thumb, 10 bytes, Stack size 0 bytes, thread.o(.text.rt_thread_suspend_with_flag))

[Stack]

• Max Depth = 400
• Call Chain = rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_suspend_to_list

• >>   rt_completion_wait_flags
• >>   _thread_sleep

rt_tick_from_millisecond (Thumb, 6 bytes, Stack size 0 bytes, clock.o(.text.rt_tick_from_millisecond))

[Called By]

• >>   rt_thread_mdelay

rt_tick_get (Thumb, 8 bytes, Stack size 0 bytes, clock.o(.text.rt_tick_get))

[Calls]

• >>   rt_hw_atomic_load

• >>   rt_tick_get_delta
• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_rx
• >>   rt_timer_check
• >>   list_timer
• >>   _timer_check
• >>   _timer_start

rt_tick_get_delta (Thumb, 12 bytes, Stack size 8 bytes, clock.o(.text.rt_tick_get_delta))

[Stack]

• Max Depth = 8
• Call Chain = rt_tick_get_delta

• >>   rt_tick_get

• >>   _serial_fifo_tx_blocking_buf
• >>   _serial_fifo_rx

rt_tick_increase (Thumb, 52 bytes, Stack size 8 bytes, clock.o(.text.rt_tick_increase))

[Stack]

• Max Depth = 448
• Call Chain = rt_tick_increase ⇒ rt_timer_check ⇒ rt_sem_release ⇒ rt_susp_list_dequeue ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_hw_atomic_add
• >>   rt_interrupt_get_nest
• >>   rt_assert_handler
• >>   rt_timer_check
• >>   rt_sched_tick_increase

• >>   SysTick_Handler

rt_timer_check (Thumb, 68 bytes, Stack size 16 bytes, timer.o(.text.rt_timer_check))

[Stack]

• Max Depth = 440
• Call Chain = rt_timer_check ⇒ rt_sem_release ⇒ rt_susp_list_dequeue ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_sem_release
• >>   rt_interrupt_get_nest
• >>   rt_assert_handler
• >>   rt_tick_get
• >>   _timer_check

• >>   rt_tick_increase

rt_timer_control (Thumb, 248 bytes, Stack size 24 bytes, timer.o(.text.rt_timer_control))

[Stack]

• Max Depth = 360
• Call Chain = rt_timer_control ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_object_get_type
• >>   rt_assert_handler

• >>   rt_completion_wait_flags
• >>   _rt_mutex_take
• >>   _rt_sem_take
• >>   _thread_sleep

rt_timer_detach (Thumb, 124 bytes, Stack size 16 bytes, timer.o(.text.rt_timer_detach))

[Stack]

• Max Depth = 368
• Call Chain = rt_timer_detach ⇒ rt_object_detach ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_object_detach
• >>   rt_object_is_systemobject
• >>   rt_object_get_type
• >>   rt_assert_handler

• >>   rt_thread_close

rt_timer_init (Thumb, 108 bytes, Stack size 32 bytes, timer.o(.text.rt_timer_init))

[Stack]

• Max Depth = 408
• Call Chain = rt_timer_init ⇒ rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler
• >>   rt_object_init

• >>   _thread_init

rt_timer_start (Thumb, 172 bytes, Stack size 24 bytes, timer.o(.text.rt_timer_start))

[Stack]

• Max Depth = 360
• Call Chain = rt_timer_start ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_sched_unlock
• >>   rt_sched_lock
• >>   _timer_start
• >>   rt_sched_thread_timer_start

• >>   rt_completion_wait_flags
• >>   _rt_mutex_take
• >>   _rt_sem_take
• >>   _thread_sleep

rt_timer_stop (Thumb, 124 bytes, Stack size 24 bytes, timer.o(.text.rt_timer_stop))

[Stack]

• Max Depth = 360
• Call Chain = rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_object_get_type
• >>   rt_assert_handler

• >>   rt_sched_thread_timer_stop

rt_vsnprintf (Thumb, 856 bytes, Stack size 80 bytes, rt_vsnprintf_tiny.o(.text.rt_vsnprintf))

[Stack]

• Max Depth = 168
• Call Chain = rt_vsnprintf ⇒ print_number

• >>   print_number
• >>   skip_atoi

• >>   rt_snprintf
• >>   rt_kprintf

rtthread_startup (Thumb, 46 bytes, Stack size 8 bytes, components.o(.text.rtthread_startup))

[Stack]

• Max Depth = 568
• Call Chain = rtthread_startup ⇒ rt_application_init ⇒ rt_thread_create ⇒ rt_object_allocate ⇒ rt_malloc ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_system_scheduler_start
• >>   rt_thread_defunct_init
• >>   rt_thread_idle_init
• >>   rt_system_timer_thread_init
• >>   rt_application_init
• >>   rt_system_scheduler_init
• >>   rt_system_timer_init
• >>   rt_hw_interrupt_disable
• >>   rt_show_version
• >>   rt_hw_board_init

• >>   main

sci_uart_eri_isr (Thumb, 84 bytes, Stack size 16 bytes, r_sci_uart.o(.text.sci_uart_eri_isr))

[Stack]

• Max Depth = 64
• Call Chain = sci_uart_eri_isr ⇒ r_sci_uart_call_callback

• >>   r_sci_uart_call_callback
• >>   R_BSP_IrqStatusClear

• vector_data.o(.application_vectors)

sci_uart_rxi_isr (Thumb, 108 bytes, Stack size 24 bytes, r_sci_uart.o(.text.sci_uart_rxi_isr))

[Stack]

• Max Depth = 72
• Call Chain = sci_uart_rxi_isr ⇒ r_sci_uart_call_callback

• >>   r_sci_uart_call_callback
• >>   R_BSP_IrqStatusClear
• >>   __aeabi_memcpy

• vector_data.o(.application_vectors)

sci_uart_tei_isr (Thumb, 52 bytes, Stack size 8 bytes, r_sci_uart.o(.text.sci_uart_tei_isr))

[Stack]

• Max Depth = 56
• Call Chain = sci_uart_tei_isr ⇒ r_sci_uart_call_callback

• >>   r_sci_uart_call_callback
• >>   R_BSP_IrqStatusClear

• vector_data.o(.application_vectors)

sci_uart_txi_isr (Thumb, 120 bytes, Stack size 8 bytes, r_sci_uart.o(.text.sci_uart_txi_isr))

[Stack]

• Max Depth = 56
• Call Chain = sci_uart_txi_isr ⇒ r_sci_uart_call_callback

• >>   r_sci_uart_call_callback
• >>   R_BSP_IrqStatusClear

• vector_data.o(.application_vectors)

user_uart0_callback (Thumb, 44 bytes, Stack size 16 bytes, drv_usart_v2.o(.text.user_uart0_callback))

[Stack]

• Max Depth = 488
• Call Chain = user_uart0_callback ⇒ rt_hw_serial_isr ⇒ rt_completion_done ⇒ rt_completion_wakeup_by_errno ⇒ rt_thread_resume ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_hw_serial_isr
• >>   rt_hw_serial_control_isr
• >>   rt_interrupt_leave
• >>   rt_interrupt_enter

• hal_data.o(.rodata.g_uart0_cfg)

_get_lc_ctype (Thumb, 44 bytes, Stack size 8 bytes, lc_ctype_c.o(locale$$code))

[Stack]

• Max Depth = 24
• Call Chain = _get_lc_ctype ⇒ strcmp

• >>   strcmp

• >>   __rt_lib_init_lc_ctype_2

• rt_ctype_table.o(.text)

Local Symbols

_pin_control (Thumb, 44 bytes, Stack size 16 bytes, dev_pin.o(.text._pin_control))

[Stack]

• Max Depth = 280
• Call Chain = _pin_control ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• dev_pin.o(.text.rt_device_pin_register)

_pin_write (Thumb, 44 bytes, Stack size 16 bytes, dev_pin.o(.text._pin_write))

[Stack]

• Max Depth = 280
• Call Chain = _pin_write ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• dev_pin.o(.text.rt_device_pin_register)

_pin_read (Thumb, 44 bytes, Stack size 16 bytes, dev_pin.o(.text._pin_read))

[Stack]

• Max Depth = 280
• Call Chain = _pin_read ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• dev_pin.o(.text.rt_device_pin_register)

_pin_cmd (Thumb, 376 bytes, Stack size 16 bytes, dev_pin.o(.text._pin_cmd))

[Stack]

• Max Depth = 304
• Call Chain = _pin_cmd ⇒ _pin_cmd_print_usage ⇒ rt_pin_get ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   msh_isint
• >>   rt_strcmp
• >>   rt_pin_get
• >>   rt_pin_read
• >>   rt_pin_mode
• >>   _pin_cmd_print_usage
• >>   rt_pin_write
• >>   rt_kprintf
• >>   atoi

• dev_pin.o(FSymTab)

_pin_cmd_print_usage (Thumb, 56 bytes, Stack size 8 bytes, dev_pin.o(.text._pin_cmd_print_usage))

[Stack]

• Max Depth = 288
• Call Chain = _pin_cmd_print_usage ⇒ rt_pin_get ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_pin_get

• >>   _pin_cmd

rt_serial_control (Thumb, 816 bytes, Stack size 24 bytes, dev_serial_v2.o(.text.rt_serial_control))

[Stack]

• Max Depth = 472
• Call Chain = rt_serial_control ⇒ rt_completion_wait ⇒ rt_completion_wait_flags ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_serial_update_read_index
• >>   rt_ringbuffer_reset
• >>   rt_ringbuffer_data_len
• >>   rt_hw_atomic_load
• >>   rt_hw_atomic_store
• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_completion_wait
• >>   rt_assert_handler
• >>   rt_memcpy

• dev_serial_v2.o(.text.rt_hw_serial_register)

rt_serial_close (Thumb, 188 bytes, Stack size 24 bytes, dev_serial_v2.o(.text.rt_serial_close))

[Stack]

• Max Depth = 496
• Call Chain = rt_serial_close ⇒ rt_free ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_completion_done
• >>   rt_assert_handler
• >>   rt_memset
• >>   rt_free

• >>   rt_serial_open

• dev_serial_v2.o(.text.rt_hw_serial_register)

rt_serial_open (Thumb, 768 bytes, Stack size 40 bytes, dev_serial_v2.o(.text.rt_serial_open))

[Stack]

• Max Depth = 536
• Call Chain = rt_serial_open ⇒ rt_serial_close ⇒ rt_free ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_hw_atomic_flag_clear
• >>   rt_serial_close
• >>   rt_ringbuffer_init
• >>   rt_hw_atomic_store
• >>   rt_completion_init
• >>   rt_assert_handler
• >>   rt_memset
• >>   rt_malloc

• dev_serial_v2.o(.text.rt_hw_serial_register)

rt_serial_init (Thumb, 64 bytes, Stack size 8 bytes, dev_serial_v2.o(.text.rt_serial_init))

[Stack]

• Max Depth = 272
• Call Chain = rt_serial_init ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• dev_serial_v2.o(.text.rt_hw_serial_register)

_serial_fifo_rx (Thumb, 328 bytes, Stack size 56 bytes, dev_serial_v2.o(.text._serial_fifo_rx))

[Stack]

• Max Depth = 504
• Call Chain = _serial_fifo_rx ⇒ rt_completion_wait ⇒ rt_completion_wait_flags ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_tick_get_delta
• >>   rt_ringbuffer_data_len
• >>   rt_ringbuffer_get
• >>   rt_hw_atomic_load
• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_completion_wait
• >>   rt_assert_handler
• >>   rt_tick_get

• dev_serial_v2.o(.text.rt_serial_open)

_serial_fifo_tx_nonblocking (Thumb, 160 bytes, Stack size 40 bytes, dev_serial_v2.o(.text._serial_fifo_tx_nonblocking))

[Stack]

• Max Depth = 488
• Call Chain = _serial_fifo_tx_nonblocking ⇒ rt_completion_wait ⇒ rt_completion_wait_flags ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_hw_atomic_flag_test_and_set
• >>   rt_serial_get_linear_buffer
• >>   rt_ringbuffer_put
• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_completion_wait
• >>   rt_assert_handler

• dev_serial_v2.o(.text.rt_serial_open)

_serial_fifo_tx_blocking_nbuf (Thumb, 176 bytes, Stack size 32 bytes, dev_serial_v2.o(.text._serial_fifo_tx_blocking_nbuf))

[Stack]

• Max Depth = 480
• Call Chain = _serial_fifo_tx_blocking_nbuf ⇒ rt_completion_wait ⇒ rt_completion_wait_flags ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_hw_atomic_flag_test_and_set
• >>   _serial_poll_tx
• >>   rt_hw_atomic_load
• >>   rt_completion_wait
• >>   rt_assert_handler
• >>   rt_thread_self

• dev_serial_v2.o(.text.rt_serial_open)

_serial_fifo_tx_blocking_buf (Thumb, 316 bytes, Stack size 64 bytes, dev_serial_v2.o(.text._serial_fifo_tx_blocking_buf))

[Stack]

• Max Depth = 512
• Call Chain = _serial_fifo_tx_blocking_buf ⇒ rt_completion_wait ⇒ rt_completion_wait_flags ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_tick_get_delta
• >>   rt_hw_atomic_flag_test_and_set
• >>   _serial_poll_tx
• >>   rt_ringbuffer_data_len
• >>   rt_ringbuffer_put
• >>   rt_hw_atomic_load
• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_completion_wait
• >>   rt_assert_handler
• >>   rt_tick_get
• >>   rt_thread_self

• dev_serial_v2.o(.text.rt_serial_open)

rt_serial_update_read_index (Thumb, 80 bytes, Stack size 16 bytes, dev_serial_v2.o(.text.rt_serial_update_read_index))

[Stack]

• Max Depth = 280
• Call Chain = rt_serial_update_read_index ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_ringbuffer_data_len
• >>   rt_assert_handler

• >>   rt_hw_serial_isr
• >>   rt_serial_control

rt_serial_get_linear_buffer (Thumb, 60 bytes, Stack size 16 bytes, dev_serial_v2.o(.text.rt_serial_get_linear_buffer))

[Stack]

• Max Depth = 280
• Call Chain = rt_serial_get_linear_buffer ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_ringbuffer_data_len
• >>   rt_assert_handler

• >>   rt_hw_serial_isr
• >>   _serial_fifo_tx_nonblocking

ra_pin_mode (Thumb, 100 bytes, Stack size 16 bytes, drv_gpio.o(.text.ra_pin_mode))

[Stack]

• Max Depth = 60
• Call Chain = ra_pin_mode ⇒ R_IOPORT_Open ⇒ r_ioport_pins_config ⇒ r_ioport_pfs_write

• >>   R_IOPORT_PinCfg
• >>   R_IOPORT_Open

• drv_gpio.o(.rodata._ra_pin_ops)

ra_pin_write (Thumb, 108 bytes, Stack size 16 bytes, drv_gpio.o(.text.ra_pin_write))

[Stack]

• Max Depth = 16
• Call Chain = ra_pin_write

• drv_gpio.o(.rodata._ra_pin_ops)

ra_pin_read (Thumb, 36 bytes, Stack size 0 bytes, drv_gpio.o(.text.ra_pin_read))
[Address Reference Count : 1]

• drv_gpio.o(.rodata._ra_pin_ops)

ra_pin_attach_irq (Thumb, 6 bytes, Stack size 0 bytes, drv_gpio.o(.text.ra_pin_attach_irq))
[Address Reference Count : 1]

• drv_gpio.o(.rodata._ra_pin_ops)

ra_pin_dettach_irq (Thumb, 6 bytes, Stack size 0 bytes, drv_gpio.o(.text.ra_pin_dettach_irq))
[Address Reference Count : 1]

• drv_gpio.o(.rodata._ra_pin_ops)

ra_pin_irq_enable (Thumb, 6 bytes, Stack size 0 bytes, drv_gpio.o(.text.ra_pin_irq_enable))
[Address Reference Count : 1]

• drv_gpio.o(.rodata._ra_pin_ops)

ra_pin_get (Thumb, 84 bytes, Stack size 8 bytes, drv_gpio.o(.text.ra_pin_get))

[Stack]

• Max Depth = 8
• Call Chain = ra_pin_get

• >>   rt_strlen

• drv_gpio.o(.rodata._ra_pin_ops)

ra_uart_configure (Thumb, 60 bytes, Stack size 16 bytes, drv_usart_v2.o(.text.ra_uart_configure))

[Stack]

• Max Depth = 280
• Call Chain = ra_uart_configure ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler
• >>   R_SCI_UART_Open

• drv_usart_v2.o(.rodata.ra_uart_ops)

ra_uart_control (Thumb, 4 bytes, Stack size 0 bytes, drv_usart_v2.o(.text.ra_uart_control))
[Address Reference Count : 1]

• drv_usart_v2.o(.rodata.ra_uart_ops)

ra_uart_putc (Thumb, 52 bytes, Stack size 16 bytes, drv_usart_v2.o(.text.ra_uart_putc))

[Stack]

• Max Depth = 280
• Call Chain = ra_uart_putc ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• drv_usart_v2.o(.rodata.ra_uart_ops)

ra_uart_getc (Thumb, 4 bytes, Stack size 0 bytes, drv_usart_v2.o(.text.ra_uart_getc))
[Address Reference Count : 1]

• drv_usart_v2.o(.rodata.ra_uart_ops)

ra_uart_transmit (Thumb, 56 bytes, Stack size 24 bytes, drv_usart_v2.o(.text.ra_uart_transmit))

[Stack]

• Max Depth = 288
• Call Chain = ra_uart_transmit ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• drv_usart_v2.o(.rodata.ra_uart_ops)

reboot (Thumb, 4 bytes, Stack size 0 bytes, drv_common.o(.text.reboot))

[Calls]

• >>   __NVIC_SystemReset

• drv_common.o(FSymTab)

__NVIC_SystemReset (Thumb, 20 bytes, Stack size 0 bytes, drv_common.o(.text.__NVIC_SystemReset))

[Called By]

• >>   reboot

finsh_rx_ind (Thumb, 28 bytes, Stack size 8 bytes, shell.o(.text.finsh_rx_ind))

[Stack]

• Max Depth = 432
• Call Chain = finsh_rx_ind ⇒ rt_sem_release ⇒ rt_susp_list_dequeue ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_sem_release
• >>   rt_assert_handler

• shell.o(.text.finsh_set_device)

finsh_thread_entry (Thumb, 1032 bytes, Stack size 32 bytes, shell.o(.text.finsh_thread_entry))

[Stack]

• Max Depth = 496
• Call Chain = finsh_thread_entry ⇒ finsh_getchar ⇒ rt_sem_take ⇒ _rt_sem_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_memcpy
• >>   rt_memset
• >>   msh_exec
• >>   rt_console_get_device
• >>   rt_kprintf
• >>   msh_opt_auto_complete
• >>   msh_auto_complete
• >>   rt_memmove
• >>   finsh_set_device
• >>   finsh_getchar
• >>   finsh_get_prompt
• >>   shell_handle_history
• >>   strlen
• >>   memcmp

• shell.o(.text.finsh_system_init)

shell_handle_history (Thumb, 36 bytes, Stack size 8 bytes, shell.o(.text.shell_handle_history))

[Stack]

• Max Depth = 208
• Call Chain = shell_handle_history ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf
• >>   finsh_get_prompt

• >>   finsh_thread_entry

msh_help (Thumb, 48 bytes, Stack size 16 bytes, msh.o(.text.msh_help))

[Stack]

• Max Depth = 216
• Call Chain = msh_help ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf

• >>   msh_auto_complete

• msh.o(FSymTab)

cmd_ps (Thumb, 10 bytes, Stack size 8 bytes, msh.o(.text.cmd_ps))

[Stack]

• Max Depth = 496
• Call Chain = cmd_ps ⇒ list_thread ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   list_thread

• msh.o(FSymTab)

cmd_free (Thumb, 56 bytes, Stack size 32 bytes, msh.o(.text.cmd_free))

[Stack]

• Max Depth = 504
• Call Chain = cmd_free ⇒ rt_memory_info ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_memory_info

• msh.o(FSymTab)

msh_get_cmd (Thumb, 52 bytes, Stack size 32 bytes, msh.o(.text.msh_get_cmd))

[Stack]

• Max Depth = 52
• Call Chain = msh_get_cmd ⇒ strncmp

• >>   strncmp

• >>   msh_exec
• >>   msh_opt_auto_complete

str_common (Thumb, 22 bytes, Stack size 8 bytes, msh.o(.text.str_common))

[Stack]

• Max Depth = 8
• Call Chain = str_common

• >>   msh_opt_auto_complete
• >>   msh_auto_complete

msh_get_cmd_opt (Thumb, 72 bytes, Stack size 32 bytes, msh.o(.text.msh_get_cmd_opt))

[Stack]

• Max Depth = 52
• Call Chain = msh_get_cmd_opt ⇒ strncmp

• >>   strncmp
• >>   strlen
• >>   strchr

• >>   msh_opt_auto_complete

clear (Thumb, 12 bytes, Stack size 8 bytes, cmd.o(.text.clear))

[Stack]

• Max Depth = 208
• Call Chain = clear ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf

• cmd.o(FSymTab)

version (Thumb, 10 bytes, Stack size 8 bytes, cmd.o(.text.version))

[Stack]

• Max Depth = 24
• Call Chain = version ⇒ rt_show_version

• >>   rt_show_version

• cmd.o(FSymTab)

list_get_next (Thumb, 104 bytes, Stack size 32 bytes, cmd.o(.text.list_get_next))

[Stack]

• Max Depth = 368
• Call Chain = list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave

• >>   list_device
• >>   list_timer
• >>   list_msgqueue
• >>   list_mailbox
• >>   list_mutex
• >>   list_event
• >>   list_sem
• >>   list_thread

object_split (Thumb, 20 bytes, Stack size 16 bytes, cmd.o(.text.object_split))

[Stack]

• Max Depth = 216
• Call Chain = object_split ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf

• >>   list_device
• >>   list_timer
• >>   list_msgqueue
• >>   list_mailbox
• >>   list_mutex
• >>   list_event
• >>   list_sem

• cmd.o(.text.list_thread)

rt_list_len (Thumb, 18 bytes, Stack size 0 bytes, cmd.o(.text.rt_list_len))

[Called By]

• >>   list_msgqueue
• >>   list_mailbox
• >>   list_mutex
• >>   list_event
• >>   list_sem

cmd_list (Thumb, 140 bytes, Stack size 8 bytes, cmd.o(.text.cmd_list))

[Stack]

• Max Depth = 512
• Call Chain = cmd_list ⇒ list_mutex ⇒ list_get_next ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_kprintf
• >>   list_device
• >>   list_timer
• >>   list_msgqueue
• >>   list_mailbox
• >>   list_mutex
• >>   list_event
• >>   list_sem
• >>   msh_opt_list_dump
• >>   msh_cmd_opt_id_get
• >>   list_thread

• cmd.o(FSymTab)

rti_start (Thumb, 4 bytes, Stack size 0 bytes, components.o(.text.rti_start))
[Address Reference Count : 1]

• components.o(.rti_fn.0)

rti_board_start (Thumb, 4 bytes, Stack size 0 bytes, components.o(.text.rti_board_start))
[Address Reference Count : 1]

• components.o(.rti_fn.0.end)

rti_board_end (Thumb, 4 bytes, Stack size 0 bytes, components.o(.text.rti_board_end))
[Address Reference Count : 1]

• components.o(.rti_fn.1.end)

rti_end (Thumb, 4 bytes, Stack size 0 bytes, components.o(.text.rti_end))
[Address Reference Count : 1]

• components.o(.rti_fn.6.end)

main_thread_entry (Thumb, 16 bytes, Stack size 8 bytes, components.o(.text.main_thread_entry))

[Stack]

• Max Depth = 456
• Call Chain = main_thread_entry ⇒ $Super$$main ⇒ hal_entry ⇒ rt_thread_mdelay ⇒ _thread_sleep ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   $Super$$main
• >>   rt_components_init

• components.o(.text.rt_application_init)

idle_thread_entry (Thumb, 32 bytes, Stack size 0 bytes, idle.o(.text.idle_thread_entry))

[Stack]

• Max Depth = 504
• Call Chain = idle_thread_entry ⇒ rt_defunct_execute ⇒ rt_object_delete ⇒ rt_free ⇒ _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_defunct_execute

• idle.o(.text.rt_thread_idle_init)

_sem_object_init (Thumb, 24 bytes, Stack size 0 bytes, ipc.o(.text._sem_object_init))

[Calls]

• >>   rt_spin_lock_init

• >>   rt_sem_init

_rt_sem_take (Thumb, 288 bytes, Stack size 40 bytes, ipc.o(.text._rt_sem_take))

[Stack]

• Max Depth = 440
• Call Chain = _rt_sem_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_suspend_to_list
• >>   rt_schedule
• >>   rt_spin_unlock_irqrestore
• >>   rt_timer_start
• >>   rt_timer_control
• >>   rt_spin_lock_irqsave
• >>   rt_interrupt_get_nest
• >>   rt_critical_level
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_thread_self
• >>   rt_kprintf

• >>   rt_sem_take

_check_and_update_prio (Thumb, 46 bytes, Stack size 16 bytes, ipc.o(.text._check_and_update_prio))

[Stack]

• Max Depth = 328
• Call Chain = _check_and_update_prio ⇒ rt_sched_thread_change_priority ⇒ _rt_sched_update_priority ⇒ rt_sched_insert_thread ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_sched_thread_change_priority
• >>   rt_sched_thread_get_curr_prio
• >>   _thread_get_mutex_priority

• >>   rt_mutex_release

_thread_get_mutex_priority (Thumb, 48 bytes, Stack size 8 bytes, ipc.o(.text._thread_get_mutex_priority))

[Stack]

• Max Depth = 8
• Call Chain = _thread_get_mutex_priority

• >>   rt_sched_thread_get_init_prio

• >>   rt_mutex_drop_thread
• >>   _rt_mutex_take
• >>   _thread_update_priority
• >>   _check_and_update_prio

_thread_update_priority (Thumb, 140 bytes, Stack size 32 bytes, ipc.o(.text._thread_update_priority))

[Stack]

• Max Depth = 344
• Call Chain = _thread_update_priority ⇒ rt_sched_thread_change_priority ⇒ _rt_sched_update_priority ⇒ rt_sched_insert_thread ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_get_type
• >>   rt_sched_thread_is_suspended
• >>   rt_sched_thread_change_priority
• >>   rt_sched_thread_get_curr_prio
• >>   rt_susp_list_enqueue
• >>   _thread_get_mutex_priority

• >>   rt_mutex_drop_thread
• >>   _rt_mutex_take

_rt_mutex_take (Thumb, 568 bytes, Stack size 48 bytes, ipc.o(.text._rt_mutex_take))

[Stack]

• Max Depth = 448
• Call Chain = _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_thread_suspend_to_list
• >>   rt_spin_unlock
• >>   rt_spin_lock
• >>   rt_schedule
• >>   rt_timer_start
• >>   rt_timer_control
• >>   rt_interrupt_get_nest
• >>   rt_critical_level
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_thread_self
• >>   rt_kprintf
• >>   rt_sched_thread_get_curr_prio
• >>   rt_sched_unlock
• >>   rt_sched_lock
• >>   _thread_update_priority
• >>   _thread_get_mutex_priority

• >>   rt_mutex_take

_kputs (Thumb, 24 bytes, Stack size 0 bytes, kservice.o(.text._kputs))

[Stack]

• Max Depth = 48
• Call Chain = _kputs ⇒ rt_device_write ⇒ rt_assert_handler (Cycle)

• >>   rt_device_write
• >>   rt_hw_console_output

• >>   rt_kprintf

cmd_backtrace (Thumb, 120 bytes, Stack size 24 bytes, kservice.o(.text.cmd_backtrace))

[Stack]

• Max Depth = 272
• Call Chain = cmd_backtrace ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_get_type
• >>   rt_thread_self
• >>   rt_kprintf
• >>   rt_backtrace_thread
• >>   rt_backtrace
• >>   strtoul

• kservice.o(FSymTab)

_heap_lock (Thumb, 32 bytes, Stack size 8 bytes, kservice.o(.text._heap_lock))

[Stack]

• Max Depth = 456
• Call Chain = _heap_lock ⇒ rt_mutex_take ⇒ _rt_mutex_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_mutex_take
• >>   rt_thread_self

• >>   rt_free
• >>   rt_malloc
• >>   rt_memory_info

_heap_unlock (Thumb, 36 bytes, Stack size 8 bytes, kservice.o(.text._heap_unlock))

[Stack]

• Max Depth = 424
• Call Chain = _heap_unlock ⇒ rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_mutex_release
• >>   rt_assert_handler
• >>   rt_thread_self

• >>   rt_free
• >>   rt_malloc
• >>   rt_memory_info

plug_holes (Thumb, 120 bytes, Stack size 16 bytes, mem.o(.text.plug_holes))

[Stack]

• Max Depth = 280
• Call Chain = plug_holes ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler

• >>   rt_smem_free

_match_name (Thumb, 40 bytes, Stack size 32 bytes, object.o(.text._match_name))

[Stack]

• Max Depth = 40
• Call Chain = _match_name ⇒ rt_strncpy

• >>   rt_strcmp
• >>   rt_strncpy

• object.o(.text.rt_object_find)

_rt_sched_update_priority (Thumb, 88 bytes, Stack size 24 bytes, scheduler_comm.o(.text._rt_sched_update_priority))

[Stack]

• Max Depth = 304
• Call Chain = _rt_sched_update_priority ⇒ rt_sched_insert_thread ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_assert_handler
• >>   rt_sched_remove_thread
• >>   rt_sched_insert_thread

• >>   rt_sched_thread_change_priority
• >>   rt_sched_thread_reset_priority

_scheduler_get_highest_priority_thread (Thumb, 28 bytes, Stack size 8 bytes, scheduler_up.o(.text._scheduler_get_highest_priority_thread))

[Stack]

• Max Depth = 8
• Call Chain = _scheduler_get_highest_priority_thread

• >>   __rt_ffs

• >>   rt_schedule
• >>   rt_system_scheduler_start

_thread_init (Thumb, 116 bytes, Stack size 32 bytes, thread.o(.text._thread_init))

[Stack]

• Max Depth = 440
• Call Chain = _thread_init ⇒ rt_timer_init ⇒ rt_object_init ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_lock_init
• >>   rt_memset
• >>   rt_timer_init
• >>   rt_hw_stack_init
• >>   rt_sched_thread_init_ctx

• >>   rt_thread_create
• >>   rt_thread_init

_thread_exit (Thumb, 48 bytes, Stack size 16 bytes, thread.o(.text._thread_exit))

[Stack]

• Max Depth = 456
• Call Chain = _thread_exit ⇒ _thread_detach_from_mutex ⇒ rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_enter_critical
• >>   rt_schedule
• >>   rt_thread_self
• >>   rt_thread_defunct_enqueue
• >>   rt_exit_critical_safe
• >>   rt_thread_close
• >>   _thread_detach_from_mutex

• thread.o(.text._thread_init)

_thread_timeout (Thumb, 96 bytes, Stack size 16 bytes, thread.o(.text._thread_timeout))

[Stack]

• Max Depth = 336
• Call Chain = _thread_timeout ⇒ rt_sched_unlock_n_resched ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_sched_thread_is_suspended
• >>   rt_sched_unlock_n_resched
• >>   rt_sched_lock
• >>   rt_sched_insert_thread

• thread.o(.text._thread_init)

_thread_detach (Thumb, 40 bytes, Stack size 16 bytes, thread.o(.text._thread_detach))

[Stack]

• Max Depth = 456
• Call Chain = _thread_detach ⇒ _thread_detach_from_mutex ⇒ rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_enter_critical
• >>   rt_thread_defunct_enqueue
• >>   rt_exit_critical_safe
• >>   rt_thread_close
• >>   _thread_detach_from_mutex

• >>   rt_thread_delete
• >>   rt_thread_detach

_thread_detach_from_mutex (Thumb, 86 bytes, Stack size 24 bytes, thread.o(.text._thread_detach_from_mutex))

[Stack]

• Max Depth = 440
• Call Chain = _thread_detach_from_mutex ⇒ rt_mutex_release ⇒ rt_sched_thread_ready ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_mutex_release
• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_object_get_type
• >>   rt_mutex_drop_thread

• >>   _thread_detach
• >>   _thread_exit

_thread_sleep (Thumb, 220 bytes, Stack size 32 bytes, thread.o(.text._thread_sleep))

[Stack]

• Max Depth = 432
• Call Chain = _thread_sleep ⇒ rt_thread_suspend_with_flag ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_enter_critical
• >>   rt_schedule
• >>   rt_timer_start
• >>   rt_timer_control
• >>   rt_thread_suspend_with_flag
• >>   rt_interrupt_get_nest
• >>   rt_critical_level
• >>   rt_object_get_type
• >>   rt_assert_handler
• >>   rt_thread_self
• >>   rt_kprintf
• >>   rt_exit_critical_safe

• >>   rt_thread_mdelay

_timer_start (Thumb, 136 bytes, Stack size 32 bytes, timer.o(.text._timer_start))

[Stack]

• Max Depth = 32
• Call Chain = _timer_start

• >>   rt_tick_get

• >>   rt_timer_start
• >>   _timer_check

_timer_check (Thumb, 192 bytes, Stack size 40 bytes, timer.o(.text._timer_check))

[Stack]

• Max Depth = 376
• Call Chain = _timer_check ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_spin_unlock_irqrestore
• >>   rt_spin_lock_irqsave
• >>   rt_tick_get
• >>   _timer_start

• >>   rt_timer_check
• >>   _timer_thread_entry

_timer_thread_entry (Thumb, 36 bytes, Stack size 0 bytes, timer.o(.text._timer_thread_entry))

[Stack]

• Max Depth = 440
• Call Chain = _timer_thread_entry ⇒ rt_sem_take ⇒ _rt_sem_take ⇒ rt_thread_suspend_to_list ⇒ rt_sched_thread_timer_stop ⇒ rt_timer_stop ⇒ rt_spin_unlock_irqrestore ⇒ rt_exit_critical_safe ⇒ rt_exit_critical ⇒ rt_schedule ⇒ rt_scheduler_stack_check ⇒ rt_assert_handler ⇒ rt_backtrace ⇒ rt_backtrace_frame ⇒ rt_kprintf ⇒ rt_vsnprintf ⇒ print_number

• >>   rt_sem_take
• >>   _timer_check

• timer.o(.text.rt_system_timer_thread_init)

skip_atoi (Thumb, 36 bytes, Stack size 8 bytes, rt_vsnprintf_tiny.o(.text.skip_atoi))

[Stack]

• Max Depth = 8
• Call Chain = skip_atoi

• >>   rt_vsnprintf

print_number (Thumb, 448 bytes, Stack size 88 bytes, rt_vsnprintf_tiny.o(.text.print_number))

[Stack]

• Max Depth = 88
• Call Chain = print_number

• >>   __aeabi_memclr4

• >>   rt_vsnprintf

SystemRuntimeInit (Thumb, 68 bytes, Stack size 24 bytes, system.o(.text.SystemRuntimeInit))

[Stack]

• Max Depth = 24
• Call Chain = SystemRuntimeInit

• >>   __aeabi_memclr4
• >>   __aeabi_memcpy4

• >>   SystemInit

r_sci_uart_baud_set (Thumb, 44 bytes, Stack size 8 bytes, r_sci_uart.o(.text.r_sci_uart_baud_set))

[Stack]

• Max Depth = 8
• Call Chain = r_sci_uart_baud_set

• >>   R_SCI_UART_Open

r_sci_irq_cfg (Thumb, 36 bytes, Stack size 16 bytes, r_sci_uart.o(.text.r_sci_irq_cfg))

[Stack]

• Max Depth = 32
• Call Chain = r_sci_irq_cfg ⇒ R_BSP_IrqCfg

• >>   R_BSP_IrqDisable
• >>   R_BSP_IrqCfg
• >>   R_BSP_IrqStatusClear

• r_sci_uart.o(.text.R_SCI_UART_Open)

r_sci_uart_call_callback (Thumb, 62 bytes, Stack size 48 bytes, r_sci_uart.o(.text.r_sci_uart_call_callback))

[Stack]

• Max Depth = 48
• Call Chain = r_sci_uart_call_callback

• >>   sci_uart_eri_isr
• >>   sci_uart_tei_isr
• >>   sci_uart_rxi_isr
• >>   sci_uart_txi_isr

bsp_prv_operating_mode_opccr_set (Thumb, 36 bytes, Stack size 0 bytes, bsp_clocks.o(.text.bsp_prv_operating_mode_opccr_set))

[Called By]

• >>   bsp_clock_init

r_ioport_pins_config (Thumb, 48 bytes, Stack size 16 bytes, r_ioport.o(.text.r_ioport_pins_config))

[Stack]

• Max Depth = 36
• Call Chain = r_ioport_pins_config ⇒ r_ioport_pfs_write

• >>   R_BSP_PinAccessDisable
• >>   r_ioport_pfs_write
• >>   R_BSP_PinAccessEnable

• >>   R_IOPORT_Open
• >>   R_IOPORT_PinsCfg

R_BSP_PinAccessEnable (Thumb, 40 bytes, Stack size 0 bytes, r_ioport.o(.text.R_BSP_PinAccessEnable))

[Called By]

• >>   R_IOPORT_PinCfg
• >>   r_ioport_pins_config

r_ioport_pfs_write (Thumb, 44 bytes, Stack size 20 bytes, r_ioport.o(.text.r_ioport_pfs_write))

[Stack]

• Max Depth = 20
• Call Chain = r_ioport_pfs_write

• >>   R_IOPORT_PinCfg
• >>   r_ioport_pins_config

R_BSP_PinAccessDisable (Thumb, 44 bytes, Stack size 0 bytes, r_ioport.o(.text.R_BSP_PinAccessDisable))

[Called By]

• >>   R_IOPORT_PinCfg
• >>   r_ioport_pins_config

Undefined Global Symbols

_call_atexit_fns (ARM, 0 bytes, Stack size 0 bytes, UNDEFINED)

[Called By]

• >>   exit