#include "config.h"#include "system.h"#include "coretypes.h"#include "target.h"#include "function.h"#include "rtl.h"#include "tree.h"#include "tree-pass.h"#include "memmodel.h"#include "tm_p.h"#include "emit-rtl.h"#include "stor-layout.h"#include "cfgbuild.h"#include "dwarf2out.h"#include "dwarf2asm.h"#include "common/common-target.h"#include "except.h"#include "profile-count.h"#include "expr.h"#include "output.h"#include "debug.h"#include "flags.h"#include "gt-dwarf2cfi.h"
Data Structures | |
| struct | dw_cfi_row |
| struct | reg_saved_in_data |
| struct | dw_trace_info |
| struct | trace_info_hasher |
| struct | queued_reg_save |
| struct | init_one_dwarf_reg_state |
Macros | |
| #define | INCOMING_RETURN_ADDR_RTX (gcc_unreachable (), NULL_RTX) |
| #define | DEFAULT_INCOMING_FRAME_SP_OFFSET INCOMING_FRAME_SP_OFFSET |
Macro Definition Documentation
◆ DEFAULT_INCOMING_FRAME_SP_OFFSET
| #define DEFAULT_INCOMING_FRAME_SP_OFFSET INCOMING_FRAME_SP_OFFSET |
Referenced by create_cie_data(), and scan_trace().
◆ INCOMING_RETURN_ADDR_RTX
| #define INCOMING_RETURN_ADDR_RTX (gcc_unreachable (), NULL_RTX) |
Dwarf2 Call Frame Information helper routines. Copyright (C) 1992-2024 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>.
??? Poison these here until it can be done generically. They've been totally replaced in this file; make sure it stays that way.
Referenced by create_cie_data(), and df_get_entry_block_def_set().
Function Documentation
◆ add_cfi()
|
static |
Add CFI either to the current insn stream or to a vector, or both.
References add_cfi_insn, add_cfi_vec, any_cfis_emitted, emit_note_after(), ggc_alloc(), NOTE_CFI, NULL, and vec_safe_push().
Referenced by add_cfi_args_size(), add_cfi_restore(), change_cfi_row(), connect_traces(), def_cfa_1(), dwarf2out_frame_debug_cfa_expression(), dwarf2out_frame_debug_cfa_toggle_ra_mangle(), dwarf2out_frame_debug_cfa_val_expression(), dwarf2out_frame_debug_cfa_window_save(), and reg_save().
◆ add_cfi_args_size()
|
static |
References add_cfi(), gcc_assert, ggc_alloc(), new_cfi(), and poly_int< N, C >::to_constant().
Referenced by connect_traces(), and notice_eh_throw().
◆ add_cfi_restore()
References add_cfi(), ggc_alloc(), and new_cfi().
Referenced by change_cfi_row(), and dwarf2out_frame_debug_cfa_restore().
◆ add_cfis_to_fde()
Walk the function, looking for NOTE_INSN_CFI notes. Add the CFIs to the function's FDE, adding CFI labels and set_loc/advance_loc opcodes as necessary.
References active_insn_p(), cfi_label_required_p(), cfun, dw_fde_node::dw_fde_cfi, dw_fde_node::dw_fde_switch_cfi_index, dwarf2out_cfi_label(), dwarf2out_cfi_label_num, emit_note_before(), get_insns(), ggc_alloc(), new_cfi(), NEXT_INSN(), NOTE_CFI, NOTE_KIND, NOTE_LABEL_NUMBER, NOTE_P, vec_safe_length(), and vec_safe_push().
Referenced by execute_dwarf2_frame().
◆ before_next_cfi_note()
Return the insn before the first NOTE_INSN_CFI after START.
References gcc_unreachable, ggc_alloc(), NEXT_INSN(), NOTE_KIND, and NOTE_P.
Referenced by connect_traces().
◆ cfa_equal_p()
| bool cfa_equal_p | ( | const dw_cfa_location * | loc1, |
| const dw_cfa_location * | loc2 ) |
Determine if two dw_cfa_location structures define the same data.
References ggc_alloc(), and known_eq.
Referenced by cfi_oprnd_equal_p(), cfi_row_equal_p(), convert_cfa_to_fb_loc_list(), and def_cfa_0().
◆ cfi_equal_p()
|
static |
Determine if two CFI entries are identical.
References a, b, cfi_oprnd_equal_p(), dw_cfi_oprnd1_desc(), dw_cfi_oprnd2_desc(), ggc_alloc(), and NULL.
Referenced by cfi_row_equal_p(), and change_cfi_row().
◆ cfi_label_required_p()
|
static |
Examine CFI and return true if a cfi label and set_loc is needed beforehand. Even when generating CFI assembler instructions, we still have to add the cfi to the list so that lookup_cfa_1 works later on. When -g2 and above we even need to force emitting of CFI labels and add to list a DW_CFA_set_loc for convert_cfa_to_fb_loc_list purposes. If we're generating DWARF3 output we use DW_OP_call_frame_cfa and so don't use convert_cfa_to_fb_loc_list.
References DINFO_LEVEL_TERSE, dwarf2out_do_cfi_asm(), dwarf_debuginfo_p(), and ggc_alloc().
Referenced by add_cfis_to_fde().
◆ cfi_oprnd_equal_p()
|
static |
Determine if two CFI operands are identical.
References a, b, cfa_equal_p(), dw_cfi_oprnd_addr, dw_cfi_oprnd_cfa_loc, dw_cfi_oprnd_loc, dw_cfi_oprnd_offset, dw_cfi_oprnd_reg_num, dw_cfi_oprnd_unused, gcc_unreachable, ggc_alloc(), and loc_descr_equal_p().
Referenced by cfi_equal_p().
◆ cfi_row_equal_p()
|
static |
Determine if two CFI_ROW structures are identical.
References a, b, cfa_equal_p(), cfi_equal_p(), ggc_alloc(), i, MAX, NULL, and vec_safe_length().
Referenced by connect_traces(), and maybe_record_trace_start().
◆ change_cfi_row()
|
static |
Emit CFI info to change the state from OLD_ROW to NEW_ROW.
References add_cfi(), add_cfi_restore(), cfi_equal_p(), def_cfa_0(), gcc_assert, ggc_alloc(), i, MAX, new_cfi(), NULL, and vec_safe_length().
Referenced by connect_traces().
◆ clobbers_queued_reg_save()
Does INSN clobber any register which QUEUED_REG_SAVES lists a saved location for? Or, does it clobber a register which we've previously said that some other register is saved in, and for which we now have a new location for?
References compare_reg_or_pc(), cur_trace, FOR_EACH_VEC_ELT, ggc_alloc(), modified_in_p(), queued_reg_saves, queued_reg_save::reg, and dw_trace_info::regs_saved_in_regs.
Referenced by dwarf2out_frame_debug(), and scan_trace().
◆ compare_reg_or_pc()
Compare X and Y for equivalence. The inputs may be REGs or PC_RTX.
References REG_P, REGNO, and y.
Referenced by clobbers_queued_reg_save(), queue_reg_save(), and record_reg_saved_in_reg().
◆ connect_traces()
Insert CFI notes between traces to properly change state between them.
References add_cfi(), add_cfi_args_size(), add_cfi_insn, dw_trace_info::args_size_defined_for_eh, dw_trace_info::args_size_undefined, before_next_cfi_note(), dw_trace_info::beg_delay_args_size, dw_trace_info::beg_row, dw_cfi_row::cfa, cfi_row_equal_p(), cfun, change_cfi_row(), cie_cfi_row, def_cfa_0(), dump_file, dw_trace_info::eh_head, dw_trace_info::end_delay_args_size, dw_trace_info::end_row, FOR_EACH_VEC_ELT, gcc_assert, ggc_alloc(), dw_trace_info::head, i, dw_trace_info::id, new_cfi(), NEXT_INSN(), NOTE_CFI, NOTE_KIND, NOTE_P, NULL, output_cfi_directive(), PREV_INSN(), dw_trace_info::switch_sections, targetm, trace_info, and VEC_ORDERED_REMOVE_IF_FROM_TO.
Referenced by execute_dwarf2_frame(), and reorder_basic_blocks_software_trace_cache().
◆ copy_cfa()
|
static |
◆ copy_cfi_row()
|
static |
Return a copy of an existing CFI row.
References ggc_alloc(), dw_cfi_row::reg_save, and vec_safe_copy().
Referenced by maybe_record_trace_start(), and scan_trace().
◆ create_cfi_notes()
Scan the function and create the initial set of CFI notes.
References gcc_checking_assert, queued_reg_saves, scan_trace(), trace_info, and trace_work_list.
Referenced by execute_dwarf2_frame().
◆ create_cie_data()
References add_cfi_vec, cie_cfi_row, cie_cfi_vec, cie_return_save, cur_row, cur_trace, def_cfa_1(), DEFAULT_INCOMING_FRAME_SP_OFFSET, dw_stack_pointer_regnum, dwf_cfa_reg(), gcc_unreachable, ggc_alloc(), global_options, INCOMING_RETURN_ADDR_RTX, initial_return_save(), new_cfi_row(), NULL, dw_cfa_location::offset, dw_cfa_location::reg, stack_pointer_rtx, targetm, and UI_DWARF2.
Referenced by execute_dwarf2_frame().
◆ create_pseudo_cfg()
Set up the pseudo-cfg of instruction traces, as described at the block comment at the top of the file.
References BARRIER_P, dw_trace_info::beg_row, dw_cfi_row::cfa, dw_trace_info::cfa_store, dw_trace_info::cfa_temp, cie_cfi_row, cie_return_save, dump_file, FOR_EACH_VEC_ELT, gcc_assert, GET_CODE, get_insns(), ggc_alloc(), dw_trace_info::head, i, dw_trace_info::id, INSN_UID(), INVALID_REGNUM, LABEL_P, NEXT_INSN(), NOTE_KIND, NOTE_P, NULL, dw_cfa_location::reg, dw_trace_info::regs_saved_in_regs, rtx_name, save_point_p(), cfa_reg::set_by_dwreg(), dw_trace_info::switch_sections, trace_index, and trace_info.
Referenced by execute_dwarf2_frame().
◆ create_trace_edges()
Propagate CUR_TRACE state to the destinations implied by INSN.
??? Sadly, this is in large part a duplicate of make_edges.
References ASM_OPERANDS_LABEL, ASM_OPERANDS_LABEL_LENGTH, CALL_P, can_nonlocal_goto(), cfun, computed_jump_p(), create_trace_edges(), extract_asm_operands(), find_reg_note(), FOR_EACH_VEC_SAFE_ELT, forced_labels, gcc_assert, get_eh_landing_pad_from_rtx(), GET_NUM_ELEM, ggc_alloc(), i, JUMP_LABEL_AS_INSN(), JUMP_P, label_ref_label(), eh_landing_pad_d::landing_pad, maybe_record_trace_start(), maybe_record_trace_start_abnormal(), nonlocal_goto_handler_labels, NULL, NULL_RTX, PATTERN(), returnjump_p(), RTVEC_ELT, SET_SRC, SIBLING_CALL_P, table, tablejump_casesi_pattern(), tablejump_p(), and XEXP.
Referenced by create_trace_edges(), and scan_trace().
◆ debug_cfi_row()
| void debug_cfi_row | ( | dw_cfi_row * | row | ) |
References dump_cfi_row(), and ggc_alloc().
◆ def_cfa_0()
|
static |
The CFA is now calculated from NEW_CFA. Consider OLD_CFA in determining what opcode to emit. Returns the CFI opcode to effect the change, or NULL if NEW_CFA == OLD_CFA.
References build_cfa_loc(), cfa_equal_p(), copy_cfa(), ggc_alloc(), INVALID_REGNUM, known_eq, new_cfi(), and NULL.
Referenced by change_cfi_row(), connect_traces(), def_cfa_1(), and dump_cfi_row().
◆ def_cfa_1()
|
static |
Similarly, but take OLD_CFA from CUR_ROW, and update it after the fact.
References add_cfi(), dw_cfi_row::cfa, dw_cfi_row::cfa_cfi, dw_trace_info::cfa_store, cur_row, cur_trace, def_cfa_0(), ggc_alloc(), NULL, dw_cfa_location::offset, and dw_cfa_location::reg.
Referenced by create_cie_data(), and scan_trace().
◆ div_data_align()
|
inlinestatic |
Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder.
References DWARF_CIE_DATA_ALIGNMENT, gcc_assert, ggc_alloc(), and r.
Referenced by output_cfi().
◆ dump_cfi_row()
|
static |
References def_cfa_0(), FOR_EACH_VEC_SAFE_ELT, ggc_alloc(), i, INVALID_REGNUM, output_cfi_directive(), dw_cfa_location::reg, and cfa_reg::set_by_dwreg().
Referenced by debug_cfi_row(), and maybe_record_trace_start().
◆ dwarf2cfi_cc_finalize()
References add_cfi_insn, add_cfi_vec, cur_cfa, cur_row, cur_trace, and NULL.
Referenced by toplev::finalize().
◆ dwarf2out_cfi_label()
Generate a new label for the CFI info to refer to.
References dwarf2out_cfi_label_num, and ggc_alloc().
Referenced by add_cfis_to_fde().
◆ dwarf2out_do_cfi_asm()
Decide whether to emit frame unwind via assembler directives.
References ASM_PREFERRED_EH_DATA_FORMAT, dwarf2out_do_eh_frame(), dwarf2out_do_frame(), ggc_alloc(), and saved_do_cfi_asm.
Referenced by cfi_label_required_p(), dwarf2out_begin_prologue(), dwarf2out_emit_cfi(), dwarf2out_end_epilogue(), dwarf2out_switch_text_section(), and output_call_frame_info().
◆ dwarf2out_do_eh_frame()
Decide whether to emit EH frame unwind information for the current translation unit.
References ggc_alloc(), global_options, and UI_DWARF2.
Referenced by dwarf2out_begin_prologue(), dwarf2out_do_cfi_asm(), and dwarf2out_do_frame().
◆ dwarf2out_do_frame()
Decide whether we want to emit frame unwind information for the current translation unit.
References dwarf2out_do_eh_frame(), dwarf_based_debuginfo_p(), dwarf_debuginfo_p(), saved_do_cfi_asm, targetm, and UI_DWARF2.
Referenced by dwarf2out_begin_prologue(), dwarf2out_do_cfi_asm(), final_end_function(), and final_scan_insn_1().
◆ dwarf2out_emit_cfi()
| void dwarf2out_emit_cfi | ( | dw_cfi_ref | cfi | ) |
References asm_out_file, dwarf2out_do_cfi_asm(), ggc_alloc(), and output_cfi_directive().
Referenced by final_scan_insn_1().
◆ dwarf2out_flush_queued_reg_saves()
Output all the entries in QUEUED_REG_SAVES.
References queued_reg_save::cfa_offset, DWARF_FRAME_RETURN_COLUMN, dwf_cfa_reg(), dwf_regno(), FOR_EACH_VEC_ELT, ggc_alloc(), i, INVALID_REGNUM, pc_rtx, queued_reg_saves, record_reg_saved_in_reg(), queued_reg_save::reg, cfa_reg::reg, reg_save(), and queued_reg_save::saved_reg.
Referenced by dwarf2out_frame_debug(), dwarf2out_frame_debug_expr(), and scan_trace().
◆ dwarf2out_frame_debug()
Record call frame debugging information for INSN, which either sets SP or FP (adjusting how we calculate the frame address) or saves a register to the stack.
References cfun, clobbers_queued_reg_save(), dwarf2out_flush_queued_reg_saves(), dwarf2out_frame_debug_adjust_cfa(), dwarf2out_frame_debug_cfa_expression(), dwarf2out_frame_debug_cfa_offset(), dwarf2out_frame_debug_cfa_register(), dwarf2out_frame_debug_cfa_restore(), dwarf2out_frame_debug_cfa_toggle_ra_mangle(), dwarf2out_frame_debug_cfa_val_expression(), dwarf2out_frame_debug_cfa_window_save(), dwarf2out_frame_debug_def_cfa(), dwarf2out_frame_debug_expr(), dwf_regno(), gcc_assert, GET_CODE, ggc_alloc(), INVALID_REGNUM, NULL, PATTERN(), REG_NOTE_KIND, REG_NOTES, REG_P, single_set(), dw_fde_node::vdrap_reg, XEXP, and XVECEXP.
Referenced by scan_insn_after().
◆ dwarf2out_frame_debug_adjust_cfa()
A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note.
References cur_cfa, dwf_cfa_reg(), gcc_assert, gcc_unreachable, GET_CODE, ggc_alloc(), dw_cfa_location::indirect, dw_cfa_location::offset, dw_cfa_location::reg, rtx_to_poly_int64(), SET, and XEXP.
Referenced by dwarf2out_frame_debug().
◆ dwarf2out_frame_debug_cfa_expression()
A subroutine of dwarf2out_frame_debug, process a REG_CFA_EXPRESSION note.
References add_cfi(), cur_row, dwf_regno(), gcc_assert, get_address_mode(), GET_MODE, ggc_alloc(), mem_loc_descriptor(), MEM_P, new_cfi(), REG_P, SET_DEST, SET_SRC, cfa_reg::span, targetm, update_row_reg_save(), VAR_INIT_STATUS_INITIALIZED, and XEXP.
Referenced by dwarf2out_frame_debug().
◆ dwarf2out_frame_debug_cfa_offset()
A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note.
References cur_cfa, DWARF_FRAME_RETURN_COLUMN, dwf_regno(), gcc_assert, gcc_unreachable, GET_CODE, GET_MODE, GET_MODE_SIZE(), ggc_alloc(), INVALID_REGNUM, MEM_P, NULL, dw_cfa_location::offset, offset, pc_rtx, dw_cfa_location::reg, reg_save(), rtx_to_poly_int64(), cfa_reg::set_by_dwreg(), cfa_reg::span, targetm, XEXP, XVECEXP, and XVECLEN.
Referenced by dwarf2out_frame_debug().
◆ dwarf2out_frame_debug_cfa_register()
A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note.
References DWARF_FRAME_RETURN_COLUMN, dwf_cfa_reg(), dwf_regno(), ggc_alloc(), pc_rtx, record_reg_saved_in_reg(), reg_save(), and XEXP.
Referenced by dwarf2out_frame_debug().
◆ dwarf2out_frame_debug_cfa_restore()
A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note. When called with EMIT_CFI set to false emitting a CFI statement is suppressed.
References add_cfi_restore(), cur_row, dwf_regno(), gcc_assert, GET_CODE, ggc_alloc(), NULL, cfa_reg::reg, REG_P, cfa_reg::span, targetm, update_row_reg_save(), XVECEXP, and XVECLEN.
Referenced by dwarf2out_frame_debug().
◆ dwarf2out_frame_debug_cfa_toggle_ra_mangle()
A subroutine of dwarf2out_frame_debug, process a REG_CFA_TOGGLE_RA_MANGLE. Note: DW_CFA_GNU_window_save dwarf opcode is reused for toggling RA mangle state, this is a target specific operation on AArch64 and can only be used on other targets if they don't use the window save operation otherwise.
References add_cfi(), cur_row, ggc_alloc(), new_cfi(), and dw_cfi_row::ra_mangled.
Referenced by dwarf2out_frame_debug().
◆ dwarf2out_frame_debug_cfa_val_expression()
A subroutine of dwarf2out_frame_debug, process a REG_CFA_VAL_EXPRESSION note.
References add_cfi(), cur_row, dwf_regno(), gcc_assert, GET_MODE, ggc_alloc(), mem_loc_descriptor(), new_cfi(), REG_P, SET_DEST, SET_SRC, cfa_reg::span, targetm, update_row_reg_save(), and VAR_INIT_STATUS_INITIALIZED.
Referenced by dwarf2out_frame_debug().
◆ dwarf2out_frame_debug_cfa_window_save()
A subroutine of dwarf2out_frame_debug, process a REG_CFA_WINDOW_SAVE. ??? Perhaps we should note in the CIE where windows are saved (instead of assuming 0(cfa)) and what registers are in the window.
References add_cfi(), cur_row, ggc_alloc(), new_cfi(), and dw_cfi_row::window_save.
Referenced by dwarf2out_frame_debug().
◆ dwarf2out_frame_debug_def_cfa()
A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note.
References dw_cfa_location::base_offset, cur_cfa, dwf_cfa_reg(), gcc_assert, ggc_alloc(), dw_cfa_location::indirect, MEM_P, dw_cfa_location::offset, dw_cfa_location::reg, REG_P, strip_offset(), and XEXP.
Referenced by dwarf2out_frame_debug().
◆ dwarf2out_frame_debug_expr()
Record call frame debugging information for an expression EXPR,
which either sets SP or FP (adjusting how we calculate the frame
address) or saves a register to the stack or another register.
LABEL indicates the address of EXPR.
This function encodes a state machine mapping rtxes to actions on
cfa, cfa_store, and cfa_temp.reg. We describe these rules so
users need not read the source code.
The High-Level Picture
Changes in the register we use to calculate the CFA: Currently we
assume that if you copy the CFA register into another register, we
should take the other one as the new CFA register; this seems to
work pretty well. If it's wrong for some target, it's simple
enough not to set RTX_FRAME_RELATED_P on the insn in question.
Changes in the register we use for saving registers to the stack:
This is usually SP, but not always. Again, we deduce that if you
copy SP into another register (and SP is not the CFA register),
then the new register is the one we will be using for register
saves. This also seems to work.
Register saves: There's not much guesswork about this one; if
RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
register save, and the register used to calculate the destination
had better be the one we think we're using for this purpose.
It's also assumed that a copy from a call-saved register to another
register is saving that register if RTX_FRAME_RELATED_P is set on
that instruction. If the copy is from a call-saved register to
the *same* register, that means that the register is now the same
value as in the caller.
Except: If the register being saved is the CFA register, and the
offset is nonzero, we are saving the CFA, so we assume we have to
use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
the intent is to save the value of SP from the previous frame.
In addition, if a register has previously been saved to a different
register,
Invariants / Summaries of Rules
cfa current rule for calculating the CFA. It usually
consists of a register and an offset. This is
actually stored in *cur_cfa, but abbreviated
for the purposes of this documentation.
cfa_store register used by prologue code to save things to the stack
cfa_store.offset is the offset from the value of
cfa_store.reg to the actual CFA
cfa_temp register holding an integral value. cfa_temp.offset
stores the value, which will be used to adjust the
stack pointer. cfa_temp is also used like cfa_store,
to track stores to the stack via fp or a temp reg.
Rules 1- 4: Setting a register's value to cfa.reg or an expression
with cfa.reg as the first operand changes the cfa.reg and its
cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
cfa_temp.offset.
Rules 6- 9: Set a non-cfa.reg register value to a constant or an
expression yielding a constant. This sets cfa_temp.reg
and cfa_temp.offset.
Rule 5: Create a new register cfa_store used to save items to the
stack.
Rules 10-14: Save a register to the stack. Define offset as the
difference of the original location and cfa_store's
location (or cfa_temp's location if cfa_temp is used).
Rules 16-20: If AND operation happens on sp in prologue, we assume
stack is realigned. We will use a group of DW_OP_XXX
expressions to represent the location of the stored
register instead of CFA+offset.
The Rules
"{a,b}" indicates a choice of a xor b.
"<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
Rule 1:
(set <reg1> <reg2>:cfa.reg)
effects: cfa.reg = <reg1>
cfa.offset unchanged
cfa_temp.reg = <reg1>
cfa_temp.offset = cfa.offset
Rule 2:
(set sp ({minus,plus,losum} {sp,fp}:cfa.reg
{<const_int>,<reg>:cfa_temp.reg}))
effects: cfa.reg = sp if fp used
cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
if cfa_store.reg==sp
Rule 3:
(set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
effects: cfa.reg = fp
cfa_offset += +/- <const_int>
Rule 4:
(set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
constraints: <reg1> != fp
<reg1> != sp
effects: cfa.reg = <reg1>
cfa_temp.reg = <reg1>
cfa_temp.offset = cfa.offset
Rule 5:
(set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
constraints: <reg1> != fp
<reg1> != sp
effects: cfa_store.reg = <reg1>
cfa_store.offset = cfa.offset - cfa_temp.offset
Rule 6:
(set <reg> <const_int>)
effects: cfa_temp.reg = <reg>
cfa_temp.offset = <const_int>
Rule 7:
(set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
effects: cfa_temp.reg = <reg1>
cfa_temp.offset |= <const_int>
Rule 8:
(set <reg> (high <exp>))
effects: none
Rule 9:
(set <reg> (lo_sum <exp> <const_int>))
effects: cfa_temp.reg = <reg>
cfa_temp.offset = <const_int>
Rule 10:
(set (mem ({pre,post}_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
effects: cfa_store.offset -= <const_int>
cfa.offset = cfa_store.offset if cfa.reg == sp
cfa.reg = sp
cfa.base_offset = -cfa_store.offset
Rule 11:
(set (mem ({pre_inc,pre_dec,post_dec} sp:cfa_store.reg)) <reg>)
effects: cfa_store.offset += -/+ mode_size(mem)
cfa.offset = cfa_store.offset if cfa.reg == sp
cfa.reg = sp
cfa.base_offset = -cfa_store.offset
Rule 12:
(set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
<reg2>)
effects: cfa.reg = <reg1>
cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
Rule 13:
(set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
effects: cfa.reg = <reg1>
cfa.base_offset = -{cfa_store,cfa_temp}.offset
Rule 14:
(set (mem (post_inc <reg1>:cfa_temp <const_int>)) <reg2>)
effects: cfa.reg = <reg1>
cfa.base_offset = -cfa_temp.offset
cfa_temp.offset -= mode_size(mem)
Rule 15:
(set <reg> {unspec, unspec_volatile})
effects: target-dependent
Rule 16:
(set sp (and: sp <const_int>))
constraints: cfa_store.reg == sp
effects: cfun->fde.stack_realign = 1
cfa_store.offset = 0
fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
Rule 17:
(set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
effects: cfa_store.offset += -/+ mode_size(mem)
Rule 18:
(set (mem ({pre_inc, pre_dec} sp)) fp)
constraints: fde->stack_realign == 1
effects: cfa_store.offset = 0
cfa.reg != HARD_FRAME_POINTER_REGNUM
Rule 19:
(set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
constraints: fde->stack_realign == 1
&& cfa.offset == 0
&& cfa.indirect == 0
&& cfa.reg != HARD_FRAME_POINTER_REGNUM
effects: Use DW_CFA_def_cfa_expression to define cfa
cfa.reg == fde->drap_reg
References dw_cfa_location::base_offset, dw_trace_info::cfa_store, dw_trace_info::cfa_temp, cfun, CONST_INT_P, cur_cfa, cur_trace, dw_fde_node::drap_reg, dw_fde_node::drap_reg_saved, dw_frame_pointer_regnum, dw_stack_pointer_regnum, dwarf2out_flush_queued_reg_saves(), dwarf2out_frame_debug_expr(), DWARF_FRAME_RETURN_COLUMN, dwf_cfa_reg(), dwf_regno(), fixed_regs, frame_pointer_needed, gcc_assert, gcc_unreachable, GET_CODE, GET_MODE, GET_MODE_SIZE(), ggc_alloc(), HARD_FRAME_POINTER_REGNUM, hard_frame_pointer_rtx, dw_cfa_location::indirect, INTVAL, INVALID_REGNUM, known_eq, MEM_P, NULL, NULL_RTX, dw_cfa_location::offset, offset, poly_int_rtx_p(), queue_reg_save(), cfa_reg::reg, dw_cfa_location::reg, REG_P, reg_saved_in(), REGNO, RTX_FRAME_RELATED_P, rtx_to_poly_int64(), dw_fde_node::rule18, SET, SET_DEST, SET_SRC, cfa_reg::span, stack_pointer_rtx, dw_fde_node::stack_realign, dw_fde_node::stack_realignment, targetm, XEXP, XVECEXP, and XVECLEN.
Referenced by dwarf2out_frame_debug(), and dwarf2out_frame_debug_expr().
◆ dwarf_cfi_name()
Convert a DWARF call frame info. operation to its string name
References ggc_alloc(), and NULL.
Referenced by output_cfi().
◆ dwf_cfa_reg()
Like dwf_regno, but when the value can span multiple registers.
References dwf_regno(), gcc_assert, GET_MODE, GET_MODE_SIZE(), ggc_alloc(), i, cfa_reg::reg, REG_P, cfa_reg::span, cfa_reg::span_width, targetm, poly_int< N, C >::to_constant(), XVECEXP, and XVECLEN.
Referenced by create_cie_data(), dwarf2out_flush_queued_reg_saves(), dwarf2out_frame_debug_adjust_cfa(), dwarf2out_frame_debug_cfa_register(), dwarf2out_frame_debug_def_cfa(), dwarf2out_frame_debug_expr(), execute_dwarf2_frame(), initial_return_save(), and operator==().
◆ dwf_regno()
Short-hand inline for the very common D_F_R (REGNO (x)) operation.
??? This ought to go into dwarf2out.h, except that dwarf2out.h is used in places where rtl is prohibited.
References DWARF_FRAME_REGNUM, gcc_assert, ggc_alloc(), and REGNO.
Referenced by dwarf2out_flush_queued_reg_saves(), dwarf2out_frame_debug(), dwarf2out_frame_debug_cfa_expression(), dwarf2out_frame_debug_cfa_offset(), dwarf2out_frame_debug_cfa_register(), dwarf2out_frame_debug_cfa_restore(), dwarf2out_frame_debug_cfa_val_expression(), dwarf2out_frame_debug_expr(), dwf_cfa_reg(), and operator==().
◆ execute_dwarf2_frame()
Annotate the function with NOTE_INSN_CFI notes to record the CFI state at each location within the function. These notes will be emitted during pass_final.
References add_cfis_to_fde(), cie_cfi_vec, connect_traces(), create_cfi_notes(), create_cie_data(), create_pseudo_cfg(), dw_frame_pointer_regnum, dwarf2out_alloc_current_fde(), dwf_cfa_reg(), FOR_EACH_VEC_ELT, hard_frame_pointer_rtx, i, NULL, dw_trace_info::regs_saved_in_regs, trace_index, and trace_info.
◆ expand_builtin_dwarf_sp_column()
Hook used by __throw.
References DWARF2_FRAME_REG_OUT, DWARF_FRAME_REGNUM, GEN_INT, and ggc_alloc().
Referenced by expand_builtin().
◆ expand_builtin_init_dwarf_reg_sizes()
Generate code to initialize the dwarf register size table located at the provided ADDRESS.
References char_type_node, DWARF_FRAME_RETURN_COLUMN, expand_normal(), gen_rtx_MEM(), gen_rtx_REG(), GET_MODE, ggc_alloc(), i, init_one_dwarf_reg_size(), init_return_column_size(), REGNO, SCALAR_INT_TYPE_MODE, si, targetm, XVECEXP, and XVECLEN.
Referenced by expand_builtin().
◆ get_cfa_from_loc_descr()
|
static |
This function fills in aa dw_cfa_location structure from a dwarf location descriptor sequence.
References dw_cfa_location::base_offset, dw_loc_descr_node::dw_loc_next, dw_loc_descr_node::dw_loc_opc, dw_loc_descr_node::dw_loc_oprnd1, gcc_assert, gcc_unreachable, ggc_alloc(), dw_cfa_location::indirect, INVALID_REGNUM, known_eq, NULL, dw_cfa_location::offset, cfa_reg::reg, dw_cfa_location::reg, cfa_reg::set_by_dwreg(), cfa_reg::span, cfa_reg::span_width, poly_int< N, C >::to_constant(), dw_val_node::v, dw_val_node::dw_val_struct_union::val_int, and dw_val_node::dw_val_struct_union::val_unsigned.
Referenced by lookup_cfa_1().
◆ get_trace_info()
|
static |
References dw_trace_info::head, INSN_UID(), and trace_index.
Referenced by maybe_record_trace_start().
◆ init_one_dwarf_reg_size()
|
static |
Helper for expand_builtin_init_dwarf_reg_sizes. Generate code to initialize the dwarf register size table entry corresponding to register REGNO in REGMODE. TABLE is the table base address, SLOTMODE is the mode to use for the size entry to initialize, and INIT_STATE is the communication datastructure conveying what we're doing to our caller.
References adjust_address, DWARF2_FRAME_REG_OUT, DWARF_FRAME_REGISTERS, DWARF_FRAME_REGNUM, DWARF_FRAME_RETURN_COLUMN, DWARF_REG_TO_UNWIND_COLUMN, emit_move_insn(), gen_int_mode(), GET_MODE_SIZE(), ggc_alloc(), and table.
Referenced by expand_builtin_init_dwarf_reg_sizes().
◆ init_return_column_size()
|
static |
MEM is a memory reference for the register size table, each element of which has mode MODE. Initialize column C as a return address column.
References adjust_address, emit_move_insn(), gen_int_mode(), GET_MODE_SIZE(), ggc_alloc(), and offset.
Referenced by expand_builtin_init_dwarf_reg_sizes().
◆ initial_return_save()
Record the initial position of the return address. RTL is INCOMING_RETURN_ADDR_RTX.
References dw_cfi_row::cfa, CONST_INT_P, cur_row, DWARF_FRAME_RETURN_COLUMN, dwf_cfa_reg(), gcc_assert, gcc_unreachable, GET_CODE, ggc_alloc(), initial_return_save(), INVALID_REGNUM, dw_cfa_location::offset, offset, pc_rtx, record_reg_saved_in_reg(), cfa_reg::reg, reg_save(), REGNO, rtx_to_poly_int64(), cfa_reg::set_by_dwreg(), and XEXP.
Referenced by create_cie_data(), and initial_return_save().
◆ lookup_cfa_1()
| void lookup_cfa_1 | ( | dw_cfi_ref | cfi, |
| dw_cfa_location * | loc, | ||
| dw_cfa_location * | remember ) |
Find the previous value for the CFA, iteratively. CFI is the opcode to interpret, *LOC will be updated as necessary, *REMEMBER is used for one level of remember/restore state processing.
References gcc_assert, get_cfa_from_loc_descr(), ggc_alloc(), dw_cfa_location::offset, dw_cfa_location::reg, and cfa_reg::set_by_dwreg().
Referenced by convert_cfa_to_fb_loc_list().
◆ make_pass_dwarf2_frame()
| rtl_opt_pass * make_pass_dwarf2_frame | ( | gcc::context * | ctxt | ) |
References ggc_alloc().
◆ maybe_record_trace_start()
If LABEL is the start of a trace, then initialize the state of that trace from CUR_TRACE and CUR_ROW.
References dw_trace_info::args_size_undefined, dw_trace_info::beg_row, dw_trace_info::beg_true_args_size, dw_trace_info::cfa_store, dw_trace_info::cfa_temp, cfi_row_equal_p(), copy_cfi_row(), cur_row, cur_trace, dump_cfi_row(), dump_file, dw_trace_info::end_true_args_size, gcc_assert, gcc_unreachable, GET_CODE, get_trace_info(), ggc_alloc(), dw_trace_info::id, INSN_UID(), NULL, dw_trace_info::regs_saved_in_regs, rtx_name, and trace_work_list.
Referenced by create_trace_edges(), maybe_record_trace_start_abnormal(), and scan_trace().
◆ maybe_record_trace_start_abnormal()
Similarly, but handle the args_size and CFA reset across EH and non-local goto edges.
References dw_cfi_row::cfa, cur_row, cur_trace, dw_stack_pointer_regnum, dw_trace_info::end_true_args_size, ggc_alloc(), known_eq, maybe_record_trace_start(), dw_cfa_location::offset, dw_cfa_location::reg, and STACK_GROWS_DOWNWARD.
Referenced by create_trace_edges().
◆ need_data_align_sf_opcode()
|
inlinestatic |
Return true if we need a signed version of a given opcode (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended).
References ggc_alloc().
Referenced by reg_save().
◆ new_cfi()
|
inlinestatic |
Return a pointer to a newly allocated Call Frame Instruction.
References ggc_alloc().
Referenced by add_cfi_args_size(), add_cfi_restore(), add_cfis_to_fde(), change_cfi_row(), connect_traces(), def_cfa_0(), dwarf2out_frame_debug_cfa_expression(), dwarf2out_frame_debug_cfa_toggle_ra_mangle(), dwarf2out_frame_debug_cfa_val_expression(), dwarf2out_frame_debug_cfa_window_save(), and reg_save().
◆ new_cfi_row()
|
static |
Return a newly allocated CFI row, with no defined data.
References ggc_alloc(), and INVALID_REGNUM.
Referenced by create_cie_data().
◆ notice_args_size()
A subroutine of scan_trace. Check INSN for a REG_ARGS_SIZE note and adjust data structures to match.
References dw_trace_info::args_size_defined_for_eh, cur_cfa, cur_trace, dw_stack_pointer_regnum, dw_trace_info::eh_head, dw_trace_info::end_true_args_size, find_reg_note(), gcc_assert, get_args_size(), ggc_alloc(), dw_cfa_location::indirect, known_eq, NULL, dw_cfa_location::offset, dw_cfa_location::reg, and STACK_GROWS_DOWNWARD.
Referenced by scan_insn_after().
◆ notice_eh_throw()
A subroutine of scan_trace. INSN is can_throw_internal. Update the data within the trace related to EH insns and args_size.
References add_cfi_args_size(), dw_trace_info::beg_delay_args_size, cur_trace, dw_trace_info::eh_head, dw_trace_info::end_delay_args_size, dw_trace_info::end_true_args_size, ggc_alloc(), and NULL.
Referenced by scan_trace().
◆ operator!=()
◆ operator==()
More efficient comparisons that don't call targetm.dwarf_register_span unnecessarily. These cfa_reg vs. rtx comparisons should be done at least for call-saved REGs that might not be CFA related (like stack pointer, hard frame pointer or DRAP registers are), in other cases it is just a compile time and memory optimization.
References dwf_cfa_reg(), dwf_regno(), and cfa_reg::reg.
◆ output_cfa_loc()
|
static |
This routine will generate the correct assembly data for a location description based on a cfi entry with a complex address.
References dw2_asm_output_data(), dw2_asm_output_data_uleb128(), DWARF2_FRAME_REG_OUT, ggc_alloc(), NULL, output_loc_sequence(), r, and size_of_locs().
Referenced by output_cfi().
◆ output_cfa_loc_raw()
|
static |
Similar, but used for .cfi_escape.
References asm_out_file, dw2_asm_output_data_uleb128_raw(), DWARF2_FRAME_REG_OUT, fputc(), ggc_alloc(), output_loc_sequence_raw(), r, and size_of_locs().
Referenced by output_cfi_directive().
◆ output_cfi()
| void output_cfi | ( | dw_cfi_ref | cfi, |
| dw_fde_ref | fde, | ||
| int | for_eh ) |
Output a Call Frame Information opcode and its operand(s).
References ASM_PREFERRED_EH_DATA_FORMAT, div_data_align(), dw2_asm_output_addr(), dw2_asm_output_data(), dw2_asm_output_data_sleb128(), dw2_asm_output_data_uleb128(), dw2_asm_output_delta(), dw2_asm_output_encoded_addr_rtx(), dw_fde_node::dw_fde_current_label, DWARF2_ADDR_SIZE, DWARF2_FRAME_REG_OUT, dwarf_cfi_name(), gcc_unreachable, ggc_alloc(), HOST_WIDE_INT_PRINT_HEX, NULL, output_cfa_loc(), and r.
Referenced by output_call_frame_info(), and output_fde().
◆ output_cfi_directive()
| void output_cfi_directive | ( | FILE * | f, |
| dw_cfi_ref | cfi ) |
Similar, but do it via assembler directives instead.
References ASM_COMMENT_START, asm_out_file, dw2_asm_output_data_uleb128_raw(), DWARF2_FRAME_REG_OUT, fputc(), gcc_assert, gcc_unreachable, ggc_alloc(), HOST_WIDE_INT_PRINT_DEC, output_cfa_loc_raw(), and r.
Referenced by connect_traces(), dump_cfi_row(), dwarf2out_emit_cfi(), and rtx_writer::print_rtx_operand_code_0().
◆ queue_reg_save()
|
static |
Add an entry to QUEUED_REG_SAVES saying that REG is now saved at SREG, or if SREG is NULL then it is saved at OFFSET to the CFA.
References compare_reg_or_pc(), FOR_EACH_VEC_ELT, ggc_alloc(), i, offset, queued_reg_saves, queued_reg_save::reg, and cfa_reg::reg.
Referenced by dwarf2out_frame_debug_expr().
◆ record_reg_saved_in_reg()
Record SRC as being saved in DEST. DEST may be null to delete an existing entry. SRC may be a register or PC_RTX.
References compare_reg_or_pc(), cur_trace, FOR_EACH_VEC_ELT, i, NULL, reg_saved_in_data::orig_reg, dw_trace_info::regs_saved_in_regs, and reg_saved_in_data::saved_in_reg.
Referenced by dwarf2out_flush_queued_reg_saves(), dwarf2out_frame_debug_cfa_register(), and initial_return_save().
◆ reg_save()
Add the CFI for saving a register. REG is the CFA column number. If SREG is INVALID_REGISTER, the register is saved at OFFSET from the CFA; otherwise it is saved in SREG.
References add_cfi(), build_cfa_aligned_loc(), build_cfa_loc(), build_span_loc(), dw_cfi_row::cfa, cfun, cur_row, gcc_unreachable, ggc_alloc(), INVALID_REGNUM, need_data_align_sf_opcode(), new_cfi(), NULL, offset, dw_fde_node::stack_realign, dw_fde_node::stack_realignment, and update_row_reg_save().
Referenced by dwarf2out_flush_queued_reg_saves(), dwarf2out_frame_debug_cfa_offset(), dwarf2out_frame_debug_cfa_register(), and initial_return_save().
◆ reg_saved_in()
What register, if any, is currently saved in REG?
References cur_trace, FOR_EACH_VEC_ELT, ggc_alloc(), i, NULL_RTX, queued_reg_saves, queued_reg_save::reg, cfa_reg::reg, REGNO, dw_trace_info::regs_saved_in_regs, and queued_reg_save::saved_reg.
Referenced by dwarf2out_frame_debug_expr().
◆ save_point_p()
References ggc_alloc(), inside_basic_block_p(), LABEL_P, NOTE_KIND, and NOTE_P.
Referenced by create_pseudo_cfg(), and scan_trace().
◆ scan_insn_after()
A subroutine of scan_trace. Do what needs to be done "after" INSN.
References dwarf2out_frame_debug(), notice_args_size(), and RTX_FRAME_RELATED_P.
Referenced by scan_trace().
◆ scan_trace()
|
static |
Scan the trace beginning at INSN and create the CFI notes for the instructions therein.
References add_cfi_insn, any_cfis_emitted, BARRIER_P, can_throw_internal(), dw_cfi_row::cfa, cfun, clobbers_queued_reg_save(), copy_cfi_row(), create_trace_edges(), cur_cfa, cur_row, cur_trace, DEBUG_INSN_P, def_cfa_1(), DEFAULT_INCOMING_FRAME_SP_OFFSET, dump_file, dwarf2out_flush_queued_reg_saves(), dw_trace_info::end_true_args_size, find_reg_note(), gcc_assert, GET_CODE, ggc_alloc(), i, INCOMING_FRAME_SP_OFFSET, inside_basic_block_p(), INSN_ANNULLED_BRANCH_P, INSN_FROM_TARGET_P, INSN_UID(), JUMP_P, maybe_record_trace_start(), NEXT_INSN(), NONJUMP_INSN_P, NOTE_KIND, NOTE_P, notice_eh_throw(), NULL, PATTERN(), queued_reg_saves, dw_cfi_row::reg_save, RTX_FRAME_RELATED_P, rtx_name, save_point_p(), scan_insn_after(), and vec_safe_copy().
Referenced by create_cfi_notes().
◆ update_row_reg_save()
|
static |
Perform ROW->REG_SAVE[COLUMN] = CFI. CFI may be null, indicating that the register column is no longer saved.
References ggc_alloc(), vec_safe_grow_cleared(), and vec_safe_length().
Referenced by dwarf2out_frame_debug_cfa_expression(), dwarf2out_frame_debug_cfa_restore(), dwarf2out_frame_debug_cfa_val_expression(), and reg_save().
Variable Documentation
◆ add_cfi_insn
|
static |
The insn after which a new CFI note should be emitted.
Referenced by add_cfi(), connect_traces(), dwarf2cfi_cc_finalize(), and scan_trace().
◆ add_cfi_vec
|
static |
When non-null, add_cfi will add the CFI to this vector.
Referenced by add_cfi(), create_cie_data(), and dwarf2cfi_cc_finalize().
◆ any_cfis_emitted
|
static |
True if any CFI directives were emitted at the current insn.
Referenced by add_cfi(), and scan_trace().
◆ cie_cfi_row
|
static |
The state of the first row of the FDE table, which includes the state provided by the CIE.
Referenced by connect_traces(), create_cie_data(), and create_pseudo_cfg().
◆ cie_cfi_vec
| cfi_vec cie_cfi_vec |
A vector of call frame insns for the CIE.
Referenced by convert_cfa_to_fb_loc_list(), create_cie_data(), execute_dwarf2_frame(), and output_call_frame_info().
◆ cie_return_save
|
static |
Referenced by create_cie_data(), and create_pseudo_cfg().
◆ cur_cfa
|
static |
A copy of the current CFA, for use during the processing of a single insn.
Referenced by dwarf2cfi_cc_finalize(), dwarf2out_frame_debug_adjust_cfa(), dwarf2out_frame_debug_cfa_offset(), dwarf2out_frame_debug_def_cfa(), dwarf2out_frame_debug_expr(), notice_args_size(), and scan_trace().
◆ cur_row
|
static |
The current, i.e. most recently generated, row of the CFI table.
Referenced by create_cie_data(), def_cfa_1(), dwarf2cfi_cc_finalize(), dwarf2out_frame_debug_cfa_expression(), dwarf2out_frame_debug_cfa_restore(), dwarf2out_frame_debug_cfa_toggle_ra_mangle(), dwarf2out_frame_debug_cfa_val_expression(), dwarf2out_frame_debug_cfa_window_save(), initial_return_save(), maybe_record_trace_start(), maybe_record_trace_start_abnormal(), reg_save(), and scan_trace().
◆ cur_trace
|
static |
The current instruction trace.
Referenced by clobbers_queued_reg_save(), create_cie_data(), def_cfa_1(), dwarf2cfi_cc_finalize(), dwarf2out_frame_debug_expr(), maybe_record_trace_start(), maybe_record_trace_start_abnormal(), notice_args_size(), notice_eh_throw(), record_reg_saved_in_reg(), reg_saved_in(), and scan_trace().
◆ dw_frame_pointer_regnum
Referenced by dwarf2out_frame_debug_expr(), and execute_dwarf2_frame().
◆ dw_stack_pointer_regnum
Short-hand for commonly used register numbers.
Referenced by create_cie_data(), dwarf2out_frame_debug_expr(), maybe_record_trace_start_abnormal(), and notice_args_size().
◆ dwarf2out_cfi_label_num
Referenced by add_cfis_to_fde(), and dwarf2out_cfi_label().
◆ queued_reg_saves
|
static |
◆ saved_do_cfi_asm
Save the result of dwarf2out_do_frame across PCH. This variable is tri-state, with 0 unset, >0 true, <0 false.
Referenced by dwarf2out_do_cfi_asm(), and dwarf2out_do_frame().
◆ trace_index
|
static |
Referenced by create_pseudo_cfg(), execute_dwarf2_frame(), and get_trace_info().
◆ trace_info
|
static |
The variables making up the pseudo-cfg, as described above.
Referenced by connect_traces(), create_cfi_notes(), create_pseudo_cfg(), and execute_dwarf2_frame().
◆ trace_work_list
|
static |
Referenced by create_cfi_notes(), and maybe_record_trace_start().
