/* Data structure definitions for a generic GCC target.
|
/* Data structure definitions for a generic GCC target.
|
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This program is free software; you can redistribute it and/or modify it
|
This program is free software; you can redistribute it and/or modify it
|
under the terms of the GNU General Public License as published by the
|
under the terms of the GNU General Public License as published by the
|
Free Software Foundation; either version 3, or (at your option) any
|
Free Software Foundation; either version 3, or (at your option) any
|
later version.
|
later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; see the file COPYING3. If not see
|
along with this program; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>.
|
<http://www.gnu.org/licenses/>.
|
|
|
In other words, you are welcome to use, share and improve this program.
|
In other words, you are welcome to use, share and improve this program.
|
You are forbidden to forbid anyone else to use, share and improve
|
You are forbidden to forbid anyone else to use, share and improve
|
what you give them. Help stamp out software-hoarding! */
|
what you give them. Help stamp out software-hoarding! */
|
|
|
|
|
/* This file contains a data structure that describes a GCC target.
|
/* This file contains a data structure that describes a GCC target.
|
At present it is incomplete, but in future it should grow to
|
At present it is incomplete, but in future it should grow to
|
contain most or all target machine and target O/S specific
|
contain most or all target machine and target O/S specific
|
information.
|
information.
|
|
|
This structure has its initializer declared in target-def.h in the
|
This structure has its initializer declared in target-def.h in the
|
form of large macro TARGET_INITIALIZER that expands to many smaller
|
form of large macro TARGET_INITIALIZER that expands to many smaller
|
macros.
|
macros.
|
|
|
The smaller macros each initialize one component of the structure,
|
The smaller macros each initialize one component of the structure,
|
and each has a default. Each target should have a file that
|
and each has a default. Each target should have a file that
|
includes target.h and target-def.h, and overrides any inappropriate
|
includes target.h and target-def.h, and overrides any inappropriate
|
defaults by undefining the relevant macro and defining a suitable
|
defaults by undefining the relevant macro and defining a suitable
|
replacement. That file should then contain the definition of
|
replacement. That file should then contain the definition of
|
"targetm" like so:
|
"targetm" like so:
|
|
|
struct gcc_target targetm = TARGET_INITIALIZER;
|
struct gcc_target targetm = TARGET_INITIALIZER;
|
|
|
Doing things this way allows us to bring together everything that
|
Doing things this way allows us to bring together everything that
|
defines a GCC target. By supplying a default that is appropriate
|
defines a GCC target. By supplying a default that is appropriate
|
to most targets, we can easily add new items without needing to
|
to most targets, we can easily add new items without needing to
|
edit dozens of target configuration files. It should also allow us
|
edit dozens of target configuration files. It should also allow us
|
to gradually reduce the amount of conditional compilation that is
|
to gradually reduce the amount of conditional compilation that is
|
scattered throughout GCC. */
|
scattered throughout GCC. */
|
|
|
#ifndef GCC_TARGET_H
|
#ifndef GCC_TARGET_H
|
#define GCC_TARGET_H
|
#define GCC_TARGET_H
|
|
|
#include "tm.h"
|
#include "tm.h"
|
#include "insn-modes.h"
|
#include "insn-modes.h"
|
|
|
/* Types used by the record_gcc_switches() target function. */
|
/* Types used by the record_gcc_switches() target function. */
|
typedef enum
|
typedef enum
|
{
|
{
|
SWITCH_TYPE_PASSED, /* A switch passed on the command line. */
|
SWITCH_TYPE_PASSED, /* A switch passed on the command line. */
|
SWITCH_TYPE_ENABLED, /* An option that is currently enabled. */
|
SWITCH_TYPE_ENABLED, /* An option that is currently enabled. */
|
SWITCH_TYPE_DESCRIPTIVE, /* Descriptive text, not a switch or option. */
|
SWITCH_TYPE_DESCRIPTIVE, /* Descriptive text, not a switch or option. */
|
SWITCH_TYPE_LINE_START, /* Please emit any necessary text at the start of a line. */
|
SWITCH_TYPE_LINE_START, /* Please emit any necessary text at the start of a line. */
|
SWITCH_TYPE_LINE_END /* Please emit a line terminator. */
|
SWITCH_TYPE_LINE_END /* Please emit a line terminator. */
|
}
|
}
|
print_switch_type;
|
print_switch_type;
|
|
|
typedef int (* print_switch_fn_type) (print_switch_type, const char *);
|
typedef int (* print_switch_fn_type) (print_switch_type, const char *);
|
|
|
/* An example implementation for ELF targets. Defined in varasm.c */
|
/* An example implementation for ELF targets. Defined in varasm.c */
|
extern int elf_record_gcc_switches (print_switch_type type, const char *);
|
extern int elf_record_gcc_switches (print_switch_type type, const char *);
|
|
|
/* Some places still assume that all pointer or address modes are the
|
/* Some places still assume that all pointer or address modes are the
|
standard Pmode and ptr_mode. These optimizations become invalid if
|
standard Pmode and ptr_mode. These optimizations become invalid if
|
the target actually supports multiple different modes. For now,
|
the target actually supports multiple different modes. For now,
|
we disable such optimizations on such targets, using this function. */
|
we disable such optimizations on such targets, using this function. */
|
extern bool target_default_pointer_address_modes_p (void);
|
extern bool target_default_pointer_address_modes_p (void);
|
|
|
struct stdarg_info;
|
struct stdarg_info;
|
struct spec_info_def;
|
struct spec_info_def;
|
|
|
/* The struct used by the secondary_reload target hook. */
|
/* The struct used by the secondary_reload target hook. */
|
typedef struct secondary_reload_info
|
typedef struct secondary_reload_info
|
{
|
{
|
/* icode is actually an enum insn_code, but we don't want to force every
|
/* icode is actually an enum insn_code, but we don't want to force every
|
file that includes target.h to include optabs.h . */
|
file that includes target.h to include optabs.h . */
|
int icode;
|
int icode;
|
int extra_cost; /* Cost for using (a) scratch register(s) to be taken
|
int extra_cost; /* Cost for using (a) scratch register(s) to be taken
|
into account by copy_cost. */
|
into account by copy_cost. */
|
/* The next two members are for the use of the backward
|
/* The next two members are for the use of the backward
|
compatibility hook. */
|
compatibility hook. */
|
struct secondary_reload_info *prev_sri;
|
struct secondary_reload_info *prev_sri;
|
int t_icode; /* Actually an enum insn_code - see above. */
|
int t_icode; /* Actually an enum insn_code - see above. */
|
} secondary_reload_info;
|
} secondary_reload_info;
|
|
|
/* This is defined in sched-int.h . */
|
/* This is defined in sched-int.h . */
|
struct _dep;
|
struct _dep;
|
|
|
/* This is defined in ddg.h . */
|
/* This is defined in ddg.h . */
|
struct ddg;
|
struct ddg;
|
|
|
/* Assembler instructions for creating various kinds of integer object. */
|
/* Assembler instructions for creating various kinds of integer object. */
|
|
|
struct asm_int_op
|
struct asm_int_op
|
{
|
{
|
const char *hi;
|
const char *hi;
|
const char *si;
|
const char *si;
|
const char *di;
|
const char *di;
|
const char *ti;
|
const char *ti;
|
};
|
};
|
|
|
/* The target structure. This holds all the backend hooks. */
|
/* The target structure. This holds all the backend hooks. */
|
|
|
struct gcc_target
|
struct gcc_target
|
{
|
{
|
/* Functions that output assembler for the target. */
|
/* Functions that output assembler for the target. */
|
struct asm_out
|
struct asm_out
|
{
|
{
|
/* Opening and closing parentheses for asm expression grouping. */
|
/* Opening and closing parentheses for asm expression grouping. */
|
const char *open_paren, *close_paren;
|
const char *open_paren, *close_paren;
|
|
|
/* Assembler instructions for creating various kinds of integer object. */
|
/* Assembler instructions for creating various kinds of integer object. */
|
const char *byte_op;
|
const char *byte_op;
|
struct asm_int_op aligned_op, unaligned_op;
|
struct asm_int_op aligned_op, unaligned_op;
|
|
|
/* Try to output the assembler code for an integer object whose
|
/* Try to output the assembler code for an integer object whose
|
value is given by X. SIZE is the size of the object in bytes and
|
value is given by X. SIZE is the size of the object in bytes and
|
ALIGNED_P indicates whether it is aligned. Return true if
|
ALIGNED_P indicates whether it is aligned. Return true if
|
successful. Only handles cases for which BYTE_OP, ALIGNED_OP
|
successful. Only handles cases for which BYTE_OP, ALIGNED_OP
|
and UNALIGNED_OP are NULL. */
|
and UNALIGNED_OP are NULL. */
|
bool (* integer) (rtx x, unsigned int size, int aligned_p);
|
bool (* integer) (rtx x, unsigned int size, int aligned_p);
|
|
|
/* Output code that will globalize a label. */
|
/* Output code that will globalize a label. */
|
void (* globalize_label) (FILE *, const char *);
|
void (* globalize_label) (FILE *, const char *);
|
|
|
/* Output code that will globalize a declaration. */
|
/* Output code that will globalize a declaration. */
|
void (* globalize_decl_name) (FILE *, tree);
|
void (* globalize_decl_name) (FILE *, tree);
|
|
|
/* Output code that will emit a label for unwind info, if this
|
/* Output code that will emit a label for unwind info, if this
|
target requires such labels. Second argument is the decl the
|
target requires such labels. Second argument is the decl the
|
unwind info is associated with, third is a boolean: true if
|
unwind info is associated with, third is a boolean: true if
|
this is for exception handling, fourth is a boolean: true if
|
this is for exception handling, fourth is a boolean: true if
|
this is only a placeholder for an omitted FDE. */
|
this is only a placeholder for an omitted FDE. */
|
void (* unwind_label) (FILE *, tree, int, int);
|
void (* unwind_label) (FILE *, tree, int, int);
|
|
|
/* Output code that will emit a label to divide up the exception
|
/* Output code that will emit a label to divide up the exception
|
table. */
|
table. */
|
void (* except_table_label) (FILE *);
|
void (* except_table_label) (FILE *);
|
|
|
/* Emit any directives required to unwind this instruction. */
|
/* Emit any directives required to unwind this instruction. */
|
void (* unwind_emit) (FILE *, rtx);
|
void (* unwind_emit) (FILE *, rtx);
|
|
|
/* Output an internal label. */
|
/* Output an internal label. */
|
void (* internal_label) (FILE *, const char *, unsigned long);
|
void (* internal_label) (FILE *, const char *, unsigned long);
|
|
|
/* Emit a ttype table reference to a typeinfo object. */
|
/* Emit a ttype table reference to a typeinfo object. */
|
bool (* ttype) (rtx);
|
bool (* ttype) (rtx);
|
|
|
/* Emit an assembler directive to set visibility for the symbol
|
/* Emit an assembler directive to set visibility for the symbol
|
associated with the tree decl. */
|
associated with the tree decl. */
|
void (* visibility) (tree, int);
|
void (* visibility) (tree, int);
|
|
|
/* Output the assembler code for entry to a function. */
|
/* Output the assembler code for entry to a function. */
|
void (* function_prologue) (FILE *, HOST_WIDE_INT);
|
void (* function_prologue) (FILE *, HOST_WIDE_INT);
|
|
|
/* Output the assembler code for end of prologue. */
|
/* Output the assembler code for end of prologue. */
|
void (* function_end_prologue) (FILE *);
|
void (* function_end_prologue) (FILE *);
|
|
|
/* Output the assembler code for start of epilogue. */
|
/* Output the assembler code for start of epilogue. */
|
void (* function_begin_epilogue) (FILE *);
|
void (* function_begin_epilogue) (FILE *);
|
|
|
/* Output the assembler code for function exit. */
|
/* Output the assembler code for function exit. */
|
void (* function_epilogue) (FILE *, HOST_WIDE_INT);
|
void (* function_epilogue) (FILE *, HOST_WIDE_INT);
|
|
|
/* Initialize target-specific sections. */
|
/* Initialize target-specific sections. */
|
void (* init_sections) (void);
|
void (* init_sections) (void);
|
|
|
/* Tell assembler to change to section NAME with attributes FLAGS.
|
/* Tell assembler to change to section NAME with attributes FLAGS.
|
If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with
|
If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with
|
which this section is associated. */
|
which this section is associated. */
|
void (* named_section) (const char *name, unsigned int flags, tree decl);
|
void (* named_section) (const char *name, unsigned int flags, tree decl);
|
|
|
/* Return a mask describing how relocations should be treated when
|
/* Return a mask describing how relocations should be treated when
|
selecting sections. Bit 1 should be set if global relocations
|
selecting sections. Bit 1 should be set if global relocations
|
should be placed in a read-write section; bit 0 should be set if
|
should be placed in a read-write section; bit 0 should be set if
|
local relocations should be placed in a read-write section. */
|
local relocations should be placed in a read-write section. */
|
int (*reloc_rw_mask) (void);
|
int (*reloc_rw_mask) (void);
|
|
|
/* Return a section for EXP. It may be a DECL or a constant. RELOC
|
/* Return a section for EXP. It may be a DECL or a constant. RELOC
|
is nonzero if runtime relocations must be applied; bit 1 will be
|
is nonzero if runtime relocations must be applied; bit 1 will be
|
set if the runtime relocations require non-local name resolution.
|
set if the runtime relocations require non-local name resolution.
|
ALIGN is the required alignment of the data. */
|
ALIGN is the required alignment of the data. */
|
section *(* select_section) (tree, int, unsigned HOST_WIDE_INT);
|
section *(* select_section) (tree, int, unsigned HOST_WIDE_INT);
|
|
|
/* Return a section for X. MODE is X's mode and ALIGN is its
|
/* Return a section for X. MODE is X's mode and ALIGN is its
|
alignment in bits. */
|
alignment in bits. */
|
section *(* select_rtx_section) (enum machine_mode, rtx,
|
section *(* select_rtx_section) (enum machine_mode, rtx,
|
unsigned HOST_WIDE_INT);
|
unsigned HOST_WIDE_INT);
|
|
|
/* Select a unique section name for DECL. RELOC is the same as
|
/* Select a unique section name for DECL. RELOC is the same as
|
for SELECT_SECTION. */
|
for SELECT_SECTION. */
|
void (* unique_section) (tree, int);
|
void (* unique_section) (tree, int);
|
|
|
/* Return the readonly data section associated with function DECL. */
|
/* Return the readonly data section associated with function DECL. */
|
section *(* function_rodata_section) (tree);
|
section *(* function_rodata_section) (tree);
|
|
|
/* Output a constructor for a symbol with a given priority. */
|
/* Output a constructor for a symbol with a given priority. */
|
void (* constructor) (rtx, int);
|
void (* constructor) (rtx, int);
|
|
|
/* Output a destructor for a symbol with a given priority. */
|
/* Output a destructor for a symbol with a given priority. */
|
void (* destructor) (rtx, int);
|
void (* destructor) (rtx, int);
|
|
|
/* Output the assembler code for a thunk function. THUNK_DECL is the
|
/* Output the assembler code for a thunk function. THUNK_DECL is the
|
declaration for the thunk function itself, FUNCTION is the decl for
|
declaration for the thunk function itself, FUNCTION is the decl for
|
the target function. DELTA is an immediate constant offset to be
|
the target function. DELTA is an immediate constant offset to be
|
added to THIS. If VCALL_OFFSET is nonzero, the word at
|
added to THIS. If VCALL_OFFSET is nonzero, the word at
|
*(*this + vcall_offset) should be added to THIS. */
|
*(*this + vcall_offset) should be added to THIS. */
|
void (* output_mi_thunk) (FILE *file, tree thunk_decl,
|
void (* output_mi_thunk) (FILE *file, tree thunk_decl,
|
HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
|
HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
|
tree function_decl);
|
tree function_decl);
|
|
|
/* Determine whether output_mi_thunk would succeed. */
|
/* Determine whether output_mi_thunk would succeed. */
|
/* ??? Ideally, this hook would not exist, and success or failure
|
/* ??? Ideally, this hook would not exist, and success or failure
|
would be returned from output_mi_thunk directly. But there's
|
would be returned from output_mi_thunk directly. But there's
|
too much undo-able setup involved in invoking output_mi_thunk.
|
too much undo-able setup involved in invoking output_mi_thunk.
|
Could be fixed by making output_mi_thunk emit rtl instead of
|
Could be fixed by making output_mi_thunk emit rtl instead of
|
text to the output file. */
|
text to the output file. */
|
bool (* can_output_mi_thunk) (const_tree thunk_decl, HOST_WIDE_INT delta,
|
bool (* can_output_mi_thunk) (const_tree thunk_decl, HOST_WIDE_INT delta,
|
HOST_WIDE_INT vcall_offset,
|
HOST_WIDE_INT vcall_offset,
|
const_tree function_decl);
|
const_tree function_decl);
|
|
|
/* Output any boilerplate text needed at the beginning of a
|
/* Output any boilerplate text needed at the beginning of a
|
translation unit. */
|
translation unit. */
|
void (*file_start) (void);
|
void (*file_start) (void);
|
|
|
/* Output any boilerplate text needed at the end of a
|
/* Output any boilerplate text needed at the end of a
|
translation unit. */
|
translation unit. */
|
void (*file_end) (void);
|
void (*file_end) (void);
|
|
|
/* Output any boilerplate text needed at the beginning of an
|
/* Output any boilerplate text needed at the beginning of an
|
LTO output stream. */
|
LTO output stream. */
|
void (*lto_start) (void);
|
void (*lto_start) (void);
|
|
|
/* Output any boilerplate text needed at the end of an
|
/* Output any boilerplate text needed at the end of an
|
LTO output stream. */
|
LTO output stream. */
|
void (*lto_end) (void);
|
void (*lto_end) (void);
|
|
|
/* Output any boilerplace text needed at the end of a
|
/* Output any boilerplace text needed at the end of a
|
translation unit before debug and unwind info is emitted. */
|
translation unit before debug and unwind info is emitted. */
|
void (*code_end) (void);
|
void (*code_end) (void);
|
|
|
/* Output an assembler pseudo-op to declare a library function name
|
/* Output an assembler pseudo-op to declare a library function name
|
external. */
|
external. */
|
void (*external_libcall) (rtx);
|
void (*external_libcall) (rtx);
|
|
|
/* Output an assembler directive to mark decl live. This instructs
|
/* Output an assembler directive to mark decl live. This instructs
|
linker to not dead code strip this symbol. */
|
linker to not dead code strip this symbol. */
|
void (*mark_decl_preserved) (const char *);
|
void (*mark_decl_preserved) (const char *);
|
|
|
/* Output a record of the command line switches that have been passed. */
|
/* Output a record of the command line switches that have been passed. */
|
print_switch_fn_type record_gcc_switches;
|
print_switch_fn_type record_gcc_switches;
|
/* The name of the section that the example ELF implementation of
|
/* The name of the section that the example ELF implementation of
|
record_gcc_switches will use to store the information. Target
|
record_gcc_switches will use to store the information. Target
|
specific versions of record_gcc_switches may or may not use
|
specific versions of record_gcc_switches may or may not use
|
this information. */
|
this information. */
|
const char * record_gcc_switches_section;
|
const char * record_gcc_switches_section;
|
|
|
/* Output the definition of a section anchor. */
|
/* Output the definition of a section anchor. */
|
void (*output_anchor) (rtx);
|
void (*output_anchor) (rtx);
|
|
|
/* Output a DTP-relative reference to a TLS symbol. */
|
/* Output a DTP-relative reference to a TLS symbol. */
|
void (*output_dwarf_dtprel) (FILE *file, int size, rtx x);
|
void (*output_dwarf_dtprel) (FILE *file, int size, rtx x);
|
|
|
/* Some target machines need to postscan each insn after it is output. */
|
/* Some target machines need to postscan each insn after it is output. */
|
void (*final_postscan_insn) (FILE *, rtx, rtx *, int);
|
void (*final_postscan_insn) (FILE *, rtx, rtx *, int);
|
|
|
/* Emit the trampoline template. This hook may be NULL. */
|
/* Emit the trampoline template. This hook may be NULL. */
|
void (*trampoline_template) (FILE *);
|
void (*trampoline_template) (FILE *);
|
} asm_out;
|
} asm_out;
|
|
|
/* Functions relating to instruction scheduling. */
|
/* Functions relating to instruction scheduling. */
|
struct sched
|
struct sched
|
{
|
{
|
/* Given the current cost, COST, of an insn, INSN, calculate and
|
/* Given the current cost, COST, of an insn, INSN, calculate and
|
return a new cost based on its relationship to DEP_INSN through
|
return a new cost based on its relationship to DEP_INSN through
|
the dependence LINK. The default is to make no adjustment. */
|
the dependence LINK. The default is to make no adjustment. */
|
int (* adjust_cost) (rtx insn, rtx link, rtx dep_insn, int cost);
|
int (* adjust_cost) (rtx insn, rtx link, rtx dep_insn, int cost);
|
|
|
/* Adjust the priority of an insn as you see fit. Returns the new
|
/* Adjust the priority of an insn as you see fit. Returns the new
|
priority. */
|
priority. */
|
int (* adjust_priority) (rtx, int);
|
int (* adjust_priority) (rtx, int);
|
|
|
/* Function which returns the maximum number of insns that can be
|
/* Function which returns the maximum number of insns that can be
|
scheduled in the same machine cycle. This must be constant
|
scheduled in the same machine cycle. This must be constant
|
over an entire compilation. The default is 1. */
|
over an entire compilation. The default is 1. */
|
int (* issue_rate) (void);
|
int (* issue_rate) (void);
|
|
|
/* Calculate how much this insn affects how many more insns we
|
/* Calculate how much this insn affects how many more insns we
|
can emit this cycle. Default is they all cost the same. */
|
can emit this cycle. Default is they all cost the same. */
|
int (* variable_issue) (FILE *, int, rtx, int);
|
int (* variable_issue) (FILE *, int, rtx, int);
|
|
|
/* Initialize machine-dependent scheduling code. */
|
/* Initialize machine-dependent scheduling code. */
|
void (* md_init) (FILE *, int, int);
|
void (* md_init) (FILE *, int, int);
|
|
|
/* Finalize machine-dependent scheduling code. */
|
/* Finalize machine-dependent scheduling code. */
|
void (* md_finish) (FILE *, int);
|
void (* md_finish) (FILE *, int);
|
|
|
/* Initialize machine-dependent function wide scheduling code. */
|
/* Initialize machine-dependent function wide scheduling code. */
|
void (* md_init_global) (FILE *, int, int);
|
void (* md_init_global) (FILE *, int, int);
|
|
|
/* Finalize machine-dependent function wide scheduling code. */
|
/* Finalize machine-dependent function wide scheduling code. */
|
void (* md_finish_global) (FILE *, int);
|
void (* md_finish_global) (FILE *, int);
|
|
|
/* Reorder insns in a machine-dependent fashion, in two different
|
/* Reorder insns in a machine-dependent fashion, in two different
|
places. Default does nothing. */
|
places. Default does nothing. */
|
int (* reorder) (FILE *, int, rtx *, int *, int);
|
int (* reorder) (FILE *, int, rtx *, int *, int);
|
int (* reorder2) (FILE *, int, rtx *, int *, int);
|
int (* reorder2) (FILE *, int, rtx *, int *, int);
|
|
|
/* The following member value is a pointer to a function called
|
/* The following member value is a pointer to a function called
|
after evaluation forward dependencies of insns in chain given
|
after evaluation forward dependencies of insns in chain given
|
by two parameter values (head and tail correspondingly). */
|
by two parameter values (head and tail correspondingly). */
|
void (* dependencies_evaluation_hook) (rtx, rtx);
|
void (* dependencies_evaluation_hook) (rtx, rtx);
|
|
|
/* The values of the following four members are pointers to
|
/* The values of the following four members are pointers to
|
functions used to simplify the automaton descriptions.
|
functions used to simplify the automaton descriptions.
|
dfa_pre_cycle_insn and dfa_post_cycle_insn give functions
|
dfa_pre_cycle_insn and dfa_post_cycle_insn give functions
|
returning insns which are used to change the pipeline hazard
|
returning insns which are used to change the pipeline hazard
|
recognizer state when the new simulated processor cycle
|
recognizer state when the new simulated processor cycle
|
correspondingly starts and finishes. The function defined by
|
correspondingly starts and finishes. The function defined by
|
init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are used
|
init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are used
|
to initialize the corresponding insns. The default values of
|
to initialize the corresponding insns. The default values of
|
the members result in not changing the automaton state when
|
the members result in not changing the automaton state when
|
the new simulated processor cycle correspondingly starts and
|
the new simulated processor cycle correspondingly starts and
|
finishes. */
|
finishes. */
|
void (* init_dfa_pre_cycle_insn) (void);
|
void (* init_dfa_pre_cycle_insn) (void);
|
rtx (* dfa_pre_cycle_insn) (void);
|
rtx (* dfa_pre_cycle_insn) (void);
|
void (* init_dfa_post_cycle_insn) (void);
|
void (* init_dfa_post_cycle_insn) (void);
|
rtx (* dfa_post_cycle_insn) (void);
|
rtx (* dfa_post_cycle_insn) (void);
|
|
|
/* The values of the following two members are pointers to
|
/* The values of the following two members are pointers to
|
functions used to simplify the automaton descriptions.
|
functions used to simplify the automaton descriptions.
|
dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called
|
dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called
|
immediately before and after cycle is advanced. */
|
immediately before and after cycle is advanced. */
|
void (* dfa_pre_advance_cycle) (void);
|
void (* dfa_pre_advance_cycle) (void);
|
void (* dfa_post_advance_cycle) (void);
|
void (* dfa_post_advance_cycle) (void);
|
|
|
/* The following member value is a pointer to a function returning value
|
/* The following member value is a pointer to a function returning value
|
which defines how many insns in queue `ready' will we try for
|
which defines how many insns in queue `ready' will we try for
|
multi-pass scheduling. If the member value is nonzero and the
|
multi-pass scheduling. If the member value is nonzero and the
|
function returns positive value, the DFA based scheduler will make
|
function returns positive value, the DFA based scheduler will make
|
multi-pass scheduling for the first cycle. In other words, we will
|
multi-pass scheduling for the first cycle. In other words, we will
|
try to choose ready insn which permits to start maximum number of
|
try to choose ready insn which permits to start maximum number of
|
insns on the same cycle. */
|
insns on the same cycle. */
|
int (* first_cycle_multipass_dfa_lookahead) (void);
|
int (* first_cycle_multipass_dfa_lookahead) (void);
|
|
|
/* The following member value is pointer to a function controlling
|
/* The following member value is pointer to a function controlling
|
what insns from the ready insn queue will be considered for the
|
what insns from the ready insn queue will be considered for the
|
multipass insn scheduling. If the hook returns zero for insn
|
multipass insn scheduling. If the hook returns zero for insn
|
passed as the parameter, the insn will be not chosen to be
|
passed as the parameter, the insn will be not chosen to be
|
issued. */
|
issued. */
|
int (* first_cycle_multipass_dfa_lookahead_guard) (rtx);
|
int (* first_cycle_multipass_dfa_lookahead_guard) (rtx);
|
|
|
/* The following member value is pointer to a function called by
|
/* The following member value is pointer to a function called by
|
the insn scheduler before issuing insn passed as the third
|
the insn scheduler before issuing insn passed as the third
|
parameter on given cycle. If the hook returns nonzero, the
|
parameter on given cycle. If the hook returns nonzero, the
|
insn is not issued on given processors cycle. Instead of that,
|
insn is not issued on given processors cycle. Instead of that,
|
the processor cycle is advanced. If the value passed through
|
the processor cycle is advanced. If the value passed through
|
the last parameter is zero, the insn ready queue is not sorted
|
the last parameter is zero, the insn ready queue is not sorted
|
on the new cycle start as usually. The first parameter passes
|
on the new cycle start as usually. The first parameter passes
|
file for debugging output. The second one passes the scheduler
|
file for debugging output. The second one passes the scheduler
|
verbose level of the debugging output. The forth and the fifth
|
verbose level of the debugging output. The forth and the fifth
|
parameter values are correspondingly processor cycle on which
|
parameter values are correspondingly processor cycle on which
|
the previous insn has been issued and the current processor
|
the previous insn has been issued and the current processor
|
cycle. */
|
cycle. */
|
int (* dfa_new_cycle) (FILE *, int, rtx, int, int, int *);
|
int (* dfa_new_cycle) (FILE *, int, rtx, int, int, int *);
|
|
|
/* The following member value is a pointer to a function called by the
|
/* The following member value is a pointer to a function called by the
|
insn scheduler. It should return true if there exists a dependence
|
insn scheduler. It should return true if there exists a dependence
|
which is considered costly by the target, between the insn
|
which is considered costly by the target, between the insn
|
DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP). The first parameter is
|
DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP). The first parameter is
|
the dep that represents the dependence between the two insns. The
|
the dep that represents the dependence between the two insns. The
|
second argument is the cost of the dependence as estimated by
|
second argument is the cost of the dependence as estimated by
|
the scheduler. The last argument is the distance in cycles
|
the scheduler. The last argument is the distance in cycles
|
between the already scheduled insn (first parameter) and the
|
between the already scheduled insn (first parameter) and the
|
second insn (second parameter). */
|
second insn (second parameter). */
|
bool (* is_costly_dependence) (struct _dep *_dep, int, int);
|
bool (* is_costly_dependence) (struct _dep *_dep, int, int);
|
|
|
/* Given the current cost, COST, of an insn, INSN, calculate and
|
/* Given the current cost, COST, of an insn, INSN, calculate and
|
return a new cost based on its relationship to DEP_INSN through the
|
return a new cost based on its relationship to DEP_INSN through the
|
dependence of type DEP_TYPE. The default is to make no adjustment. */
|
dependence of type DEP_TYPE. The default is to make no adjustment. */
|
int (* adjust_cost_2) (rtx insn, int, rtx dep_insn, int cost, int dw);
|
int (* adjust_cost_2) (rtx insn, int, rtx dep_insn, int cost, int dw);
|
|
|
/* The following member value is a pointer to a function called
|
/* The following member value is a pointer to a function called
|
by the insn scheduler. This hook is called to notify the backend
|
by the insn scheduler. This hook is called to notify the backend
|
that new instructions were emitted. */
|
that new instructions were emitted. */
|
void (* h_i_d_extended) (void);
|
void (* h_i_d_extended) (void);
|
|
|
/* Next 5 functions are for multi-point scheduling. */
|
/* Next 5 functions are for multi-point scheduling. */
|
|
|
/* Allocate memory for scheduler context. */
|
/* Allocate memory for scheduler context. */
|
void *(* alloc_sched_context) (void);
|
void *(* alloc_sched_context) (void);
|
|
|
/* Fills the context from the local machine scheduler context. */
|
/* Fills the context from the local machine scheduler context. */
|
void (* init_sched_context) (void *, bool);
|
void (* init_sched_context) (void *, bool);
|
|
|
/* Sets local machine scheduler context to a saved value. */
|
/* Sets local machine scheduler context to a saved value. */
|
void (* set_sched_context) (void *);
|
void (* set_sched_context) (void *);
|
|
|
/* Clears a scheduler context so it becomes like after init. */
|
/* Clears a scheduler context so it becomes like after init. */
|
void (* clear_sched_context) (void *);
|
void (* clear_sched_context) (void *);
|
|
|
/* Frees the scheduler context. */
|
/* Frees the scheduler context. */
|
void (* free_sched_context) (void *);
|
void (* free_sched_context) (void *);
|
|
|
/* The following member value is a pointer to a function called
|
/* The following member value is a pointer to a function called
|
by the insn scheduler.
|
by the insn scheduler.
|
The first parameter is an instruction, the second parameter is the type
|
The first parameter is an instruction, the second parameter is the type
|
of the requested speculation, and the third parameter is a pointer to the
|
of the requested speculation, and the third parameter is a pointer to the
|
speculative pattern of the corresponding type (set if return value == 1).
|
speculative pattern of the corresponding type (set if return value == 1).
|
It should return
|
It should return
|
-1, if there is no pattern, that will satisfy the requested speculation
|
-1, if there is no pattern, that will satisfy the requested speculation
|
type,
|
type,
|
0, if current pattern satisfies the requested speculation type,
|
0, if current pattern satisfies the requested speculation type,
|
1, if pattern of the instruction should be changed to the newly
|
1, if pattern of the instruction should be changed to the newly
|
generated one. */
|
generated one. */
|
int (* speculate_insn) (rtx, int, rtx *);
|
int (* speculate_insn) (rtx, int, rtx *);
|
|
|
/* The following member value is a pointer to a function called
|
/* The following member value is a pointer to a function called
|
by the insn scheduler. It should return true if the check instruction
|
by the insn scheduler. It should return true if the check instruction
|
passed as the parameter needs a recovery block. */
|
passed as the parameter needs a recovery block. */
|
bool (* needs_block_p) (int);
|
bool (* needs_block_p) (int);
|
|
|
/* The following member value is a pointer to a function called
|
/* The following member value is a pointer to a function called
|
by the insn scheduler. It should return a pattern for the check
|
by the insn scheduler. It should return a pattern for the check
|
instruction.
|
instruction.
|
The first parameter is a speculative instruction, the second parameter
|
The first parameter is a speculative instruction, the second parameter
|
is the label of the corresponding recovery block (or null, if it is a
|
is the label of the corresponding recovery block (or null, if it is a
|
simple check). If the mutation of the check is requested (e.g. from
|
simple check). If the mutation of the check is requested (e.g. from
|
ld.c to chk.a), the third parameter is true - in this case the first
|
ld.c to chk.a), the third parameter is true - in this case the first
|
parameter is the previous check. */
|
parameter is the previous check. */
|
rtx (* gen_spec_check) (rtx, rtx, int);
|
rtx (* gen_spec_check) (rtx, rtx, int);
|
|
|
/* The following member value is a pointer to a function controlling
|
/* The following member value is a pointer to a function controlling
|
what insns from the ready insn queue will be considered for the
|
what insns from the ready insn queue will be considered for the
|
multipass insn scheduling. If the hook returns zero for the insn
|
multipass insn scheduling. If the hook returns zero for the insn
|
passed as the parameter, the insn will not be chosen to be
|
passed as the parameter, the insn will not be chosen to be
|
issued. This hook is used to discard speculative instructions,
|
issued. This hook is used to discard speculative instructions,
|
that stand at the first position of the ready list. */
|
that stand at the first position of the ready list. */
|
bool (* first_cycle_multipass_dfa_lookahead_guard_spec) (const_rtx);
|
bool (* first_cycle_multipass_dfa_lookahead_guard_spec) (const_rtx);
|
|
|
/* The following member value is a pointer to a function that provides
|
/* The following member value is a pointer to a function that provides
|
information about the speculation capabilities of the target.
|
information about the speculation capabilities of the target.
|
The parameter is a pointer to spec_info variable. */
|
The parameter is a pointer to spec_info variable. */
|
void (* set_sched_flags) (struct spec_info_def *);
|
void (* set_sched_flags) (struct spec_info_def *);
|
|
|
/* Return speculation types of the instruction passed as the parameter. */
|
/* Return speculation types of the instruction passed as the parameter. */
|
int (* get_insn_spec_ds) (rtx);
|
int (* get_insn_spec_ds) (rtx);
|
|
|
/* Return speculation types that are checked for the instruction passed as
|
/* Return speculation types that are checked for the instruction passed as
|
the parameter. */
|
the parameter. */
|
int (* get_insn_checked_ds) (rtx);
|
int (* get_insn_checked_ds) (rtx);
|
|
|
/* Return bool if rtx scanning should just skip current layer and
|
/* Return bool if rtx scanning should just skip current layer and
|
advance to the inner rtxes. */
|
advance to the inner rtxes. */
|
bool (* skip_rtx_p) (const_rtx);
|
bool (* skip_rtx_p) (const_rtx);
|
|
|
/* The following member value is a pointer to a function that provides
|
/* The following member value is a pointer to a function that provides
|
information about the target resource-based lower bound which is
|
information about the target resource-based lower bound which is
|
used by the swing modulo scheduler. The parameter is a pointer
|
used by the swing modulo scheduler. The parameter is a pointer
|
to ddg variable. */
|
to ddg variable. */
|
int (* sms_res_mii) (struct ddg *);
|
int (* sms_res_mii) (struct ddg *);
|
} sched;
|
} sched;
|
|
|
/* Functions relating to vectorization. */
|
/* Functions relating to vectorization. */
|
struct vectorize
|
struct vectorize
|
{
|
{
|
/* The following member value is a pointer to a function called
|
/* The following member value is a pointer to a function called
|
by the vectorizer, and return the decl of the target builtin
|
by the vectorizer, and return the decl of the target builtin
|
function. */
|
function. */
|
tree (* builtin_mask_for_load) (void);
|
tree (* builtin_mask_for_load) (void);
|
|
|
/* Returns a code for builtin that realizes vectorized version of
|
/* Returns a code for builtin that realizes vectorized version of
|
function, or NULL_TREE if not available. */
|
function, or NULL_TREE if not available. */
|
tree (* builtin_vectorized_function) (tree, tree, tree);
|
tree (* builtin_vectorized_function) (tree, tree, tree);
|
|
|
/* Returns a code for builtin that realizes vectorized version of
|
/* Returns a code for builtin that realizes vectorized version of
|
conversion, or NULL_TREE if not available. */
|
conversion, or NULL_TREE if not available. */
|
tree (* builtin_conversion) (unsigned, tree);
|
tree (* builtin_conversion) (unsigned, tree);
|
|
|
/* Target builtin that implements vector widening multiplication.
|
/* Target builtin that implements vector widening multiplication.
|
builtin_mul_widen_eve computes the element-by-element products
|
builtin_mul_widen_eve computes the element-by-element products
|
for the even elements, and builtin_mul_widen_odd computes the
|
for the even elements, and builtin_mul_widen_odd computes the
|
element-by-element products for the odd elements. */
|
element-by-element products for the odd elements. */
|
tree (* builtin_mul_widen_even) (tree);
|
tree (* builtin_mul_widen_even) (tree);
|
tree (* builtin_mul_widen_odd) (tree);
|
tree (* builtin_mul_widen_odd) (tree);
|
|
|
/* Returns the cost to be added to the overheads involved with
|
/* Returns the cost to be added to the overheads involved with
|
executing the vectorized version of a loop. */
|
executing the vectorized version of a loop. */
|
int (*builtin_vectorization_cost) (bool);
|
int (*builtin_vectorization_cost) (bool);
|
|
|
/* Return true if vector alignment is reachable (by peeling N
|
/* Return true if vector alignment is reachable (by peeling N
|
iterations) for the given type. */
|
iterations) for the given type. */
|
bool (* vector_alignment_reachable) (const_tree, bool);
|
bool (* vector_alignment_reachable) (const_tree, bool);
|
|
|
/* Target builtin that implements vector permute. */
|
/* Target builtin that implements vector permute. */
|
tree (* builtin_vec_perm) (tree, tree*);
|
tree (* builtin_vec_perm) (tree, tree*);
|
|
|
/* Return true if a vector created for builtin_vec_perm is valid. */
|
/* Return true if a vector created for builtin_vec_perm is valid. */
|
bool (* builtin_vec_perm_ok) (tree, tree);
|
bool (* builtin_vec_perm_ok) (tree, tree);
|
|
|
/* Return true if the target supports misaligned store/load of a
|
/* Return true if the target supports misaligned store/load of a
|
specific factor denoted in the third parameter. The last parameter
|
specific factor denoted in the third parameter. The last parameter
|
is true if the access is defined in a packed struct. */
|
is true if the access is defined in a packed struct. */
|
bool (* builtin_support_vector_misalignment) (enum machine_mode,
|
bool (* builtin_support_vector_misalignment) (enum machine_mode,
|
const_tree, int, bool);
|
const_tree, int, bool);
|
} vectorize;
|
} vectorize;
|
|
|
/* The initial value of target_flags. */
|
/* The initial value of target_flags. */
|
int default_target_flags;
|
int default_target_flags;
|
|
|
/* Allow target specific overriding of option settings after options have
|
/* Allow target specific overriding of option settings after options have
|
been changed by an attribute or pragma or when it is reset at the
|
been changed by an attribute or pragma or when it is reset at the
|
end of the code affected by an attribute or pragma. */
|
end of the code affected by an attribute or pragma. */
|
void (* override_options_after_change) (void);
|
void (* override_options_after_change) (void);
|
|
|
/* Handle target switch CODE (an OPT_* value). ARG is the argument
|
/* Handle target switch CODE (an OPT_* value). ARG is the argument
|
passed to the switch; it is NULL if no argument was. VALUE is the
|
passed to the switch; it is NULL if no argument was. VALUE is the
|
value of ARG if CODE specifies a UInteger option, otherwise it is
|
value of ARG if CODE specifies a UInteger option, otherwise it is
|
1 if the positive form of the switch was used and 0 if the negative
|
1 if the positive form of the switch was used and 0 if the negative
|
form was. Return true if the switch was valid. */
|
form was. Return true if the switch was valid. */
|
bool (* handle_option) (size_t code, const char *arg, int value);
|
bool (* handle_option) (size_t code, const char *arg, int value);
|
|
|
/* Display extra, target specific information in response to a
|
/* Display extra, target specific information in response to a
|
--target-help switch. */
|
--target-help switch. */
|
void (* target_help) (void);
|
void (* target_help) (void);
|
|
|
/* Return machine mode for filter value. */
|
/* Return machine mode for filter value. */
|
enum machine_mode (* eh_return_filter_mode) (void);
|
enum machine_mode (* eh_return_filter_mode) (void);
|
|
|
/* Return machine mode for libgcc expanded cmp instructions. */
|
/* Return machine mode for libgcc expanded cmp instructions. */
|
enum machine_mode (* libgcc_cmp_return_mode) (void);
|
enum machine_mode (* libgcc_cmp_return_mode) (void);
|
|
|
/* Return machine mode for libgcc expanded shift instructions. */
|
/* Return machine mode for libgcc expanded shift instructions. */
|
enum machine_mode (* libgcc_shift_count_mode) (void);
|
enum machine_mode (* libgcc_shift_count_mode) (void);
|
|
|
/* Return machine mode to be used for _Unwind_Word type. */
|
/* Return machine mode to be used for _Unwind_Word type. */
|
enum machine_mode (* unwind_word_mode) (void);
|
enum machine_mode (* unwind_word_mode) (void);
|
|
|
/* Given two decls, merge their attributes and return the result. */
|
/* Given two decls, merge their attributes and return the result. */
|
tree (* merge_decl_attributes) (tree, tree);
|
tree (* merge_decl_attributes) (tree, tree);
|
|
|
/* Given two types, merge their attributes and return the result. */
|
/* Given two types, merge their attributes and return the result. */
|
tree (* merge_type_attributes) (tree, tree);
|
tree (* merge_type_attributes) (tree, tree);
|
|
|
/* Table of machine attributes and functions to handle them.
|
/* Table of machine attributes and functions to handle them.
|
Ignored if NULL. */
|
Ignored if NULL. */
|
const struct attribute_spec *attribute_table;
|
const struct attribute_spec *attribute_table;
|
|
|
/* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
|
/* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
|
one if they are compatible and two if they are nearly compatible
|
one if they are compatible and two if they are nearly compatible
|
(which causes a warning to be generated). */
|
(which causes a warning to be generated). */
|
int (* comp_type_attributes) (const_tree type1, const_tree type2);
|
int (* comp_type_attributes) (const_tree type1, const_tree type2);
|
|
|
/* Assign default attributes to the newly defined TYPE. */
|
/* Assign default attributes to the newly defined TYPE. */
|
void (* set_default_type_attributes) (tree type);
|
void (* set_default_type_attributes) (tree type);
|
|
|
/* Insert attributes on the newly created DECL. */
|
/* Insert attributes on the newly created DECL. */
|
void (* insert_attributes) (tree decl, tree *attributes);
|
void (* insert_attributes) (tree decl, tree *attributes);
|
|
|
/* Return true if FNDECL (which has at least one machine attribute)
|
/* Return true if FNDECL (which has at least one machine attribute)
|
can be inlined despite its machine attributes, false otherwise. */
|
can be inlined despite its machine attributes, false otherwise. */
|
bool (* function_attribute_inlinable_p) (const_tree fndecl);
|
bool (* function_attribute_inlinable_p) (const_tree fndecl);
|
|
|
/* Return true if bitfields in RECORD_TYPE should follow the
|
/* Return true if bitfields in RECORD_TYPE should follow the
|
Microsoft Visual C++ bitfield layout rules. */
|
Microsoft Visual C++ bitfield layout rules. */
|
bool (* ms_bitfield_layout_p) (const_tree record_type);
|
bool (* ms_bitfield_layout_p) (const_tree record_type);
|
|
|
/* True if the target supports decimal floating point. */
|
/* True if the target supports decimal floating point. */
|
bool (* decimal_float_supported_p) (void);
|
bool (* decimal_float_supported_p) (void);
|
|
|
/* True if the target supports fixed-point. */
|
/* True if the target supports fixed-point. */
|
bool (* fixed_point_supported_p) (void);
|
bool (* fixed_point_supported_p) (void);
|
|
|
/* Return true if anonymous bitfields affect structure alignment. */
|
/* Return true if anonymous bitfields affect structure alignment. */
|
bool (* align_anon_bitfield) (void);
|
bool (* align_anon_bitfield) (void);
|
|
|
/* Return true if volatile bitfields should use the narrowest type possible.
|
/* Return true if volatile bitfields should use the narrowest type possible.
|
Return false if they should use the container type. */
|
Return false if they should use the container type. */
|
bool (* narrow_volatile_bitfield) (void);
|
bool (* narrow_volatile_bitfield) (void);
|
|
|
/* Set up target-specific built-in functions. */
|
/* Set up target-specific built-in functions. */
|
void (* init_builtins) (void);
|
void (* init_builtins) (void);
|
|
|
/* Initialize (if INITIALIZE_P is true) and return the target-specific
|
/* Initialize (if INITIALIZE_P is true) and return the target-specific
|
built-in function decl for CODE.
|
built-in function decl for CODE.
|
Return NULL if that is not possible. Return error_mark_node if CODE
|
Return NULL if that is not possible. Return error_mark_node if CODE
|
is outside of the range of valid target builtin function codes. */
|
is outside of the range of valid target builtin function codes. */
|
tree (* builtin_decl) (unsigned code, bool initialize_p);
|
tree (* builtin_decl) (unsigned code, bool initialize_p);
|
|
|
/* Expand a target-specific builtin. */
|
/* Expand a target-specific builtin. */
|
rtx (* expand_builtin) (tree exp, rtx target, rtx subtarget,
|
rtx (* expand_builtin) (tree exp, rtx target, rtx subtarget,
|
enum machine_mode mode, int ignore);
|
enum machine_mode mode, int ignore);
|
|
|
/* Select a replacement for a target-specific builtin. This is done
|
/* Select a replacement for a target-specific builtin. This is done
|
*before* regular type checking, and so allows the target to
|
*before* regular type checking, and so allows the target to
|
implement a crude form of function overloading. The result is a
|
implement a crude form of function overloading. The result is a
|
complete expression that implements the operation. PARAMS really
|
complete expression that implements the operation. PARAMS really
|
has type VEC(tree,gc)*, but we don't want to include tree.h
|
has type VEC(tree,gc)*, but we don't want to include tree.h
|
here. */
|
here. */
|
tree (*resolve_overloaded_builtin) (unsigned int /*location_t*/,
|
tree (*resolve_overloaded_builtin) (unsigned int /*location_t*/,
|
tree decl, void *params);
|
tree decl, void *params);
|
|
|
/* Fold a target-specific builtin. */
|
/* Fold a target-specific builtin. */
|
tree (* fold_builtin) (tree fndecl, tree arglist, bool ignore);
|
tree (* fold_builtin) (tree fndecl, tree arglist, bool ignore);
|
|
|
/* Returns a code for a target-specific builtin that implements
|
/* Returns a code for a target-specific builtin that implements
|
reciprocal of the function, or NULL_TREE if not available. */
|
reciprocal of the function, or NULL_TREE if not available. */
|
tree (* builtin_reciprocal) (unsigned, bool, bool);
|
tree (* builtin_reciprocal) (unsigned, bool, bool);
|
|
|
/* For a vendor-specific TYPE, return a pointer to a statically-allocated
|
/* For a vendor-specific TYPE, return a pointer to a statically-allocated
|
string containing the C++ mangling for TYPE. In all other cases, return
|
string containing the C++ mangling for TYPE. In all other cases, return
|
NULL. */
|
NULL. */
|
const char * (* mangle_type) (const_tree type);
|
const char * (* mangle_type) (const_tree type);
|
|
|
/* Make any adjustments to libfunc names needed for this target. */
|
/* Make any adjustments to libfunc names needed for this target. */
|
void (* init_libfuncs) (void);
|
void (* init_libfuncs) (void);
|
|
|
/* Given a decl, a section name, and whether the decl initializer
|
/* Given a decl, a section name, and whether the decl initializer
|
has relocs, choose attributes for the section. */
|
has relocs, choose attributes for the section. */
|
/* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION. */
|
/* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION. */
|
unsigned int (* section_type_flags) (tree, const char *, int);
|
unsigned int (* section_type_flags) (tree, const char *, int);
|
|
|
/* True if new jumps cannot be created, to replace existing ones or
|
/* True if new jumps cannot be created, to replace existing ones or
|
not, at the current point in the compilation. */
|
not, at the current point in the compilation. */
|
bool (* cannot_modify_jumps_p) (void);
|
bool (* cannot_modify_jumps_p) (void);
|
|
|
/* Return a register class for which branch target register
|
/* Return a register class for which branch target register
|
optimizations should be applied. */
|
optimizations should be applied. */
|
enum reg_class (* branch_target_register_class) (void);
|
enum reg_class (* branch_target_register_class) (void);
|
|
|
/* Return true if branch target register optimizations should include
|
/* Return true if branch target register optimizations should include
|
callee-saved registers that are not already live during the current
|
callee-saved registers that are not already live during the current
|
function. AFTER_PE_GEN is true if prologues and epilogues have
|
function. AFTER_PE_GEN is true if prologues and epilogues have
|
already been generated. */
|
already been generated. */
|
bool (* branch_target_register_callee_saved) (bool after_pe_gen);
|
bool (* branch_target_register_callee_saved) (bool after_pe_gen);
|
|
|
/* Return true if the target supports conditional execution. */
|
/* Return true if the target supports conditional execution. */
|
bool (* have_conditional_execution) (void);
|
bool (* have_conditional_execution) (void);
|
|
|
/* True if the constant X cannot be placed in the constant pool. */
|
/* True if the constant X cannot be placed in the constant pool. */
|
bool (* cannot_force_const_mem) (rtx);
|
bool (* cannot_force_const_mem) (rtx);
|
|
|
/* True if the insn X cannot be duplicated. */
|
/* True if the insn X cannot be duplicated. */
|
bool (* cannot_copy_insn_p) (rtx);
|
bool (* cannot_copy_insn_p) (rtx);
|
|
|
/* True if X is considered to be commutative. */
|
/* True if X is considered to be commutative. */
|
bool (* commutative_p) (const_rtx, int);
|
bool (* commutative_p) (const_rtx, int);
|
|
|
/* Given an invalid address X for a given machine mode, try machine-specific
|
/* Given an invalid address X for a given machine mode, try machine-specific
|
ways to make it legitimate. Return X or an invalid address on failure. */
|
ways to make it legitimate. Return X or an invalid address on failure. */
|
rtx (* legitimize_address) (rtx, rtx, enum machine_mode);
|
rtx (* legitimize_address) (rtx, rtx, enum machine_mode);
|
|
|
/* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */
|
/* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */
|
rtx (* delegitimize_address) (rtx);
|
rtx (* delegitimize_address) (rtx);
|
|
|
/* Given an address RTX, say whether it is valid. */
|
/* Given an address RTX, say whether it is valid. */
|
bool (* legitimate_address_p) (enum machine_mode, rtx, bool);
|
bool (* legitimate_address_p) (enum machine_mode, rtx, bool);
|
|
|
/* True if the given constant can be put into an object_block. */
|
/* True if the given constant can be put into an object_block. */
|
bool (* use_blocks_for_constant_p) (enum machine_mode, const_rtx);
|
bool (* use_blocks_for_constant_p) (enum machine_mode, const_rtx);
|
|
|
/* The minimum and maximum byte offsets for anchored addresses. */
|
/* The minimum and maximum byte offsets for anchored addresses. */
|
HOST_WIDE_INT min_anchor_offset;
|
HOST_WIDE_INT min_anchor_offset;
|
HOST_WIDE_INT max_anchor_offset;
|
HOST_WIDE_INT max_anchor_offset;
|
|
|
/* True if section anchors can be used to access the given symbol. */
|
/* True if section anchors can be used to access the given symbol. */
|
bool (* use_anchors_for_symbol_p) (const_rtx);
|
bool (* use_anchors_for_symbol_p) (const_rtx);
|
|
|
/* True if it is OK to do sibling call optimization for the specified
|
/* True if it is OK to do sibling call optimization for the specified
|
call expression EXP. DECL will be the called function, or NULL if
|
call expression EXP. DECL will be the called function, or NULL if
|
this is an indirect call. */
|
this is an indirect call. */
|
bool (*function_ok_for_sibcall) (tree decl, tree exp);
|
bool (*function_ok_for_sibcall) (tree decl, tree exp);
|
|
|
/* Establish appropriate back-end context for processing the function
|
/* Establish appropriate back-end context for processing the function
|
FNDECL. The argument might be NULL to indicate processing at top
|
FNDECL. The argument might be NULL to indicate processing at top
|
level, outside of any function scope. */
|
level, outside of any function scope. */
|
void (*set_current_function) (tree fndecl);
|
void (*set_current_function) (tree fndecl);
|
|
|
/* True if EXP should be placed in a "small data" section. */
|
/* True if EXP should be placed in a "small data" section. */
|
bool (* in_small_data_p) (const_tree);
|
bool (* in_small_data_p) (const_tree);
|
|
|
/* True if EXP names an object for which name resolution must resolve
|
/* True if EXP names an object for which name resolution must resolve
|
to the current executable or shared library. */
|
to the current executable or shared library. */
|
bool (* binds_local_p) (const_tree);
|
bool (* binds_local_p) (const_tree);
|
|
|
/* Modify and return the identifier of a DECL's external name,
|
/* Modify and return the identifier of a DECL's external name,
|
originally identified by ID, as required by the target,
|
originally identified by ID, as required by the target,
|
(eg, append @nn to windows32 stdcall function names).
|
(eg, append @nn to windows32 stdcall function names).
|
The default is to return ID without modification. */
|
The default is to return ID without modification. */
|
tree (* mangle_decl_assembler_name) (tree decl, tree id);
|
tree (* mangle_decl_assembler_name) (tree decl, tree id);
|
|
|
/* Do something target-specific to record properties of the DECL into
|
/* Do something target-specific to record properties of the DECL into
|
the associated SYMBOL_REF. */
|
the associated SYMBOL_REF. */
|
void (* encode_section_info) (tree, rtx, int);
|
void (* encode_section_info) (tree, rtx, int);
|
|
|
/* Undo the effects of encode_section_info on the symbol string. */
|
/* Undo the effects of encode_section_info on the symbol string. */
|
const char * (* strip_name_encoding) (const char *);
|
const char * (* strip_name_encoding) (const char *);
|
|
|
/* If shift optabs for MODE are known to always truncate the shift count,
|
/* If shift optabs for MODE are known to always truncate the shift count,
|
return the mask that they apply. Return 0 otherwise. */
|
return the mask that they apply. Return 0 otherwise. */
|
unsigned HOST_WIDE_INT (* shift_truncation_mask) (enum machine_mode mode);
|
unsigned HOST_WIDE_INT (* shift_truncation_mask) (enum machine_mode mode);
|
|
|
/* Return the number of divisions in the given MODE that should be present,
|
/* Return the number of divisions in the given MODE that should be present,
|
so that it is profitable to turn the division into a multiplication by
|
so that it is profitable to turn the division into a multiplication by
|
the reciprocal. */
|
the reciprocal. */
|
unsigned int (* min_divisions_for_recip_mul) (enum machine_mode mode);
|
unsigned int (* min_divisions_for_recip_mul) (enum machine_mode mode);
|
|
|
/* If the representation of integral MODE is such that values are
|
/* If the representation of integral MODE is such that values are
|
always sign-extended to a wider mode MODE_REP then return
|
always sign-extended to a wider mode MODE_REP then return
|
SIGN_EXTEND. Return UNKNOWN otherwise. */
|
SIGN_EXTEND. Return UNKNOWN otherwise. */
|
/* Note that the return type ought to be RTX_CODE, but that's not
|
/* Note that the return type ought to be RTX_CODE, but that's not
|
necessarily defined at this point. */
|
necessarily defined at this point. */
|
int (* mode_rep_extended) (enum machine_mode mode,
|
int (* mode_rep_extended) (enum machine_mode mode,
|
enum machine_mode mode_rep);
|
enum machine_mode mode_rep);
|
|
|
/* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */
|
/* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */
|
bool (* valid_pointer_mode) (enum machine_mode mode);
|
bool (* valid_pointer_mode) (enum machine_mode mode);
|
|
|
/* Support for named address spaces. */
|
/* Support for named address spaces. */
|
struct addr_space {
|
struct addr_space {
|
/* MODE to use for a pointer into another address space. */
|
/* MODE to use for a pointer into another address space. */
|
enum machine_mode (* pointer_mode) (addr_space_t);
|
enum machine_mode (* pointer_mode) (addr_space_t);
|
|
|
/* MODE to use for an address in another address space. */
|
/* MODE to use for an address in another address space. */
|
enum machine_mode (* address_mode) (addr_space_t);
|
enum machine_mode (* address_mode) (addr_space_t);
|
|
|
/* True if MODE is valid for a pointer in __attribute__((mode("MODE")))
|
/* True if MODE is valid for a pointer in __attribute__((mode("MODE")))
|
in another address space. */
|
in another address space. */
|
bool (* valid_pointer_mode) (enum machine_mode, addr_space_t);
|
bool (* valid_pointer_mode) (enum machine_mode, addr_space_t);
|
|
|
/* True if an address is a valid memory address to a given named address
|
/* True if an address is a valid memory address to a given named address
|
space for a given mode. */
|
space for a given mode. */
|
bool (* legitimate_address_p) (enum machine_mode, rtx, bool, addr_space_t);
|
bool (* legitimate_address_p) (enum machine_mode, rtx, bool, addr_space_t);
|
|
|
/* Return an updated address to convert an invalid pointer to a named
|
/* Return an updated address to convert an invalid pointer to a named
|
address space to a valid one. If NULL_RTX is returned use machine
|
address space to a valid one. If NULL_RTX is returned use machine
|
independent methods to make the address valid. */
|
independent methods to make the address valid. */
|
rtx (* legitimize_address) (rtx, rtx, enum machine_mode, addr_space_t);
|
rtx (* legitimize_address) (rtx, rtx, enum machine_mode, addr_space_t);
|
|
|
/* True if one named address space is a subset of another named address. */
|
/* True if one named address space is a subset of another named address. */
|
bool (* subset_p) (addr_space_t, addr_space_t);
|
bool (* subset_p) (addr_space_t, addr_space_t);
|
|
|
/* Function to convert an rtl expression from one address space to
|
/* Function to convert an rtl expression from one address space to
|
another. */
|
another. */
|
rtx (* convert) (rtx, tree, tree);
|
rtx (* convert) (rtx, tree, tree);
|
|
|
} addr_space;
|
} addr_space;
|
|
|
/* True if MODE is valid for the target. By "valid", we mean able to
|
/* True if MODE is valid for the target. By "valid", we mean able to
|
be manipulated in non-trivial ways. In particular, this means all
|
be manipulated in non-trivial ways. In particular, this means all
|
the arithmetic is supported. */
|
the arithmetic is supported. */
|
bool (* scalar_mode_supported_p) (enum machine_mode mode);
|
bool (* scalar_mode_supported_p) (enum machine_mode mode);
|
|
|
/* Similarly for vector modes. "Supported" here is less strict. At
|
/* Similarly for vector modes. "Supported" here is less strict. At
|
least some operations are supported; need to check optabs or builtins
|
least some operations are supported; need to check optabs or builtins
|
for further details. */
|
for further details. */
|
bool (* vector_mode_supported_p) (enum machine_mode mode);
|
bool (* vector_mode_supported_p) (enum machine_mode mode);
|
|
|
/* Compute a (partial) cost for rtx X. Return true if the complete
|
/* Compute a (partial) cost for rtx X. Return true if the complete
|
cost has been computed, and false if subexpressions should be
|
cost has been computed, and false if subexpressions should be
|
scanned. In either case, *TOTAL contains the cost result. */
|
scanned. In either case, *TOTAL contains the cost result. */
|
/* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's
|
/* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's
|
not necessarily defined at this point. */
|
not necessarily defined at this point. */
|
bool (* rtx_costs) (rtx x, int code, int outer_code, int *total, bool speed);
|
bool (* rtx_costs) (rtx x, int code, int outer_code, int *total, bool speed);
|
|
|
/* Compute the cost of X, used as an address. Never called with
|
/* Compute the cost of X, used as an address. Never called with
|
invalid addresses. */
|
invalid addresses. */
|
int (* address_cost) (rtx x, bool speed);
|
int (* address_cost) (rtx x, bool speed);
|
|
|
/* Return where to allocate pseudo for a given hard register initial
|
/* Return where to allocate pseudo for a given hard register initial
|
value. */
|
value. */
|
rtx (* allocate_initial_value) (rtx x);
|
rtx (* allocate_initial_value) (rtx x);
|
|
|
/* Return nonzero if evaluating UNSPEC[_VOLATILE] X might cause a trap.
|
/* Return nonzero if evaluating UNSPEC[_VOLATILE] X might cause a trap.
|
FLAGS has the same meaning as in rtlanal.c: may_trap_p_1. */
|
FLAGS has the same meaning as in rtlanal.c: may_trap_p_1. */
|
int (* unspec_may_trap_p) (const_rtx x, unsigned flags);
|
int (* unspec_may_trap_p) (const_rtx x, unsigned flags);
|
|
|
/* Given a register, this hook should return a parallel of registers
|
/* Given a register, this hook should return a parallel of registers
|
to represent where to find the register pieces. Define this hook
|
to represent where to find the register pieces. Define this hook
|
if the register and its mode are represented in Dwarf in
|
if the register and its mode are represented in Dwarf in
|
non-contiguous locations, or if the register should be
|
non-contiguous locations, or if the register should be
|
represented in more than one register in Dwarf. Otherwise, this
|
represented in more than one register in Dwarf. Otherwise, this
|
hook should return NULL_RTX. */
|
hook should return NULL_RTX. */
|
rtx (* dwarf_register_span) (rtx);
|
rtx (* dwarf_register_span) (rtx);
|
|
|
/* If expand_builtin_init_dwarf_reg_sizes needs to fill in table
|
/* If expand_builtin_init_dwarf_reg_sizes needs to fill in table
|
entries not corresponding directly to registers below
|
entries not corresponding directly to registers below
|
FIRST_PSEUDO_REGISTER, this hook should generate the necessary
|
FIRST_PSEUDO_REGISTER, this hook should generate the necessary
|
code, given the address of the table. */
|
code, given the address of the table. */
|
void (* init_dwarf_reg_sizes_extra) (tree);
|
void (* init_dwarf_reg_sizes_extra) (tree);
|
|
|
/* Fetch the fixed register(s) which hold condition codes, for
|
/* Fetch the fixed register(s) which hold condition codes, for
|
targets where it makes sense to look for duplicate assignments to
|
targets where it makes sense to look for duplicate assignments to
|
the condition codes. This should return true if there is such a
|
the condition codes. This should return true if there is such a
|
register, false otherwise. The arguments should be set to the
|
register, false otherwise. The arguments should be set to the
|
fixed register numbers. Up to two condition code registers are
|
fixed register numbers. Up to two condition code registers are
|
supported. If there is only one for this target, the int pointed
|
supported. If there is only one for this target, the int pointed
|
at by the second argument should be set to -1. */
|
at by the second argument should be set to -1. */
|
bool (* fixed_condition_code_regs) (unsigned int *, unsigned int *);
|
bool (* fixed_condition_code_regs) (unsigned int *, unsigned int *);
|
|
|
/* If two condition code modes are compatible, return a condition
|
/* If two condition code modes are compatible, return a condition
|
code mode which is compatible with both, such that a comparison
|
code mode which is compatible with both, such that a comparison
|
done in the returned mode will work for both of the original
|
done in the returned mode will work for both of the original
|
modes. If the condition code modes are not compatible, return
|
modes. If the condition code modes are not compatible, return
|
VOIDmode. */
|
VOIDmode. */
|
enum machine_mode (* cc_modes_compatible) (enum machine_mode,
|
enum machine_mode (* cc_modes_compatible) (enum machine_mode,
|
enum machine_mode);
|
enum machine_mode);
|
|
|
/* Do machine-dependent code transformations. Called just before
|
/* Do machine-dependent code transformations. Called just before
|
delayed-branch scheduling. */
|
delayed-branch scheduling. */
|
void (* machine_dependent_reorg) (void);
|
void (* machine_dependent_reorg) (void);
|
|
|
/* Create the __builtin_va_list type. */
|
/* Create the __builtin_va_list type. */
|
tree (* build_builtin_va_list) (void);
|
tree (* build_builtin_va_list) (void);
|
|
|
/* Get the cfun/fndecl calling abi __builtin_va_list type. */
|
/* Get the cfun/fndecl calling abi __builtin_va_list type. */
|
tree (* fn_abi_va_list) (tree);
|
tree (* fn_abi_va_list) (tree);
|
|
|
/* Get the __builtin_va_list type dependent on input type. */
|
/* Get the __builtin_va_list type dependent on input type. */
|
tree (* canonical_va_list_type) (tree);
|
tree (* canonical_va_list_type) (tree);
|
|
|
/* Expand the __builtin_va_start builtin. */
|
/* Expand the __builtin_va_start builtin. */
|
void (* expand_builtin_va_start) (tree valist, rtx nextarg);
|
void (* expand_builtin_va_start) (tree valist, rtx nextarg);
|
|
|
/* Gimplifies a VA_ARG_EXPR. */
|
/* Gimplifies a VA_ARG_EXPR. */
|
tree (* gimplify_va_arg_expr) (tree valist, tree type, gimple_seq *pre_p,
|
tree (* gimplify_va_arg_expr) (tree valist, tree type, gimple_seq *pre_p,
|
gimple_seq *post_p);
|
gimple_seq *post_p);
|
|
|
/* Validity-checking routines for PCH files, target-specific.
|
/* Validity-checking routines for PCH files, target-specific.
|
get_pch_validity returns a pointer to the data to be stored,
|
get_pch_validity returns a pointer to the data to be stored,
|
and stores the size in its argument. pch_valid_p gets the same
|
and stores the size in its argument. pch_valid_p gets the same
|
information back and returns NULL if the PCH is valid,
|
information back and returns NULL if the PCH is valid,
|
or an error message if not.
|
or an error message if not.
|
*/
|
*/
|
void * (* get_pch_validity) (size_t *);
|
void * (* get_pch_validity) (size_t *);
|
const char * (* pch_valid_p) (const void *, size_t);
|
const char * (* pch_valid_p) (const void *, size_t);
|
|
|
/* If nonnull, this function checks whether a PCH file with the
|
/* If nonnull, this function checks whether a PCH file with the
|
given set of target flags can be used. It returns NULL if so,
|
given set of target flags can be used. It returns NULL if so,
|
otherwise it returns an error message. */
|
otherwise it returns an error message. */
|
const char *(*check_pch_target_flags) (int);
|
const char *(*check_pch_target_flags) (int);
|
|
|
/* True if the compiler should give an enum type only as many
|
/* True if the compiler should give an enum type only as many
|
bytes as it takes to represent the range of possible values of
|
bytes as it takes to represent the range of possible values of
|
that type. */
|
that type. */
|
bool (* default_short_enums) (void);
|
bool (* default_short_enums) (void);
|
|
|
/* This target hook returns an rtx that is used to store the address
|
/* This target hook returns an rtx that is used to store the address
|
of the current frame into the built-in setjmp buffer. */
|
of the current frame into the built-in setjmp buffer. */
|
rtx (* builtin_setjmp_frame_value) (void);
|
rtx (* builtin_setjmp_frame_value) (void);
|
|
|
/* This target hook should add STRING_CST trees for any hard regs
|
/* This target hook should add STRING_CST trees for any hard regs
|
the port wishes to automatically clobber for an asm. */
|
the port wishes to automatically clobber for an asm. */
|
tree (* md_asm_clobbers) (tree, tree, tree);
|
tree (* md_asm_clobbers) (tree, tree, tree);
|
|
|
/* This target hook allows the backend to specify a calling convention
|
/* This target hook allows the backend to specify a calling convention
|
in the debug information. This function actually returns an
|
in the debug information. This function actually returns an
|
enum dwarf_calling_convention, but because of forward declarations
|
enum dwarf_calling_convention, but because of forward declarations
|
and not wanting to include dwarf2.h everywhere target.h is included
|
and not wanting to include dwarf2.h everywhere target.h is included
|
the function is being declared as an int. */
|
the function is being declared as an int. */
|
int (* dwarf_calling_convention) (const_tree);
|
int (* dwarf_calling_convention) (const_tree);
|
|
|
/* This target hook allows the backend to emit frame-related insns that
|
/* This target hook allows the backend to emit frame-related insns that
|
contain UNSPECs or UNSPEC_VOLATILEs. The call frame debugging info
|
contain UNSPECs or UNSPEC_VOLATILEs. The call frame debugging info
|
engine will invoke it on insns of the form
|
engine will invoke it on insns of the form
|
(set (reg) (unspec [...] UNSPEC_INDEX))
|
(set (reg) (unspec [...] UNSPEC_INDEX))
|
and
|
and
|
(set (reg) (unspec_volatile [...] UNSPECV_INDEX))
|
(set (reg) (unspec_volatile [...] UNSPECV_INDEX))
|
to let the backend emit the call frame instructions. */
|
to let the backend emit the call frame instructions. */
|
void (* dwarf_handle_frame_unspec) (const char *, rtx, int);
|
void (* dwarf_handle_frame_unspec) (const char *, rtx, int);
|
|
|
/* Perform architecture specific checking of statements gimplified
|
/* Perform architecture specific checking of statements gimplified
|
from VA_ARG_EXPR. STMT is the statement. Returns true if the statement
|
from VA_ARG_EXPR. STMT is the statement. Returns true if the statement
|
doesn't need to be checked for va_list references. */
|
doesn't need to be checked for va_list references. */
|
bool (* stdarg_optimize_hook) (struct stdarg_info *ai, const_gimple stmt);
|
bool (* stdarg_optimize_hook) (struct stdarg_info *ai, const_gimple stmt);
|
|
|
/* This target hook allows the operating system to override the DECL
|
/* This target hook allows the operating system to override the DECL
|
that represents the external variable that contains the stack
|
that represents the external variable that contains the stack
|
protection guard variable. The type of this DECL is ptr_type_node. */
|
protection guard variable. The type of this DECL is ptr_type_node. */
|
tree (* stack_protect_guard) (void);
|
tree (* stack_protect_guard) (void);
|
|
|
/* This target hook allows the operating system to override the CALL_EXPR
|
/* This target hook allows the operating system to override the CALL_EXPR
|
that is invoked when a check vs the guard variable fails. */
|
that is invoked when a check vs the guard variable fails. */
|
tree (* stack_protect_fail) (void);
|
tree (* stack_protect_fail) (void);
|
|
|
/* Returns NULL if target supports the insn within a doloop block,
|
/* Returns NULL if target supports the insn within a doloop block,
|
otherwise it returns an error message. */
|
otherwise it returns an error message. */
|
const char * (*invalid_within_doloop) (const_rtx);
|
const char * (*invalid_within_doloop) (const_rtx);
|
|
|
/* DECL is a variable or function with __attribute__((dllimport))
|
/* DECL is a variable or function with __attribute__((dllimport))
|
specified. Use this hook if the target needs to add extra validation
|
specified. Use this hook if the target needs to add extra validation
|
checks to handle_dll_attribute (). */
|
checks to handle_dll_attribute (). */
|
bool (* valid_dllimport_attribute_p) (const_tree decl);
|
bool (* valid_dllimport_attribute_p) (const_tree decl);
|
|
|
/* If non-zero, align constant anchors in CSE to a multiple of this
|
/* If non-zero, align constant anchors in CSE to a multiple of this
|
value. */
|
value. */
|
unsigned HOST_WIDE_INT const_anchor;
|
unsigned HOST_WIDE_INT const_anchor;
|
|
|
/* Functions relating to calls - argument passing, returns, etc. */
|
/* Functions relating to calls - argument passing, returns, etc. */
|
struct calls {
|
struct calls {
|
enum machine_mode (*promote_function_mode) (const_tree type,
|
enum machine_mode (*promote_function_mode) (const_tree type,
|
enum machine_mode mode,
|
enum machine_mode mode,
|
int *punsignedp,
|
int *punsignedp,
|
const_tree fntype,
|
const_tree fntype,
|
int for_return);
|
int for_return);
|
bool (*promote_prototypes) (const_tree fntype);
|
bool (*promote_prototypes) (const_tree fntype);
|
rtx (*struct_value_rtx) (tree fndecl, int incoming);
|
rtx (*struct_value_rtx) (tree fndecl, int incoming);
|
bool (*return_in_memory) (const_tree type, const_tree fndecl);
|
bool (*return_in_memory) (const_tree type, const_tree fndecl);
|
bool (*return_in_msb) (const_tree type);
|
bool (*return_in_msb) (const_tree type);
|
|
|
/* Return true if a parameter must be passed by reference. TYPE may
|
/* Return true if a parameter must be passed by reference. TYPE may
|
be null if this is a libcall. CA may be null if this query is
|
be null if this is a libcall. CA may be null if this query is
|
from __builtin_va_arg. */
|
from __builtin_va_arg. */
|
bool (*pass_by_reference) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
bool (*pass_by_reference) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
const_tree type, bool named_arg);
|
const_tree type, bool named_arg);
|
|
|
rtx (*expand_builtin_saveregs) (void);
|
rtx (*expand_builtin_saveregs) (void);
|
/* Returns pretend_argument_size. */
|
/* Returns pretend_argument_size. */
|
void (*setup_incoming_varargs) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
void (*setup_incoming_varargs) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
tree type, int *pretend_arg_size,
|
tree type, int *pretend_arg_size,
|
int second_time);
|
int second_time);
|
bool (*strict_argument_naming) (CUMULATIVE_ARGS *ca);
|
bool (*strict_argument_naming) (CUMULATIVE_ARGS *ca);
|
/* Returns true if we should use
|
/* Returns true if we should use
|
targetm.calls.setup_incoming_varargs() and/or
|
targetm.calls.setup_incoming_varargs() and/or
|
targetm.calls.strict_argument_naming(). */
|
targetm.calls.strict_argument_naming(). */
|
bool (*pretend_outgoing_varargs_named) (CUMULATIVE_ARGS *ca);
|
bool (*pretend_outgoing_varargs_named) (CUMULATIVE_ARGS *ca);
|
|
|
/* Given a complex type T, return true if a parameter of type T
|
/* Given a complex type T, return true if a parameter of type T
|
should be passed as two scalars. */
|
should be passed as two scalars. */
|
bool (* split_complex_arg) (const_tree type);
|
bool (* split_complex_arg) (const_tree type);
|
|
|
/* Return true if type T, mode MODE, may not be passed in registers,
|
/* Return true if type T, mode MODE, may not be passed in registers,
|
but must be passed on the stack. */
|
but must be passed on the stack. */
|
/* ??? This predicate should be applied strictly after pass-by-reference.
|
/* ??? This predicate should be applied strictly after pass-by-reference.
|
Need audit to verify that this is the case. */
|
Need audit to verify that this is the case. */
|
bool (* must_pass_in_stack) (enum machine_mode mode, const_tree t);
|
bool (* must_pass_in_stack) (enum machine_mode mode, const_tree t);
|
|
|
/* Return true if type TYPE, mode MODE, which is passed by reference,
|
/* Return true if type TYPE, mode MODE, which is passed by reference,
|
should have the object copy generated by the callee rather than
|
should have the object copy generated by the callee rather than
|
the caller. It is never called for TYPE requiring constructors. */
|
the caller. It is never called for TYPE requiring constructors. */
|
bool (* callee_copies) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
bool (* callee_copies) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
const_tree type, bool named);
|
const_tree type, bool named);
|
|
|
/* Return zero for arguments passed entirely on the stack or entirely
|
/* Return zero for arguments passed entirely on the stack or entirely
|
in registers. If passed in both, return the number of bytes passed
|
in registers. If passed in both, return the number of bytes passed
|
in registers; the balance is therefore passed on the stack. */
|
in registers; the balance is therefore passed on the stack. */
|
int (* arg_partial_bytes) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
int (* arg_partial_bytes) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
|
tree type, bool named);
|
tree type, bool named);
|
|
|
/* Return the diagnostic message string if function without a prototype
|
/* Return the diagnostic message string if function without a prototype
|
is not allowed for this 'val' argument; NULL otherwise. */
|
is not allowed for this 'val' argument; NULL otherwise. */
|
const char *(*invalid_arg_for_unprototyped_fn) (const_tree typelist,
|
const char *(*invalid_arg_for_unprototyped_fn) (const_tree typelist,
|
const_tree funcdecl,
|
const_tree funcdecl,
|
const_tree val);
|
const_tree val);
|
|
|
/* Return an rtx for the return value location of the function
|
/* Return an rtx for the return value location of the function
|
specified by FN_DECL_OR_TYPE with a return type of RET_TYPE. */
|
specified by FN_DECL_OR_TYPE with a return type of RET_TYPE. */
|
rtx (*function_value) (const_tree ret_type, const_tree fn_decl_or_type,
|
rtx (*function_value) (const_tree ret_type, const_tree fn_decl_or_type,
|
bool outgoing);
|
bool outgoing);
|
|
|
/* Return the rtx for the result of a libcall of mode MODE,
|
/* Return the rtx for the result of a libcall of mode MODE,
|
calling the function FN_NAME. */
|
calling the function FN_NAME. */
|
rtx (*libcall_value) (enum machine_mode, const_rtx);
|
rtx (*libcall_value) (enum machine_mode, const_rtx);
|
|
|
/* Return an rtx for the argument pointer incoming to the
|
/* Return an rtx for the argument pointer incoming to the
|
current function. */
|
current function. */
|
rtx (*internal_arg_pointer) (void);
|
rtx (*internal_arg_pointer) (void);
|
|
|
/* Update the current function stack boundary if needed. */
|
/* Update the current function stack boundary if needed. */
|
void (*update_stack_boundary) (void);
|
void (*update_stack_boundary) (void);
|
|
|
/* Handle stack alignment and return an rtx for Dynamic Realign
|
/* Handle stack alignment and return an rtx for Dynamic Realign
|
Argument Pointer if necessary. */
|
Argument Pointer if necessary. */
|
rtx (*get_drap_rtx) (void);
|
rtx (*get_drap_rtx) (void);
|
|
|
/* Return true if all function parameters should be spilled to the
|
/* Return true if all function parameters should be spilled to the
|
stack. */
|
stack. */
|
bool (*allocate_stack_slots_for_args) (void);
|
bool (*allocate_stack_slots_for_args) (void);
|
|
|
/* Return an rtx for the static chain for FNDECL. If INCOMING_P is true,
|
/* Return an rtx for the static chain for FNDECL. If INCOMING_P is true,
|
then it should be for the callee; otherwise for the caller. */
|
then it should be for the callee; otherwise for the caller. */
|
rtx (*static_chain) (const_tree fndecl, bool incoming_p);
|
rtx (*static_chain) (const_tree fndecl, bool incoming_p);
|
|
|
/* Fill in the trampoline at MEM with a call to FNDECL and a
|
/* Fill in the trampoline at MEM with a call to FNDECL and a
|
static chain value of CHAIN. */
|
static chain value of CHAIN. */
|
void (*trampoline_init) (rtx mem, tree fndecl, rtx chain);
|
void (*trampoline_init) (rtx mem, tree fndecl, rtx chain);
|
|
|
/* Adjust the address of the trampoline in a target-specific way. */
|
/* Adjust the address of the trampoline in a target-specific way. */
|
rtx (*trampoline_adjust_address) (rtx addr);
|
rtx (*trampoline_adjust_address) (rtx addr);
|
} calls;
|
} calls;
|
|
|
/* Return the diagnostic message string if conversion from FROMTYPE
|
/* Return the diagnostic message string if conversion from FROMTYPE
|
to TOTYPE is not allowed, NULL otherwise. */
|
to TOTYPE is not allowed, NULL otherwise. */
|
const char *(*invalid_conversion) (const_tree fromtype, const_tree totype);
|
const char *(*invalid_conversion) (const_tree fromtype, const_tree totype);
|
|
|
/* Return the diagnostic message string if the unary operation OP is
|
/* Return the diagnostic message string if the unary operation OP is
|
not permitted on TYPE, NULL otherwise. */
|
not permitted on TYPE, NULL otherwise. */
|
const char *(*invalid_unary_op) (int op, const_tree type);
|
const char *(*invalid_unary_op) (int op, const_tree type);
|
|
|
/* Return the diagnostic message string if the binary operation OP
|
/* Return the diagnostic message string if the binary operation OP
|
is not permitted on TYPE1 and TYPE2, NULL otherwise. */
|
is not permitted on TYPE1 and TYPE2, NULL otherwise. */
|
const char *(*invalid_binary_op) (int op, const_tree type1, const_tree type2);
|
const char *(*invalid_binary_op) (int op, const_tree type1, const_tree type2);
|
|
|
/* Return the diagnostic message string if TYPE is not valid as a
|
/* Return the diagnostic message string if TYPE is not valid as a
|
function parameter type, NULL otherwise. */
|
function parameter type, NULL otherwise. */
|
const char *(*invalid_parameter_type) (const_tree type);
|
const char *(*invalid_parameter_type) (const_tree type);
|
|
|
/* Return the diagnostic message string if TYPE is not valid as a
|
/* Return the diagnostic message string if TYPE is not valid as a
|
function return type, NULL otherwise. */
|
function return type, NULL otherwise. */
|
const char *(*invalid_return_type) (const_tree type);
|
const char *(*invalid_return_type) (const_tree type);
|
|
|
/* If values of TYPE are promoted to some other type when used in
|
/* If values of TYPE are promoted to some other type when used in
|
expressions (analogous to the integer promotions), return that type,
|
expressions (analogous to the integer promotions), return that type,
|
or NULL_TREE otherwise. */
|
or NULL_TREE otherwise. */
|
tree (*promoted_type) (const_tree type);
|
tree (*promoted_type) (const_tree type);
|
|
|
/* Convert EXPR to TYPE, if target-specific types with special conversion
|
/* Convert EXPR to TYPE, if target-specific types with special conversion
|
rules are involved. Return the converted expression, or NULL to apply
|
rules are involved. Return the converted expression, or NULL to apply
|
the standard conversion rules. */
|
the standard conversion rules. */
|
tree (*convert_to_type) (tree type, tree expr);
|
tree (*convert_to_type) (tree type, tree expr);
|
|
|
/* Return the array of IRA cover classes for the current target. */
|
/* Return the array of IRA cover classes for the current target. */
|
const enum reg_class *(*ira_cover_classes) (void);
|
const enum reg_class *(*ira_cover_classes) (void);
|
|
|
/* Return the class for a secondary reload, and fill in extra information. */
|
/* Return the class for a secondary reload, and fill in extra information. */
|
enum reg_class (*secondary_reload) (bool, rtx, enum reg_class,
|
enum reg_class (*secondary_reload) (bool, rtx, enum reg_class,
|
enum machine_mode,
|
enum machine_mode,
|
secondary_reload_info *);
|
secondary_reload_info *);
|
|
|
/* This target hook allows the backend to perform additional
|
/* This target hook allows the backend to perform additional
|
processing while initializing for variable expansion. */
|
processing while initializing for variable expansion. */
|
void (* expand_to_rtl_hook) (void);
|
void (* expand_to_rtl_hook) (void);
|
|
|
/* This target hook allows the backend to perform additional
|
/* This target hook allows the backend to perform additional
|
instantiations on rtx that are not actually in insns yet,
|
instantiations on rtx that are not actually in insns yet,
|
but will be later. */
|
but will be later. */
|
void (* instantiate_decls) (void);
|
void (* instantiate_decls) (void);
|
|
|
/* Return true if is OK to use a hard register REGNO as scratch register
|
/* Return true if is OK to use a hard register REGNO as scratch register
|
in peephole2. */
|
in peephole2. */
|
bool (* hard_regno_scratch_ok) (unsigned int regno);
|
bool (* hard_regno_scratch_ok) (unsigned int regno);
|
|
|
/* Return the smallest number of different values for which it is best to
|
/* Return the smallest number of different values for which it is best to
|
use a jump-table instead of a tree of conditional branches. */
|
use a jump-table instead of a tree of conditional branches. */
|
unsigned int (* case_values_threshold) (void);
|
unsigned int (* case_values_threshold) (void);
|
|
|
/* Retutn true if a function must have and use a frame pointer. */
|
/* Retutn true if a function must have and use a frame pointer. */
|
bool (* frame_pointer_required) (void);
|
bool (* frame_pointer_required) (void);
|
|
|
/* Returns true if the compiler is allowed to try to replace register number
|
/* Returns true if the compiler is allowed to try to replace register number
|
from-reg with register number to-reg. */
|
from-reg with register number to-reg. */
|
bool (* can_eliminate) (const int, const int);
|
bool (* can_eliminate) (const int, const int);
|
|
|
/* Functions specific to the C family of frontends. */
|
/* Functions specific to the C family of frontends. */
|
struct c {
|
struct c {
|
/* Return machine mode for non-standard suffix
|
/* Return machine mode for non-standard suffix
|
or VOIDmode if non-standard suffixes are unsupported. */
|
or VOIDmode if non-standard suffixes are unsupported. */
|
enum machine_mode (*mode_for_suffix) (char);
|
enum machine_mode (*mode_for_suffix) (char);
|
} c;
|
} c;
|
|
|
/* Functions specific to the C++ frontend. */
|
/* Functions specific to the C++ frontend. */
|
struct cxx {
|
struct cxx {
|
/* Return the integer type used for guard variables. */
|
/* Return the integer type used for guard variables. */
|
tree (*guard_type) (void);
|
tree (*guard_type) (void);
|
/* Return true if only the low bit of the guard should be tested. */
|
/* Return true if only the low bit of the guard should be tested. */
|
bool (*guard_mask_bit) (void);
|
bool (*guard_mask_bit) (void);
|
/* Returns the size of the array cookie for an array of type. */
|
/* Returns the size of the array cookie for an array of type. */
|
tree (*get_cookie_size) (tree);
|
tree (*get_cookie_size) (tree);
|
/* Returns true if the element size should be stored in the
|
/* Returns true if the element size should be stored in the
|
array cookie. */
|
array cookie. */
|
bool (*cookie_has_size) (void);
|
bool (*cookie_has_size) (void);
|
/* Allows backends to perform additional processing when
|
/* Allows backends to perform additional processing when
|
deciding if a class should be exported or imported. */
|
deciding if a class should be exported or imported. */
|
int (*import_export_class) (tree, int);
|
int (*import_export_class) (tree, int);
|
/* Returns true if constructors and destructors return "this". */
|
/* Returns true if constructors and destructors return "this". */
|
bool (*cdtor_returns_this) (void);
|
bool (*cdtor_returns_this) (void);
|
/* Returns true if the key method for a class can be an inline
|
/* Returns true if the key method for a class can be an inline
|
function, so long as it is not declared inline in the class
|
function, so long as it is not declared inline in the class
|
itself. Returning true is the behavior required by the Itanium
|
itself. Returning true is the behavior required by the Itanium
|
C++ ABI. */
|
C++ ABI. */
|
bool (*key_method_may_be_inline) (void);
|
bool (*key_method_may_be_inline) (void);
|
/* DECL is a virtual table, virtual table table, typeinfo object,
|
/* DECL is a virtual table, virtual table table, typeinfo object,
|
or other similar implicit class data object that will be
|
or other similar implicit class data object that will be
|
emitted with external linkage in this translation unit. No ELF
|
emitted with external linkage in this translation unit. No ELF
|
visibility has been explicitly specified. If the target needs
|
visibility has been explicitly specified. If the target needs
|
to specify a visibility other than that of the containing class,
|
to specify a visibility other than that of the containing class,
|
use this hook to set DECL_VISIBILITY and
|
use this hook to set DECL_VISIBILITY and
|
DECL_VISIBILITY_SPECIFIED. */
|
DECL_VISIBILITY_SPECIFIED. */
|
void (*determine_class_data_visibility) (tree decl);
|
void (*determine_class_data_visibility) (tree decl);
|
/* Returns true (the default) if virtual tables and other
|
/* Returns true (the default) if virtual tables and other
|
similar implicit class data objects are always COMDAT if they
|
similar implicit class data objects are always COMDAT if they
|
have external linkage. If this hook returns false, then
|
have external linkage. If this hook returns false, then
|
class data for classes whose virtual table will be emitted in
|
class data for classes whose virtual table will be emitted in
|
only one translation unit will not be COMDAT. */
|
only one translation unit will not be COMDAT. */
|
bool (*class_data_always_comdat) (void);
|
bool (*class_data_always_comdat) (void);
|
/* Returns true (the default) if the RTTI for the basic types,
|
/* Returns true (the default) if the RTTI for the basic types,
|
which is always defined in the C++ runtime, should be COMDAT;
|
which is always defined in the C++ runtime, should be COMDAT;
|
false if it should not be COMDAT. */
|
false if it should not be COMDAT. */
|
bool (*library_rtti_comdat) (void);
|
bool (*library_rtti_comdat) (void);
|
/* Returns true if __aeabi_atexit should be used to register static
|
/* Returns true if __aeabi_atexit should be used to register static
|
destructors. */
|
destructors. */
|
bool (*use_aeabi_atexit) (void);
|
bool (*use_aeabi_atexit) (void);
|
/* Returns true if target may use atexit in the same manner as
|
/* Returns true if target may use atexit in the same manner as
|
__cxa_atexit to register static destructors. */
|
__cxa_atexit to register static destructors. */
|
bool (*use_atexit_for_cxa_atexit) (void);
|
bool (*use_atexit_for_cxa_atexit) (void);
|
/* TYPE is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that
|
/* TYPE is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that
|
has just been defined. Use this hook to make adjustments to the
|
has just been defined. Use this hook to make adjustments to the
|
class (eg, tweak visibility or perform any other required
|
class (eg, tweak visibility or perform any other required
|
target modifications). */
|
target modifications). */
|
void (*adjust_class_at_definition) (tree type);
|
void (*adjust_class_at_definition) (tree type);
|
} cxx;
|
} cxx;
|
|
|
/* Functions and data for emulated TLS support. */
|
/* Functions and data for emulated TLS support. */
|
struct emutls {
|
struct emutls {
|
/* Name of the address and common functions. */
|
/* Name of the address and common functions. */
|
const char *get_address;
|
const char *get_address;
|
const char *register_common;
|
const char *register_common;
|
|
|
/* Prefixes for proxy variable and template. */
|
/* Prefixes for proxy variable and template. */
|
const char *var_section;
|
const char *var_section;
|
const char *tmpl_section;
|
const char *tmpl_section;
|
|
|
/* Prefixes for proxy variable and template. */
|
/* Prefixes for proxy variable and template. */
|
const char *var_prefix;
|
const char *var_prefix;
|
const char *tmpl_prefix;
|
const char *tmpl_prefix;
|
|
|
/* Function to generate field definitions of the proxy variable. */
|
/* Function to generate field definitions of the proxy variable. */
|
tree (*var_fields) (tree, tree *);
|
tree (*var_fields) (tree, tree *);
|
|
|
/* Function to initialize a proxy variable. */
|
/* Function to initialize a proxy variable. */
|
tree (*var_init) (tree, tree, tree);
|
tree (*var_init) (tree, tree, tree);
|
|
|
/* Whether we are allowed to alter the usual alignment of the
|
/* Whether we are allowed to alter the usual alignment of the
|
proxy variable. */
|
proxy variable. */
|
bool var_align_fixed;
|
bool var_align_fixed;
|
|
|
/* Whether we can emit debug information for TLS vars. */
|
/* Whether we can emit debug information for TLS vars. */
|
bool debug_form_tls_address;
|
bool debug_form_tls_address;
|
} emutls;
|
} emutls;
|
|
|
struct target_option_hooks {
|
struct target_option_hooks {
|
/* Function to validate the attribute((option(...))) strings or NULL. If
|
/* Function to validate the attribute((option(...))) strings or NULL. If
|
the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will
|
the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will
|
be filled in in the function decl node. */
|
be filled in in the function decl node. */
|
bool (*valid_attribute_p) (tree, tree, tree, int);
|
bool (*valid_attribute_p) (tree, tree, tree, int);
|
|
|
/* Function to save any extra target state in the target options
|
/* Function to save any extra target state in the target options
|
structure. */
|
structure. */
|
void (*save) (struct cl_target_option *);
|
void (*save) (struct cl_target_option *);
|
|
|
/* Function to restore any extra target state from the target options
|
/* Function to restore any extra target state from the target options
|
structure. */
|
structure. */
|
void (*restore) (struct cl_target_option *);
|
void (*restore) (struct cl_target_option *);
|
|
|
/* Function to print any extra target state from the target options
|
/* Function to print any extra target state from the target options
|
structure. */
|
structure. */
|
void (*print) (FILE *, int, struct cl_target_option *);
|
void (*print) (FILE *, int, struct cl_target_option *);
|
|
|
/* Function to parse arguments to be validated for #pragma option, and to
|
/* Function to parse arguments to be validated for #pragma option, and to
|
change the state if the options are valid. If the first argument is
|
change the state if the options are valid. If the first argument is
|
NULL, the second argument specifies the default options to use. Return
|
NULL, the second argument specifies the default options to use. Return
|
true if the options are valid, and set the current state. */
|
true if the options are valid, and set the current state. */
|
bool (*pragma_parse) (tree, tree);
|
bool (*pragma_parse) (tree, tree);
|
|
|
/* Function to determine if one function can inline another function. */
|
/* Function to determine if one function can inline another function. */
|
bool (*can_inline_p) (tree, tree);
|
bool (*can_inline_p) (tree, tree);
|
} target_option;
|
} target_option;
|
|
|
/* For targets that need to mark extra registers as live on entry to
|
/* For targets that need to mark extra registers as live on entry to
|
the function, they should define this target hook and set their
|
the function, they should define this target hook and set their
|
bits in the bitmap passed in. */
|
bits in the bitmap passed in. */
|
void (*live_on_entry) (bitmap);
|
void (*live_on_entry) (bitmap);
|
|
|
/* True if unwinding tables should be generated by default. */
|
/* True if unwinding tables should be generated by default. */
|
bool unwind_tables_default;
|
bool unwind_tables_default;
|
|
|
/* Leave the boolean fields at the end. */
|
/* Leave the boolean fields at the end. */
|
|
|
/* True if arbitrary sections are supported. */
|
/* True if arbitrary sections are supported. */
|
bool have_named_sections;
|
bool have_named_sections;
|
|
|
/* True if we can create zeroed data by switching to a BSS section
|
/* True if we can create zeroed data by switching to a BSS section
|
and then using ASM_OUTPUT_SKIP to allocate the space. */
|
and then using ASM_OUTPUT_SKIP to allocate the space. */
|
bool have_switchable_bss_sections;
|
bool have_switchable_bss_sections;
|
|
|
/* True if "native" constructors and destructors are supported,
|
/* True if "native" constructors and destructors are supported,
|
false if we're using collect2 for the job. */
|
false if we're using collect2 for the job. */
|
bool have_ctors_dtors;
|
bool have_ctors_dtors;
|
|
|
/* True if thread-local storage is supported. */
|
/* True if thread-local storage is supported. */
|
bool have_tls;
|
bool have_tls;
|
|
|
/* True if a small readonly data section is supported. */
|
/* True if a small readonly data section is supported. */
|
bool have_srodata_section;
|
bool have_srodata_section;
|
|
|
/* True if EH frame info sections should be zero-terminated. */
|
/* True if EH frame info sections should be zero-terminated. */
|
bool terminate_dw2_eh_frame_info;
|
bool terminate_dw2_eh_frame_info;
|
|
|
/* True if #NO_APP should be emitted at the beginning of
|
/* True if #NO_APP should be emitted at the beginning of
|
assembly output. */
|
assembly output. */
|
bool file_start_app_off;
|
bool file_start_app_off;
|
|
|
/* True if output_file_directive should be called for main_input_filename
|
/* True if output_file_directive should be called for main_input_filename
|
at the beginning of assembly output. */
|
at the beginning of assembly output. */
|
bool file_start_file_directive;
|
bool file_start_file_directive;
|
|
|
/* True if #pragma extern_prefix is to be supported. */
|
/* True if #pragma extern_prefix is to be supported. */
|
bool handle_pragma_extern_prefix;
|
bool handle_pragma_extern_prefix;
|
|
|
/* True if the target is allowed to reorder memory accesses unless
|
/* True if the target is allowed to reorder memory accesses unless
|
synchronization is explicitly requested. */
|
synchronization is explicitly requested. */
|
bool relaxed_ordering;
|
bool relaxed_ordering;
|
|
|
/* Returns true if we should generate exception tables for use with the
|
/* Returns true if we should generate exception tables for use with the
|
ARM EABI. The effects the encoding of function exception specifications.
|
ARM EABI. The effects the encoding of function exception specifications.
|
*/
|
*/
|
bool arm_eabi_unwinder;
|
bool arm_eabi_unwinder;
|
|
|
/* Leave the boolean fields at the end. */
|
/* Leave the boolean fields at the end. */
|
};
|
};
|
|
|
extern struct gcc_target targetm;
|
extern struct gcc_target targetm;
|
|
|
struct gcc_targetcm {
|
struct gcc_targetcm {
|
/* Handle target switch CODE (an OPT_* value). ARG is the argument
|
/* Handle target switch CODE (an OPT_* value). ARG is the argument
|
passed to the switch; it is NULL if no argument was. VALUE is the
|
passed to the switch; it is NULL if no argument was. VALUE is the
|
value of ARG if CODE specifies a UInteger option, otherwise it is
|
value of ARG if CODE specifies a UInteger option, otherwise it is
|
1 if the positive form of the switch was used and 0 if the negative
|
1 if the positive form of the switch was used and 0 if the negative
|
form was. Return true if the switch was valid. */
|
form was. Return true if the switch was valid. */
|
bool (*handle_c_option) (size_t code, const char *arg, int value);
|
bool (*handle_c_option) (size_t code, const char *arg, int value);
|
};
|
};
|
|
|
/* Each target can provide their own. */
|
/* Each target can provide their own. */
|
extern struct gcc_targetcm targetcm;
|
extern struct gcc_targetcm targetcm;
|
|
|
#endif /* GCC_TARGET_H */
|
#endif /* GCC_TARGET_H */
|
|
|
