mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-09 04:21:49 +08:00
c7defc5386
This patch adds support in GAS to create generic GAS instructions (a.k.a., the ginsn) for the x86 backend (AMD64 ABI only at this time). Using this ginsn infrastructure, GAS can then synthesize CFI for hand-written asm for x86_64. A ginsn is a target-independent representation of the machine instructions. One machine instruction may need one or more ginsn. This patch also adds skeleton support for printing ginsn in the listing output for debugging purposes. Since the current use-case of ginsn is to synthesize CFI, the x86 target needs to generate ginsns necessary for the following machine instructions only: - All change of flow instructions, including all conditional and unconditional branches, call and return from functions. - All register saves and unsaves to the stack. - All instructions affecting the two registers that could potentially be used as the base register for CFA tracking. For SCFI, the base register for CFA tracking is limited to REG_SP and REG_FP only for now. The representation of ginsn is kept simple: - GAS instruction has GINSN_NUM_SRC_OPNDS (defined to be 2 at this time) number of source operands and one destination operand at this time. - GAS instruction uses DWARF register numbers in its representation and does not track register size. - GAS instructions carry location information (file name and line number). - GAS instructions are ID's with a natural number in order of their addtion to the list. This can be used as a proxy for the static program order of the corresponding machine instructions. Note that, GAS instruction (ginsn) format does not support GINSN_TYPE_PUSH and GINSN_TYPE_POP. Some architectures, like aarch64, do not have push and pop instructions, but rather STP/LDP/STR/LDR etc. instructions. Further these instructions have a variety of addressing modes, like offset, pre-indexing and post-indexing etc. Among other things, one of differences in these addressing modes is _when_ the addr register is updated with the result of the address calculation: before or after the memory operation. To best support such needs, the generic instructions like GINSN_TYPE_LOAD, GINSN_TYPE_STORE together with GINSN_TYPE_ADD, and GINSN_TYPE_SUB may be used. The functionality provided in ginsn.c and scfi.c is compiled in when a target defines TARGET_USE_SCFI and TARGET_USE_GINSN. This can be revisited later when there are other use-cases of creating ginsn's in GAS, apart from the current use-case of synthesizing CFI for hand-written asm. Support is added only for System V AMD64 ABI for ELF at this time. If the user enables SCFI with --32, GAS issues an error: "Fatal error: SCFI is not supported for this ABI" For synthesizing (DWARF) CFI, the SCFI machinery requires the programmer to adhere to some pre-requisites for their asm: - Hand-written asm block must begin with a .type foo, @function It is highly recommended to, additionally, also ensure that: - Hand-written asm block ends with a .size foo, .-foo The SCFI machinery encodes some rules which align with the standard calling convention specified by the ABI. Apart from the rules, the SCFI machinery employs some heuristics. For example: - The base register for CFA tracking may be either REG_SP or REG_FP. - If the base register for CFA tracking is REG_SP, the precise amount of stack usage (and hence, the value of REG_SP) must be known at all times. - If using dynamic stack allocation, the function must switch to FP-based CFA. This means using instructions like the following (in AMD64) in prologue: pushq %rbp movq %rsp, %rbp and analogous instructions in epilogue. - Save and Restore of callee-saved registers must be symmetrical. However, the SCFI machinery at this time only warns if any such asymmetry is seen. These heuristics/rules are architecture-independent and are meant to employed for all architectures/ABIs using SCFI in the future. gas/ * Makefile.am: Add new files. * Makefile.in: Regenerated. * as.c (defined): Handle documentation and listing option for ginsns and SCFI. * config/obj-elf.c (obj_elf_size): Invoke ginsn_data_end. (obj_elf_type): Invoke ginsn_data_begin. * config/tc-i386.c (x86_scfi_callee_saved_p): New function. (ginsn_prefix_66H_p): Likewise. (ginsn_dw2_regnum): Likewise. (x86_ginsn_addsub_reg_mem): Likewise. (x86_ginsn_addsub_mem_reg): Likewise. (x86_ginsn_alu_imm): Likewise. (x86_ginsn_move): Likewise. (x86_ginsn_lea): Likewise. (x86_ginsn_jump): Likewise. (x86_ginsn_jump_cond): Likewise. (x86_ginsn_enter): Likewise. (x86_ginsn_safe_to_skip): Likewise. (x86_ginsn_unhandled): Likewise. (x86_ginsn_new): New functionality to generate ginsns. (md_assemble): Invoke x86_ginsn_new. (s_insn): Likewise. (i386_target_format): Add hard error for usage of SCFI with non AMD64 ABIs. * config/tc-i386.h (TARGET_USE_GINSN): New definition. (TARGET_USE_SCFI): Likewise. (SCFI_MAX_REG_ID): Likewise. (REG_FP): Likewise. (REG_SP): Likewise. (SCFI_INIT_CFA_OFFSET): Likewise. (SCFI_CALLEE_SAVED_REG_P): Likewise. (x86_scfi_callee_saved_p): Likewise. * gas/listing.h (LISTING_GINSN_SCFI): New define for ginsn and SCFI. * gas/read.c (read_a_source_file): Close SCFI processing at end of file read. * gas/scfidw2gen.c (scfi_process_cfi_label): Add implementation. (scfi_process_cfi_signal_frame): Likewise. * subsegs.h (struct frch_ginsn_data): New forward declaration. (struct frchain): New member for ginsn data. * gas/subsegs.c (subseg_set_rest): Initialize the new member. * symbols.c (colon): Invoke ginsn_frob_label to convey user-defined labels to ginsn infrastructure. * ginsn.c: New file. * ginsn.h: New file. * scfi.c: New file. * scfi.h: New file.
112 lines
3.8 KiB
C
112 lines
3.8 KiB
C
/* subsegs.h -> subsegs.c
|
|
Copyright (C) 1987-2024 Free Software Foundation, Inc.
|
|
|
|
This file is part of GAS, the GNU Assembler.
|
|
|
|
GAS 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.
|
|
|
|
GAS 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 GAS; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
|
|
02110-1301, USA. */
|
|
|
|
/*
|
|
* For every sub-segment the user mentions in the ASsembler program,
|
|
* we make one struct frchain. Each sub-segment has exactly one struct frchain
|
|
* and vice versa.
|
|
*
|
|
* Struct frchain's are forward chained (in ascending order of sub-segment
|
|
* code number). The chain runs through frch_next of each subsegment.
|
|
* This makes it hard to find a subsegment's frags
|
|
* if programmer uses a lot of them. Most programs only use text0 and
|
|
* data0, so they don't suffer. At least this way:
|
|
* (1) There are no "arbitrary" restrictions on how many subsegments
|
|
* can be programmed;
|
|
* (2) Subsegments' frchain-s are (later) chained together in the order in
|
|
* which they are emitted for object file viz text then data.
|
|
*
|
|
* From each struct frchain dangles a chain of struct frags. The frags
|
|
* represent code fragments, for that sub-segment, forward chained.
|
|
*/
|
|
|
|
#include "obstack.h"
|
|
|
|
struct frch_cfi_data;
|
|
struct frch_ginsn_data;
|
|
|
|
struct frchain /* control building of a frag chain */
|
|
{ /* FRCH = FRagment CHain control */
|
|
struct frag *frch_root; /* 1st struct frag in chain, or NULL */
|
|
struct frag *frch_last; /* last struct frag in chain, or NULL */
|
|
struct frchain *frch_next; /* next in chain of struct frchain-s */
|
|
subsegT frch_subseg; /* subsegment number of this chain */
|
|
fixS *fix_root; /* Root of fixups for this subsegment. */
|
|
fixS *fix_tail; /* Last fixup for this subsegment. */
|
|
struct obstack frch_obstack; /* for objects in this frag chain */
|
|
fragS *frch_frag_now; /* frag_now for this subsegment */
|
|
struct frch_cfi_data *frch_cfi_data;
|
|
struct frch_ginsn_data *frch_ginsn_data;
|
|
};
|
|
|
|
typedef struct frchain frchainS;
|
|
|
|
/* Frchain we are assembling into now. That is, the current segment's
|
|
frag chain, even if it contains no (complete) frags. */
|
|
extern frchainS *frchain_now;
|
|
|
|
typedef struct segment_info_struct {
|
|
frchainS *frchainP;
|
|
unsigned int hadone : 1;
|
|
|
|
/* This field is set if this is a .bss section which does not really
|
|
have any contents. Once upon a time a .bss section did not have
|
|
any frags, but that is no longer true. This field prevent the
|
|
SEC_HAS_CONTENTS flag from being set for the section even if
|
|
there are frags. */
|
|
unsigned int bss : 1;
|
|
|
|
/* Fixups for this segment. This is only valid after the frchains
|
|
are run together. */
|
|
fixS *fix_root;
|
|
fixS *fix_tail;
|
|
|
|
/* NULL, or pointer to the gas symbol that is the section symbol for
|
|
this section. */
|
|
symbolS *sym;
|
|
|
|
/* Used by dwarf2dbg.c for this section's line table entries. */
|
|
void *dwarf2_line_seg;
|
|
|
|
union {
|
|
/* Current size of section holding stabs strings. */
|
|
unsigned long stab_string_size;
|
|
/* Initial frag for ELF. */
|
|
char *p;
|
|
}
|
|
stabu;
|
|
|
|
#ifdef NEED_LITERAL_POOL
|
|
unsigned long literal_pool_size;
|
|
#endif
|
|
|
|
#ifdef TC_SEGMENT_INFO_TYPE
|
|
TC_SEGMENT_INFO_TYPE tc_segment_info_data;
|
|
#endif
|
|
} segment_info_type;
|
|
|
|
|
|
#define seg_info(sec) \
|
|
((segment_info_type *) bfd_section_userdata (sec))
|
|
|
|
extern symbolS *section_symbol (segT);
|
|
|
|
extern void subsegs_print_statistics (FILE *);
|