LCOV - code coverage report
Current view: top level - gcc - target.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 11 11 100.0 %
Date: 2020-04-04 11:58:09 Functions: 0 0 -
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Data structure definitions for a generic GCC target.
       2                 :            :    Copyright (C) 2001-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            :    This program is free software; you can redistribute it and/or modify it
       5                 :            :    under the terms of the GNU General Public License as published by the
       6                 :            :    Free Software Foundation; either version 3, or (at your option) any
       7                 :            :    later version.
       8                 :            : 
       9                 :            :    This program is distributed in the hope that it will be useful,
      10                 :            :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      11                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12                 :            :    GNU General Public License for more details.
      13                 :            : 
      14                 :            :    You should have received a copy of the GNU General Public License
      15                 :            :    along with this program; see the file COPYING3.  If not see
      16                 :            :    <http://www.gnu.org/licenses/>.
      17                 :            : 
      18                 :            :    In other words, you are welcome to use, share and improve this program.
      19                 :            :    You are forbidden to forbid anyone else to use, share and improve
      20                 :            :    what you give them.   Help stamp out software-hoarding!  */
      21                 :            : 
      22                 :            : 
      23                 :            : /* This file contains a data structure that describes a GCC target.
      24                 :            :    At present it is incomplete, but in future it should grow to
      25                 :            :    contain most or all target machine and target O/S specific
      26                 :            :    information.
      27                 :            : 
      28                 :            :    This structure has its initializer declared in target-def.h in the
      29                 :            :    form of large macro TARGET_INITIALIZER that expands to many smaller
      30                 :            :    macros.
      31                 :            : 
      32                 :            :    The smaller macros each initialize one component of the structure,
      33                 :            :    and each has a default.  Each target should have a file that
      34                 :            :    includes target.h and target-def.h, and overrides any inappropriate
      35                 :            :    defaults by undefining the relevant macro and defining a suitable
      36                 :            :    replacement.  That file should then contain the definition of
      37                 :            :    "targetm" like so:
      38                 :            : 
      39                 :            :    struct gcc_target targetm = TARGET_INITIALIZER;
      40                 :            : 
      41                 :            :    Doing things this way allows us to bring together everything that
      42                 :            :    defines a GCC target.  By supplying a default that is appropriate
      43                 :            :    to most targets, we can easily add new items without needing to
      44                 :            :    edit dozens of target configuration files.  It should also allow us
      45                 :            :    to gradually reduce the amount of conditional compilation that is
      46                 :            :    scattered throughout GCC.  */
      47                 :            : 
      48                 :            : #ifndef GCC_TARGET_H
      49                 :            : #define GCC_TARGET_H
      50                 :            : 
      51                 :            : #include "insn-codes.h"
      52                 :            : #include "tm.h"
      53                 :            : #include "hard-reg-set.h"
      54                 :            : 
      55                 :            : #if CHECKING_P
      56                 :            : 
      57                 :            : struct cumulative_args_t { void *magic; void *p; };
      58                 :            : 
      59                 :            : #else /* !CHECKING_P */
      60                 :            : 
      61                 :            : /* When using a GCC build compiler, we could use
      62                 :            :    __attribute__((transparent_union)) to get cumulative_args_t function
      63                 :            :    arguments passed like scalars where the ABI would mandate a less
      64                 :            :    efficient way of argument passing otherwise.  However, that would come
      65                 :            :    at the cost of less type-safe !CHECKING_P compilation.  */
      66                 :            : 
      67                 :            : union cumulative_args_t { void *p; };
      68                 :            : 
      69                 :            : #endif /* !CHECKING_P */
      70                 :            : 
      71                 :            : /* Types used by the record_gcc_switches() target function.  */
      72                 :            : enum print_switch_type
      73                 :            : {
      74                 :            :   SWITCH_TYPE_PASSED,           /* A switch passed on the command line.  */
      75                 :            :   SWITCH_TYPE_ENABLED,          /* An option that is currently enabled.  */
      76                 :            :   SWITCH_TYPE_DESCRIPTIVE,      /* Descriptive text, not a switch or option.  */
      77                 :            :   SWITCH_TYPE_LINE_START,       /* Please emit any necessary text at the start of a line.  */
      78                 :            :   SWITCH_TYPE_LINE_END          /* Please emit a line terminator.  */
      79                 :            : };
      80                 :            : 
      81                 :            : /* Types of memory operation understood by the "by_pieces" infrastructure.
      82                 :            :    Used by the TARGET_USE_BY_PIECES_INFRASTRUCTURE_P target hook and
      83                 :            :    internally by the functions in expr.c.  */
      84                 :            : 
      85                 :            : enum by_pieces_operation
      86                 :            : {
      87                 :            :   CLEAR_BY_PIECES,
      88                 :            :   MOVE_BY_PIECES,
      89                 :            :   SET_BY_PIECES,
      90                 :            :   STORE_BY_PIECES,
      91                 :            :   COMPARE_BY_PIECES
      92                 :            : };
      93                 :            : 
      94                 :            : extern unsigned HOST_WIDE_INT by_pieces_ninsns (unsigned HOST_WIDE_INT,
      95                 :            :                                                 unsigned int,
      96                 :            :                                                 unsigned int,
      97                 :            :                                                 by_pieces_operation);
      98                 :            : 
      99                 :            : typedef int (* print_switch_fn_type) (print_switch_type, const char *);
     100                 :            : 
     101                 :            : /* An example implementation for ELF targets.  Defined in varasm.c  */
     102                 :            : extern int elf_record_gcc_switches (print_switch_type type, const char *);
     103                 :            : 
     104                 :            : /* Some places still assume that all pointer or address modes are the
     105                 :            :    standard Pmode and ptr_mode.  These optimizations become invalid if
     106                 :            :    the target actually supports multiple different modes.  For now,
     107                 :            :    we disable such optimizations on such targets, using this function.  */
     108                 :            : extern bool target_default_pointer_address_modes_p (void);
     109                 :            : 
     110                 :            : /* For hooks which use the MOVE_RATIO macro, this gives the legacy default
     111                 :            :    behavior.  */
     112                 :            : extern unsigned int get_move_ratio (bool);
     113                 :            : 
     114                 :            : struct stdarg_info;
     115                 :            : struct spec_info_def;
     116                 :            : struct hard_reg_set_container;
     117                 :            : struct cgraph_node;
     118                 :            : struct cgraph_simd_clone;
     119                 :            : 
     120                 :            : /* The struct used by the secondary_reload target hook.  */
     121                 :            : struct secondary_reload_info
     122                 :            : {
     123                 :            :   /* icode is actually an enum insn_code, but we don't want to force every
     124                 :            :      file that includes target.h to include optabs.h .  */
     125                 :            :   int icode;
     126                 :            :   int extra_cost; /* Cost for using (a) scratch register(s) to be taken
     127                 :            :                      into account by copy_cost.  */
     128                 :            :   /* The next two members are for the use of the backward
     129                 :            :      compatibility hook.  */
     130                 :            :   struct secondary_reload_info *prev_sri;
     131                 :            :   int t_icode; /* Actually an enum insn_code - see above.  */
     132                 :            : };
     133                 :            : 
     134                 :            : /* This is defined in sched-int.h .  */
     135                 :            : struct _dep;
     136                 :            : 
     137                 :            : /* This is defined in ddg.h .  */
     138                 :            : struct ddg;
     139                 :            : 
     140                 :            : /* This is defined in cfgloop.h .  */
     141                 :            : class loop;
     142                 :            : 
     143                 :            : /* This is defined in ifcvt.h.  */
     144                 :            : struct noce_if_info;
     145                 :            : 
     146                 :            : /* This is defined in tree-ssa-alias.h.  */
     147                 :            : class ao_ref;
     148                 :            : 
     149                 :            : /* This is defined in tree-vectorizer.h.  */
     150                 :            : class _stmt_vec_info;
     151                 :            : 
     152                 :            : /* This is defined in calls.h.  */
     153                 :            : class function_arg_info;
     154                 :            : 
     155                 :            : /* This is defined in function-abi.h.  */
     156                 :            : class predefined_function_abi;
     157                 :            : 
     158                 :            : /* These are defined in tree-vect-stmts.c.  */
     159                 :            : extern tree stmt_vectype (class _stmt_vec_info *);
     160                 :            : extern bool stmt_in_inner_loop_p (class _stmt_vec_info *);
     161                 :            : 
     162                 :            : /* Assembler instructions for creating various kinds of integer object.  */
     163                 :            : 
     164                 :            : struct asm_int_op
     165                 :            : {
     166                 :            :   const char *hi;
     167                 :            :   const char *psi;
     168                 :            :   const char *si;
     169                 :            :   const char *pdi;
     170                 :            :   const char *di;
     171                 :            :   const char *pti;
     172                 :            :   const char *ti;
     173                 :            : };
     174                 :            : 
     175                 :            : /* Types of costs for vectorizer cost model.  */
     176                 :            : enum vect_cost_for_stmt
     177                 :            : {
     178                 :            :   scalar_stmt,
     179                 :            :   scalar_load,
     180                 :            :   scalar_store,
     181                 :            :   vector_stmt,
     182                 :            :   vector_load,
     183                 :            :   vector_gather_load,
     184                 :            :   unaligned_load,
     185                 :            :   unaligned_store,
     186                 :            :   vector_store,
     187                 :            :   vector_scatter_store,
     188                 :            :   vec_to_scalar,
     189                 :            :   scalar_to_vec,
     190                 :            :   cond_branch_not_taken,
     191                 :            :   cond_branch_taken,
     192                 :            :   vec_perm,
     193                 :            :   vec_promote_demote,
     194                 :            :   vec_construct
     195                 :            : };
     196                 :            : 
     197                 :            : /* Separate locations for which the vectorizer cost model should
     198                 :            :    track costs.  */
     199                 :            : enum vect_cost_model_location {
     200                 :            :   vect_prologue = 0,
     201                 :            :   vect_body = 1,
     202                 :            :   vect_epilogue = 2
     203                 :            : };
     204                 :            : 
     205                 :            : class vec_perm_indices;
     206                 :            : 
     207                 :            : /* The type to use for lists of vector sizes.  */
     208                 :            : typedef vec<machine_mode> vector_modes;
     209                 :            : 
     210                 :            : /* Same, but can be used to construct local lists that are
     211                 :            :    automatically freed.  */
     212                 :            : typedef auto_vec<machine_mode, 8> auto_vector_modes;
     213                 :            : 
     214                 :            : /* First argument of targetm.omp.device_kind_arch_isa.  */
     215                 :            : enum omp_device_kind_arch_isa {
     216                 :            :   omp_device_kind,
     217                 :            :   omp_device_arch,
     218                 :            :   omp_device_isa
     219                 :            : };
     220                 :            : 
     221                 :            : /* Flags returned by TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES:
     222                 :            : 
     223                 :            :    VECT_COMPARE_COSTS
     224                 :            :        Tells the loop vectorizer to try all the provided modes and
     225                 :            :        pick the one with the lowest cost.  By default the vectorizer
     226                 :            :        will choose the first mode that works.  */
     227                 :            : const unsigned int VECT_COMPARE_COSTS = 1U << 0;
     228                 :            : 
     229                 :            : /* The contexts in which the use of a type T can be checked by
     230                 :            :    TARGET_VERIFY_TYPE_CONTEXT.  */
     231                 :            : enum type_context_kind {
     232                 :            :   /* Directly measuring the size of T.  */
     233                 :            :   TCTX_SIZEOF,
     234                 :            : 
     235                 :            :   /* Directly measuring the alignment of T.  */
     236                 :            :   TCTX_ALIGNOF,
     237                 :            : 
     238                 :            :   /* Creating objects of type T with static storage duration.  */
     239                 :            :   TCTX_STATIC_STORAGE,
     240                 :            : 
     241                 :            :   /* Creating objects of type T with thread-local storage duration.  */
     242                 :            :   TCTX_THREAD_STORAGE,
     243                 :            : 
     244                 :            :   /* Creating a field of type T.  */
     245                 :            :   TCTX_FIELD,
     246                 :            : 
     247                 :            :   /* Creating an array with elements of type T.  */
     248                 :            :   TCTX_ARRAY_ELEMENT,
     249                 :            : 
     250                 :            :   /* Adding to or subtracting from a pointer to T, or computing the
     251                 :            :      difference between two pointers when one of them is a pointer to T.  */
     252                 :            :   TCTX_POINTER_ARITH,
     253                 :            : 
     254                 :            :   /* Dynamically allocating objects of type T.  */
     255                 :            :   TCTX_ALLOCATION,
     256                 :            : 
     257                 :            :   /* Dynamically deallocating objects of type T.  */
     258                 :            :   TCTX_DEALLOCATION,
     259                 :            : 
     260                 :            :   /* Throwing or catching an object of type T.  */
     261                 :            :   TCTX_EXCEPTIONS,
     262                 :            : 
     263                 :            :   /* Capturing objects of type T by value in a closure.  */
     264                 :            :   TCTX_CAPTURE_BY_COPY
     265                 :            : };
     266                 :            : 
     267                 :            : extern bool verify_type_context (location_t, type_context_kind, const_tree,
     268                 :            :                                  bool = false);
     269                 :            : 
     270                 :            : /* The target structure.  This holds all the backend hooks.  */
     271                 :            : #define DEFHOOKPOD(NAME, DOC, TYPE, INIT) TYPE NAME;
     272                 :            : #define DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT) TYPE (* NAME) PARAMS;
     273                 :            : #define DEFHOOK_UNDOC DEFHOOK
     274                 :            : #define HOOKSTRUCT(FRAGMENT) FRAGMENT
     275                 :            : 
     276                 :            : #include "target.def"
     277                 :            : 
     278                 :            : extern struct gcc_target targetm;
     279                 :            : 
     280                 :            : /* Return an estimate of the runtime value of X, for use in things
     281                 :            :    like cost calculations or profiling frequencies.  Note that this
     282                 :            :    function should never be used in situations where the actual
     283                 :            :    runtime value is needed for correctness, since the function only
     284                 :            :    provides a rough guess.  */
     285                 :            : 
     286                 :            : static inline HOST_WIDE_INT
     287                 : 9012312352 : estimated_poly_value (poly_int64 x)
     288                 :            : {
     289                 : 9012312352 :   if (NUM_POLY_INT_COEFFS == 1)
     290                 : 9008214632 :     return x.coeffs[0];
     291                 :            :   else
     292                 :            :     return targetm.estimated_poly_value (x);
     293                 :            : }
     294                 :            : 
     295                 :            : #ifdef GCC_TM_H
     296                 :            : 
     297                 :            : #ifndef CUMULATIVE_ARGS_MAGIC
     298                 :            : #define CUMULATIVE_ARGS_MAGIC ((void *) &targetm.calls)
     299                 :            : #endif
     300                 :            : 
     301                 :            : static inline CUMULATIVE_ARGS *
     302                 :   53935020 : get_cumulative_args (cumulative_args_t arg)
     303                 :            : {
     304                 :            : #if CHECKING_P
     305                 :   53935020 :   gcc_assert (arg.magic == CUMULATIVE_ARGS_MAGIC);
     306                 :            : #endif /* CHECKING_P */
     307                 :   53935020 :   return (CUMULATIVE_ARGS *) arg.p;
     308                 :            : }
     309                 :            : 
     310                 :            : static inline cumulative_args_t
     311                 :   22550730 : pack_cumulative_args (CUMULATIVE_ARGS *arg)
     312                 :            : {
     313                 :   22550730 :   cumulative_args_t ret;
     314                 :            : 
     315                 :            : #if CHECKING_P
     316                 :   22550730 :   ret.magic = CUMULATIVE_ARGS_MAGIC;
     317                 :            : #endif /* CHECKING_P */
     318                 :   22550730 :   ret.p = (void *) arg;
     319                 :   22550730 :   return ret;
     320                 :            : }
     321                 :            : #endif /* GCC_TM_H */
     322                 :            : 
     323                 :            : #endif /* GCC_TARGET_H */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.