A group of struct gdbarch functions and a value provide information about the current stack and how it is being processed by the target program.

set_gdbarch_skip_prologue         (gdbarch, or1k_skip_prologue);
set_gdbarch_inner_than            (gdbarch, core_addr_lessthan);
set_gdbarch_frame_align           (gdbarch, or1k_frame_align);
set_gdbarch_frame_red_zone_size   (gdbarch, OR1K_FRAME_RED_ZONE_SIZE);
	    

set_gdbarch_unwind_pc             (gdbarch, or1k_unwind_pc);
set_gdbarch_unwind_sp             (gdbarch, or1k_unwind_sp);
	    

There are only two functions required here, or1k_unwind_pc and or1k_unwind_sp. Given a pointer to the NEXT frame, these functions return the value of respectively the program counter and stack pointer in THIS frame.

Since the OpenRISC architecture defines standard frame sniffers, and both these registers are raw registers, the functions can be implemented very simply by a call to frame_unwind_register_unsigned.

Two struct gdbarch provide support for calling code in the target inferior.

set_gdbarch_push_dummy_call       (gdbarch, or1k_push_dummy_call);
set_gdbarch_unwind_dummy_id       (gdbarch, or1k_unwind_dummy_id);
	    

The preceding functions all have a 1:1 relationship with struct gdbarch. However for stack analysis (or "sniffing") more than one approach may be appropriate, so a list of functions is maintained.

The low level stack analysis functions are set by frame_unwind_append_sniffer. The OpenRISC 1000 has its own sniffers for finding the ID of a frame and getting the value of a register on the frame specified by or1k_frame_sniffer. For all other sniffing functions, the default DWARF2 frame sniffer is used, dwarf2_frame_sniffer.

The high level sniffer finds the base of the stack frame. OpenRISC defines its own base sniffer, or1k_frame_base as default. It provides all the functionality needed, so can be used as the default base sniffer, set using frame_base_set_default. The frame base is a structure, with entries pointing to the corresponding frame sniffer and functions to give the base address of the frame, the arguments on the frame and the local variables on the frame. Since these are all the same for the OpenRISC 1000, the same function, or1k_frame_base_address is used for all three.

The same function, or1k_frame_base_address is used to provide all three base functions: for the frame itself, the local variables and any arguments. In the OpenRISC 1000 these are all the same value.

or1k_frame_base.unwind      = or1k_frame_sniffer (NULL);
or1k_frame_base.this_base   = or1k_frame_base_address;
or1k_frame_base.this_locals = or1k_frame_base_address;
or1k_frame_base.this_args   = or1k_frame_base_address;
frame_base_set_default            (gdbarch, &or1k_frame_base);
	    

The specification of this function requires the end of the stack, i.e. the stack pointer. Rather confusingly the function is also used to determine the value of the $fp variable if deprecated_fp_regnum has not been set and there is no register with the name "fp". However, as noted earlier, GDB is moving away from an intrinsic understanding of frame pointers. For the OpenRISC 1000, deprecated_fp_regnum is currently defined, although in time a pseudo register will be defined, with the name of fp and mapping to GPR 2.

Like all the frame sniffers, this function is passed the address of the NEXT frame, and requires the value for THIS frame, so the value of the stack pointer is unwound from the stack by using the generic register unwinder, frame_unwind_register_unsigned.

The function or1k_frame_sniffer returns a pointer to struct frame_unwind with entries for the functions defined by this sniffer. For the OpenRISC 1000, this defines a custom function to construct the frame ID of THIS frame given a pointer to the NEXT frame (or1k_frame_this_id) and a custom function to give the value of a register in THIS frame given a pointer to the NEXT frame (or1k_frame_prev_register).

The OpenRISC 1000 low level sniffers rely on or1k_frame_unwind_cache. This is the heart of the sniffer. It must determine the frame ID for THIS frame given a pointer to the NEXT frame and then the information in THIS frame about the values of registers in the PREVIOUS frame.

All this data is returned in a prologue cache (see Section 2.3.6), a reference to which is passed as an argument. If the cache already exists for THIS frame it can be returned immediately as the result.

If the cache does not yet exist, it is allocated (using trad_frame_cache_zalloc). The first step is to unwind the start address of this function from the NEXT frame. The DWARF2 information in the object file can be used to find the end of the prologue (using skip_prologue_using_sal).

The code then works through each instruction of the prologue to find the data required.

	Caution
	The analysis must only consider prologue instructions that have actually been executed. It is quite possible the program counter is in the prologue code, and only instructions that have actually been executed should be analyzed.

The stack pointer and program counter are found by simply unwinding the NEXT frame. The stack pointer is the base of THIS frame, and is added to the cache data using trad_frame_set_this_base.

end_iaddr marks the end of the code we should analyze. Only instructions with addresses less than this will be considered.

The l.addi instruction should be first and its immediate constant field is the size of the stack. If it is missing, then this is a frameless call to a function. If the program counter is right at the start of the function, before the stack and frame pointers are set up, then it will also look like a frameless function.

Unless it is subsequently found to have been saved on the stack, the program counter of the PREVIOUS frame is the link register of THIS frame and can be recorded in the register cache.

Tip

It is essential to save the register data using the correct function. Use trad_frame_set_reg_realreg when a register in the PREVIOUS frame is obtained from a register in THIS frame. Use trad_frame_set_reg_addr when a register in the PREVIOUS frame is obtained from an address in THIS frame. Use trad_frame_set_reg_value when a register in the PREVIOUS frame is a particular value in THIS frame. The default entry for each register is that its value in the PREVIOUS frame is obtained from the same register in THIS frame.

For a frameless call, there is no more information to be found, so the rest of the code analysis only applies if the frame size was non-zero.

The second instruction in the prologue is where the frame pointer of the PREVIOUS frame is saved. It is an error if this is missing. The address where it is saved (the stack pointer of THIS frame plus the offset in the l.sw instruction) is saved in the cache using trad_frame_set_reg_addr.

The third instruction should be an l.addi instruction which sets the frame pointer. The frame size set in this instruction should match the frame size set in the first instruction. Once this has been set up, the frame pointer can be used to yield the stack pointer of the previous frame. This information is recorded in the register cache.

The fourth instruction is optional and saves the return address to the stack. If this instruction is found, the entry in the register cache for the program counter in the PREVIOUS frame must be changed using trad_frame_set_reg_addr to indicate it is found at an address in this frame.

All the subsequent instructions in the prolong should be saves of callee-savable registers. These are checked for until the code address has reached the end of the prologue. For each instruction that is found, the save location of the register is recorded in the cache using trad_frame_set_reg_addr.

The detailed analysis in or1k_frame_unwind_cache uses a series of helper functions: or1k_frame_size, or1k_frame_fp_loc, or1k_frame_size_check, or1k_link_address and or1k_get_saved_reg. These helper routines check each of the instructions in the prologue. By breaking out this code into separate functions, they can be reused by or1k_skip_prologue.