LCOV - code coverage report
Current view: top level - gcc/config/i386 - x86-tune-sched.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 172 272 63.2 %
Date: 2020-03-28 11:57:23 Functions: 6 9 66.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Scheduler hooks for IA-32 which implement CPU specific logic.
       2                 :            :    Copyright (C) 1988-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify
       7                 :            : it under the terms of the GNU General Public License as published by
       8                 :            : the Free Software Foundation; either version 3, or (at your option)
       9                 :            : any later version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful,
      12                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            : GNU General Public License for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #define IN_TARGET_CODE 1
      21                 :            : 
      22                 :            : #include "config.h"
      23                 :            : #include "system.h"
      24                 :            : #include "coretypes.h"
      25                 :            : #include "backend.h"
      26                 :            : #include "rtl.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "cfghooks.h"
      29                 :            : #include "tm_p.h"
      30                 :            : #include "target.h"
      31                 :            : #include "insn-config.h"
      32                 :            : #include "insn-attr.h"
      33                 :            : #include "insn-opinit.h"
      34                 :            : #include "recog.h"
      35                 :            : 
      36                 :            : /* Return the maximum number of instructions a cpu can issue.  */
      37                 :            : 
      38                 :            : int
      39                 :   25219700 : ix86_issue_rate (void)
      40                 :            : {
      41                 :   25219700 :   switch (ix86_tune)
      42                 :            :     {
      43                 :            :     case PROCESSOR_PENTIUM:
      44                 :            :     case PROCESSOR_LAKEMONT:
      45                 :            :     case PROCESSOR_BONNELL:
      46                 :            :     case PROCESSOR_SILVERMONT:
      47                 :            :     case PROCESSOR_KNL:
      48                 :            :     case PROCESSOR_KNM:
      49                 :            :     case PROCESSOR_INTEL:
      50                 :            :     case PROCESSOR_K6:
      51                 :            :     case PROCESSOR_BTVER2:
      52                 :            :     case PROCESSOR_PENTIUM4:
      53                 :            :     case PROCESSOR_NOCONA:
      54                 :            :       return 2;
      55                 :            : 
      56                 :     139530 :     case PROCESSOR_PENTIUMPRO:
      57                 :     139530 :     case PROCESSOR_ATHLON:
      58                 :     139530 :     case PROCESSOR_K8:
      59                 :     139530 :     case PROCESSOR_AMDFAM10:
      60                 :     139530 :     case PROCESSOR_BTVER1:
      61                 :     139530 :       return 3;
      62                 :            : 
      63                 :   25055400 :     case PROCESSOR_BDVER1:
      64                 :   25055400 :     case PROCESSOR_BDVER2:
      65                 :   25055400 :     case PROCESSOR_BDVER3:
      66                 :   25055400 :     case PROCESSOR_BDVER4:
      67                 :   25055400 :     case PROCESSOR_ZNVER1:
      68                 :   25055400 :     case PROCESSOR_ZNVER2:
      69                 :   25055400 :     case PROCESSOR_CORE2:
      70                 :   25055400 :     case PROCESSOR_NEHALEM:
      71                 :   25055400 :     case PROCESSOR_SANDYBRIDGE:
      72                 :   25055400 :     case PROCESSOR_HASWELL:
      73                 :   25055400 :     case PROCESSOR_GENERIC:
      74                 :   25055400 :       return 4;
      75                 :            : 
      76                 :      14883 :     default:
      77                 :      14883 :       return 1;
      78                 :            :     }
      79                 :            : }
      80                 :            : 
      81                 :            : /* Return true iff USE_INSN has a memory address with operands set by
      82                 :            :    SET_INSN.  */
      83                 :            : 
      84                 :            : bool
      85                 :    7638270 : ix86_agi_dependent (rtx_insn *set_insn, rtx_insn *use_insn)
      86                 :            : {
      87                 :    7638270 :   int i;
      88                 :    7638270 :   extract_insn_cached (use_insn);
      89                 :    9503970 :   for (i = recog_data.n_operands - 1; i >= 0; --i)
      90                 :    9164850 :     if (MEM_P (recog_data.operand[i]))
      91                 :            :       {
      92                 :    7299160 :         rtx addr = XEXP (recog_data.operand[i], 0);
      93                 :    7299160 :         if (modified_in_p (addr, set_insn) != 0)
      94                 :            :           {
      95                 :            :             /* No AGI stall if SET_INSN is a push or pop and USE_INSN
      96                 :            :                has SP based memory (unless index reg is modified in a pop).  */
      97                 :    3371470 :             rtx set = single_set (set_insn);
      98                 :    3371470 :             if (set
      99                 :    3371470 :                 && (push_operand (SET_DEST (set), GET_MODE (SET_DEST (set)))
     100                 :    2498310 :                     || pop_operand (SET_SRC (set), GET_MODE (SET_SRC (set)))))
     101                 :            :               {
     102                 :     684400 :                 struct ix86_address parts;
     103                 :     684400 :                 if (ix86_decompose_address (addr, &parts)
     104                 :     684400 :                     && parts.base == stack_pointer_rtx
     105                 :    1368640 :                     && (parts.index == NULL_RTX
     106                 :        352 :                         || MEM_P (SET_DEST (set))
     107                 :          0 :                         || !modified_in_p (parts.index, set_insn)))
     108                 :     684239 :                   return false;
     109                 :            :               }
     110                 :    2687230 :             return true;
     111                 :            :           }
     112                 :            :         return false;
     113                 :            :       }
     114                 :            :   return false;
     115                 :            : }
     116                 :            : 
     117                 :            : /* A subroutine of ix86_adjust_cost -- return TRUE iff INSN reads flags set
     118                 :            :    by DEP_INSN and nothing set by DEP_INSN.  */
     119                 :            : 
     120                 :            : static bool
     121                 :          0 : ix86_flags_dependent (rtx_insn *insn, rtx_insn *dep_insn, enum attr_type insn_type)
     122                 :            : {
     123                 :          0 :   rtx set, set2;
     124                 :            : 
     125                 :            :   /* Simplify the test for uninteresting insns.  */
     126                 :          0 :   if (insn_type != TYPE_SETCC
     127                 :          0 :       && insn_type != TYPE_ICMOV
     128                 :          0 :       && insn_type != TYPE_FCMOV
     129                 :          0 :       && insn_type != TYPE_IBR)
     130                 :            :     return false;
     131                 :            : 
     132                 :          0 :   if ((set = single_set (dep_insn)) != 0)
     133                 :            :     {
     134                 :          0 :       set = SET_DEST (set);
     135                 :          0 :       set2 = NULL_RTX;
     136                 :            :     }
     137                 :          0 :   else if (GET_CODE (PATTERN (dep_insn)) == PARALLEL
     138                 :          0 :            && XVECLEN (PATTERN (dep_insn), 0) == 2
     139                 :          0 :            && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 0)) == SET
     140                 :          0 :            && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 1)) == SET)
     141                 :            :     {
     142                 :          0 :       set = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
     143                 :          0 :       set2 = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
     144                 :            :     }
     145                 :            :   else
     146                 :            :     return false;
     147                 :            : 
     148                 :          0 :   if (!REG_P (set) || REGNO (set) != FLAGS_REG)
     149                 :            :     return false;
     150                 :            : 
     151                 :            :   /* This test is true if the dependent insn reads the flags but
     152                 :            :      not any other potentially set register.  */
     153                 :          0 :   if (!reg_overlap_mentioned_p (set, PATTERN (insn)))
     154                 :            :     return false;
     155                 :            : 
     156                 :          0 :   if (set2 && reg_overlap_mentioned_p (set2, PATTERN (insn)))
     157                 :          0 :     return false;
     158                 :            : 
     159                 :            :   return true;
     160                 :            : }
     161                 :            : 
     162                 :            : /* Helper function for exact_store_load_dependency.
     163                 :            :    Return true if addr is found in insn.  */
     164                 :            : static bool
     165                 :          0 : exact_dependency_1 (rtx addr, rtx insn)
     166                 :            : {
     167                 :          0 :   enum rtx_code code;
     168                 :          0 :   const char *format_ptr;
     169                 :          0 :   int i, j;
     170                 :            : 
     171                 :          0 :   code = GET_CODE (insn);
     172                 :          0 :   switch (code)
     173                 :            :     {
     174                 :          0 :     case MEM:
     175                 :          0 :       if (rtx_equal_p (addr, insn))
     176                 :            :         return true;
     177                 :            :       break;
     178                 :            :     case REG:
     179                 :            :     CASE_CONST_ANY:
     180                 :            :     case SYMBOL_REF:
     181                 :            :     case CODE_LABEL:
     182                 :            :     case PC:
     183                 :            :     case CC0:
     184                 :            :     case EXPR_LIST:
     185                 :            :       return false;
     186                 :            :     default:
     187                 :            :       break;
     188                 :            :     }
     189                 :            : 
     190                 :          0 :   format_ptr = GET_RTX_FORMAT (code);
     191                 :          0 :   for (i = 0; i < GET_RTX_LENGTH (code); i++)
     192                 :            :     {
     193                 :          0 :       switch (*format_ptr++)
     194                 :            :         {
     195                 :          0 :         case 'e':
     196                 :          0 :           if (exact_dependency_1 (addr, XEXP (insn, i)))
     197                 :            :             return true;
     198                 :            :           break;
     199                 :            :         case 'E':
     200                 :          0 :           for (j = 0; j < XVECLEN (insn, i); j++)
     201                 :          0 :             if (exact_dependency_1 (addr, XVECEXP (insn, i, j)))
     202                 :            :               return true;
     203                 :            :           break;
     204                 :            :         }
     205                 :            :     }
     206                 :            :   return false;
     207                 :            : }
     208                 :            : 
     209                 :            : /* Return true if there exists exact dependency for store & load, i.e.
     210                 :            :    the same memory address is used in them.  */
     211                 :            : static bool
     212                 :          0 : exact_store_load_dependency (rtx_insn *store, rtx_insn *load)
     213                 :            : {
     214                 :          0 :   rtx set1, set2;
     215                 :            : 
     216                 :          0 :   set1 = single_set (store);
     217                 :          0 :   if (!set1)
     218                 :            :     return false;
     219                 :          0 :   if (!MEM_P (SET_DEST (set1)))
     220                 :            :     return false;
     221                 :          0 :   set2 = single_set (load);
     222                 :          0 :   if (!set2)
     223                 :            :     return false;
     224                 :          0 :   if (exact_dependency_1 (SET_DEST (set1), SET_SRC (set2)))
     225                 :          0 :     return true;
     226                 :            :   return false;
     227                 :            : }
     228                 :            : 
     229                 :            : 
     230                 :            : /* This function corrects the value of COST (latency) based on the relationship
     231                 :            :    between INSN and DEP_INSN through a dependence of type DEP_TYPE, and strength
     232                 :            :    DW.  It should return the new value.
     233                 :            : 
     234                 :            :    On x86 CPUs this is most commonly used to model the fact that valus of
     235                 :            :    registers used to compute address of memory operand  needs to be ready
     236                 :            :    earlier than values of registers used in the actual operation.  */
     237                 :            : 
     238                 :            : int
     239                 :  101485000 : ix86_adjust_cost (rtx_insn *insn, int dep_type, rtx_insn *dep_insn, int cost,
     240                 :            :                   unsigned int)
     241                 :            : {
     242                 :  101485000 :   enum attr_type insn_type, dep_insn_type;
     243                 :  101485000 :   enum attr_memory memory;
     244                 :  101485000 :   rtx set, set2;
     245                 :  101485000 :   int dep_insn_code_number;
     246                 :            : 
     247                 :            :   /* Anti and output dependencies have zero cost on all CPUs.  */
     248                 :  101485000 :   if (dep_type != 0)
     249                 :            :     return 0;
     250                 :            : 
     251                 :   40066000 :   dep_insn_code_number = recog_memoized (dep_insn);
     252                 :            : 
     253                 :            :   /* If we can't recognize the insns, we can't really do anything.  */
     254                 :   79810800 :   if (dep_insn_code_number < 0 || recog_memoized (insn) < 0)
     255                 :     321133 :     return cost;
     256                 :            : 
     257                 :   39744800 :   insn_type = get_attr_type (insn);
     258                 :   39744800 :   dep_insn_type = get_attr_type (dep_insn);
     259                 :            : 
     260                 :   39744800 :   switch (ix86_tune)
     261                 :            :     {
     262                 :          0 :     case PROCESSOR_PENTIUM:
     263                 :          0 :     case PROCESSOR_LAKEMONT:
     264                 :            :       /* Address Generation Interlock adds a cycle of latency.  */
     265                 :          0 :       if (insn_type == TYPE_LEA)
     266                 :            :         {
     267                 :          0 :           rtx addr = PATTERN (insn);
     268                 :            : 
     269                 :          0 :           if (GET_CODE (addr) == PARALLEL)
     270                 :          0 :             addr = XVECEXP (addr, 0, 0);
     271                 :            : 
     272                 :          0 :           gcc_assert (GET_CODE (addr) == SET);
     273                 :            : 
     274                 :          0 :           addr = SET_SRC (addr);
     275                 :          0 :           if (modified_in_p (addr, dep_insn))
     276                 :          0 :             cost += 1;
     277                 :            :         }
     278                 :          0 :       else if (ix86_agi_dependent (dep_insn, insn))
     279                 :          0 :         cost += 1;
     280                 :            : 
     281                 :            :       /* ??? Compares pair with jump/setcc.  */
     282                 :          0 :       if (ix86_flags_dependent (insn, dep_insn, insn_type))
     283                 :          0 :         cost = 0;
     284                 :            : 
     285                 :            :       /* Floating point stores require value to be ready one cycle earlier.  */
     286                 :          0 :       if (insn_type == TYPE_FMOV
     287                 :          0 :           && get_attr_memory (insn) == MEMORY_STORE
     288                 :          0 :           && !ix86_agi_dependent (dep_insn, insn))
     289                 :          0 :         cost += 1;
     290                 :            :       break;
     291                 :            : 
     292                 :          0 :     case PROCESSOR_PENTIUMPRO:
     293                 :            :       /* INT->FP conversion is expensive.  */
     294                 :          0 :       if (get_attr_fp_int_src (dep_insn))
     295                 :          0 :         cost += 5;
     296                 :            : 
     297                 :            :       /* There is one cycle extra latency between an FP op and a store.  */
     298                 :          0 :       if (insn_type == TYPE_FMOV
     299                 :          0 :           && (set = single_set (dep_insn)) != NULL_RTX
     300                 :          0 :           && (set2 = single_set (insn)) != NULL_RTX
     301                 :          0 :           && rtx_equal_p (SET_DEST (set), SET_SRC (set2))
     302                 :          0 :           && MEM_P (SET_DEST (set2)))
     303                 :          0 :         cost += 1;
     304                 :            : 
     305                 :          0 :       memory = get_attr_memory (insn);
     306                 :            : 
     307                 :            :       /* Show ability of reorder buffer to hide latency of load by executing
     308                 :            :          in parallel with previous instruction in case
     309                 :            :          previous instruction is not needed to compute the address.  */
     310                 :          0 :       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
     311                 :          0 :           && !ix86_agi_dependent (dep_insn, insn))
     312                 :            :         {
     313                 :            :           /* Claim moves to take one cycle, as core can issue one load
     314                 :            :              at time and the next load can start cycle later.  */
     315                 :          0 :           if (dep_insn_type == TYPE_IMOV
     316                 :          0 :               || dep_insn_type == TYPE_FMOV)
     317                 :            :             cost = 1;
     318                 :          0 :           else if (cost > 1)
     319                 :          0 :             cost--;
     320                 :            :         }
     321                 :            :       break;
     322                 :            : 
     323                 :          0 :     case PROCESSOR_K6:
     324                 :            :      /* The esp dependency is resolved before
     325                 :            :         the instruction is really finished.  */
     326                 :          0 :       if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
     327                 :          0 :           && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
     328                 :            :         return 1;
     329                 :            : 
     330                 :            :       /* INT->FP conversion is expensive.  */
     331                 :          0 :       if (get_attr_fp_int_src (dep_insn))
     332                 :          0 :         cost += 5;
     333                 :            : 
     334                 :          0 :       memory = get_attr_memory (insn);
     335                 :            : 
     336                 :            :       /* Show ability of reorder buffer to hide latency of load by executing
     337                 :            :          in parallel with previous instruction in case
     338                 :            :          previous instruction is not needed to compute the address.  */
     339                 :          0 :       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
     340                 :          0 :           && !ix86_agi_dependent (dep_insn, insn))
     341                 :            :         {
     342                 :            :           /* Claim moves to take one cycle, as core can issue one load
     343                 :            :              at time and the next load can start cycle later.  */
     344                 :          0 :           if (dep_insn_type == TYPE_IMOV
     345                 :          0 :               || dep_insn_type == TYPE_FMOV)
     346                 :            :             cost = 1;
     347                 :          0 :           else if (cost > 2)
     348                 :          0 :             cost -= 2;
     349                 :            :           else
     350                 :            :             cost = 1;
     351                 :            :         }
     352                 :            :       break;
     353                 :            : 
     354                 :       8727 :     case PROCESSOR_AMDFAM10:
     355                 :       8727 :     case PROCESSOR_BDVER1:
     356                 :       8727 :     case PROCESSOR_BDVER2:
     357                 :       8727 :     case PROCESSOR_BDVER3:
     358                 :       8727 :     case PROCESSOR_BDVER4:
     359                 :       8727 :     case PROCESSOR_BTVER1:
     360                 :       8727 :     case PROCESSOR_BTVER2:
     361                 :            :       /* Stack engine allows to execute push&pop instructions in parall.  */
     362                 :       8727 :       if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
     363                 :        219 :           && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
     364                 :            :         return 0;
     365                 :            :       /* FALLTHRU */
     366                 :            : 
     367                 :      52407 :     case PROCESSOR_ATHLON:
     368                 :      52407 :     case PROCESSOR_K8:
     369                 :      52407 :       memory = get_attr_memory (insn);
     370                 :            : 
     371                 :            :       /* Show ability of reorder buffer to hide latency of load by executing
     372                 :            :          in parallel with previous instruction in case
     373                 :            :          previous instruction is not needed to compute the address.  */
     374                 :      52407 :       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
     375                 :      52407 :           && !ix86_agi_dependent (dep_insn, insn))
     376                 :            :         {
     377                 :       9975 :           enum attr_unit unit = get_attr_unit (insn);
     378                 :       9975 :           int loadcost = 3;
     379                 :            : 
     380                 :            :           /* Because of the difference between the length of integer and
     381                 :            :              floating unit pipeline preparation stages, the memory operands
     382                 :            :              for floating point are cheaper.
     383                 :            : 
     384                 :            :              ??? For Athlon it the difference is most probably 2.  */
     385                 :       9975 :           if (unit == UNIT_INTEGER || unit == UNIT_UNKNOWN)
     386                 :            :             loadcost = 3;
     387                 :            :           else
     388                 :       6031 :             loadcost = TARGET_ATHLON ? 2 : 0;
     389                 :            : 
     390                 :       9975 :           if (cost >= loadcost)
     391                 :       6820 :             cost -= loadcost;
     392                 :            :           else
     393                 :            :             cost = 0;
     394                 :            :         }
     395                 :            :       break;
     396                 :            : 
     397                 :         85 :     case PROCESSOR_ZNVER1:
     398                 :         85 :     case PROCESSOR_ZNVER2:
     399                 :            :       /* Stack engine allows to execute push&pop instructions in parall.  */
     400                 :         85 :       if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
     401                 :          0 :           && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
     402                 :            :         return 0;
     403                 :            : 
     404                 :         85 :       memory = get_attr_memory (insn);
     405                 :            : 
     406                 :            :       /* Show ability of reorder buffer to hide latency of load by executing
     407                 :            :          in parallel with previous instruction in case
     408                 :            :          previous instruction is not needed to compute the address.  */
     409                 :         85 :       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
     410                 :         85 :           && !ix86_agi_dependent (dep_insn, insn))
     411                 :            :         {
     412                 :          7 :           enum attr_unit unit = get_attr_unit (insn);
     413                 :          7 :           int loadcost;
     414                 :            : 
     415                 :          7 :           if (unit == UNIT_INTEGER || unit == UNIT_UNKNOWN)
     416                 :            :             loadcost = 4;
     417                 :            :           else
     418                 :          6 :             loadcost = 7;
     419                 :            : 
     420                 :          7 :           if (cost >= loadcost)
     421                 :          2 :             cost -= loadcost;
     422                 :            :           else
     423                 :            :             cost = 0;
     424                 :            :         }
     425                 :            :       break;
     426                 :            : 
     427                 :   39673200 :     case PROCESSOR_CORE2:
     428                 :   39673200 :     case PROCESSOR_NEHALEM:
     429                 :   39673200 :     case PROCESSOR_SANDYBRIDGE:
     430                 :   39673200 :     case PROCESSOR_HASWELL:
     431                 :   39673200 :     case PROCESSOR_GENERIC:
     432                 :            :       /* Stack engine allows to execute push&pop instructions in parall.  */
     433                 :   39673200 :       if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
     434                 :    9288600 :           && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
     435                 :            :         return 0;
     436                 :            : 
     437                 :   33452300 :       memory = get_attr_memory (insn);
     438                 :            : 
     439                 :            :       /* Show ability of reorder buffer to hide latency of load by executing
     440                 :            :          in parallel with previous instruction in case
     441                 :            :          previous instruction is not needed to compute the address.  */
     442                 :   33452300 :       if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
     443                 :   33452300 :           && !ix86_agi_dependent (dep_insn, insn))
     444                 :            :         {
     445                 :    4940980 :           if (cost >= 4)
     446                 :     191702 :             cost -= 4;
     447                 :            :           else
     448                 :            :             cost = 0;
     449                 :            :         }
     450                 :            :       break;
     451                 :            : 
     452                 :       9442 :     case PROCESSOR_SILVERMONT:
     453                 :       9442 :     case PROCESSOR_KNL:
     454                 :       9442 :     case PROCESSOR_KNM:
     455                 :       9442 :     case PROCESSOR_INTEL:
     456                 :       9442 :       if (!reload_completed)
     457                 :            :         return cost;
     458                 :            : 
     459                 :            :       /* Increase cost of integer loads.  */
     460                 :       9442 :       memory = get_attr_memory (dep_insn);
     461                 :       9442 :       if (memory == MEMORY_LOAD || memory == MEMORY_BOTH)
     462                 :            :         {
     463                 :       2734 :           enum attr_unit unit = get_attr_unit (dep_insn);
     464                 :       2734 :           if (unit == UNIT_INTEGER && cost == 1)
     465                 :            :             {
     466                 :        987 :               if (memory == MEMORY_LOAD)
     467                 :            :                 cost = 3;
     468                 :            :               else
     469                 :            :                 {
     470                 :            :                   /* Increase cost of ld/st for short int types only
     471                 :            :                      because of store forwarding issue.  */
     472                 :          0 :                   rtx set = single_set (dep_insn);
     473                 :          0 :                   if (set && (GET_MODE (SET_DEST (set)) == QImode
     474                 :          0 :                               || GET_MODE (SET_DEST (set)) == HImode))
     475                 :            :                     {
     476                 :            :                       /* Increase cost of store/load insn if exact
     477                 :            :                          dependence exists and it is load insn.  */
     478                 :          0 :                       enum attr_memory insn_memory = get_attr_memory (insn);
     479                 :          0 :                       if (insn_memory == MEMORY_LOAD
     480                 :          0 :                           && exact_store_load_dependency (dep_insn, insn))
     481                 :            :                         cost = 3;
     482                 :            :                     }
     483                 :            :                 }
     484                 :            :             }
     485                 :            :         }
     486                 :            : 
     487                 :            :     default:
     488                 :            :       break;
     489                 :            :     }
     490                 :            : 
     491                 :            :   return cost;
     492                 :            : }
     493                 :            : 
     494                 :            : /* How many alternative schedules to try.  This should be as wide as the
     495                 :            :    scheduling freedom in the DFA, but no wider.  Making this value too
     496                 :            :    large results extra work for the scheduler.  */
     497                 :            : 
     498                 :            : int
     499                 :     644572 : ia32_multipass_dfa_lookahead (void)
     500                 :            : {
     501                 :            :   /* Generally, we want haifa-sched:max_issue() to look ahead as far
     502                 :            :      as many instructions can be executed on a cycle, i.e.,
     503                 :            :      issue_rate.  */
     504                 :     644572 :   if (reload_completed)
     505                 :     644279 :     return ix86_issue_rate ();
     506                 :            :   /* Don't use lookahead for pre-reload schedule to save compile time.  */
     507                 :            :   return 0;
     508                 :            : }
     509                 :            : 
     510                 :            : /* Return true if target platform supports macro-fusion.  */
     511                 :            : 
     512                 :            : bool
     513                 :   67006100 : ix86_macro_fusion_p ()
     514                 :            : {
     515                 :   67006100 :   return TARGET_FUSE_CMP_AND_BRANCH;
     516                 :            : }
     517                 :            : 
     518                 :            : /* Check whether current microarchitecture support macro fusion
     519                 :            :    for insn pair "CONDGEN + CONDJMP". Refer to
     520                 :            :    "Intel Architectures Optimization Reference Manual". */
     521                 :            : 
     522                 :            : bool
     523                 :   30142100 : ix86_macro_fusion_pair_p (rtx_insn *condgen, rtx_insn *condjmp)
     524                 :            : {
     525                 :   30142100 :   rtx src, dest;
     526                 :   30142100 :   enum rtx_code ccode;
     527                 :   30142100 :   rtx compare_set = NULL_RTX, test_if, cond;
     528                 :   30142100 :   rtx alu_set = NULL_RTX, addr = NULL_RTX;
     529                 :   30142100 :   enum attr_type condgen_type;
     530                 :            : 
     531                 :   30142100 :   if (!any_condjump_p (condjmp))
     532                 :            :     return false;
     533                 :            : 
     534                 :    3027840 :   unsigned int condreg1, condreg2;
     535                 :    3027840 :   rtx cc_reg_1;
     536                 :    3027840 :   targetm.fixed_condition_code_regs (&condreg1, &condreg2);
     537                 :    3027840 :   cc_reg_1 = gen_rtx_REG (CCmode, condreg1);
     538                 :    3027840 :   if (!reg_referenced_p (cc_reg_1, PATTERN (condjmp))
     539                 :    3027840 :       || !condgen
     540                 :    6055670 :       || !modified_in_p (cc_reg_1, condgen))
     541                 :      80896 :     return false;
     542                 :            : 
     543                 :    2946940 :   condgen_type = get_attr_type (condgen);
     544                 :    2946940 :   if (condgen_type == TYPE_MULTI
     545                 :        120 :       && INSN_CODE (condgen) == code_for_stack_protect_test_1 (ptr_mode)
     546                 :    2947060 :       && TARGET_FUSE_ALU_AND_BRANCH)
     547                 :            :     {
     548                 :            :       /* stack_protect_test_<mode> ends with a sub, which subtracts
     549                 :            :          a non-rip special memory operand from a GPR.  */
     550                 :        120 :       src = NULL_RTX;
     551                 :        120 :       alu_set = XVECEXP (PATTERN (condgen), 0, 1);
     552                 :        120 :       goto handle_stack_protect_test;
     553                 :            :     }
     554                 :    2946820 :   else if (condgen_type != TYPE_TEST
     555                 :    2946820 :            && condgen_type != TYPE_ICMP
     556                 :    2946820 :            && condgen_type != TYPE_INCDEC
     557                 :     367390 :            && condgen_type != TYPE_ALU)
     558                 :            :     return false;
     559                 :            : 
     560                 :    2692670 :   compare_set = single_set (condgen);
     561                 :    2692670 :   if (compare_set == NULL_RTX && !TARGET_FUSE_ALU_AND_BRANCH)
     562                 :            :     return false;
     563                 :            : 
     564                 :    2692660 :   if (compare_set == NULL_RTX)
     565                 :            :     {
     566                 :      46291 :       int i;
     567                 :      46291 :       rtx pat = PATTERN (condgen);
     568                 :     138873 :       for (i = 0; i < XVECLEN (pat, 0); i++)
     569                 :      92582 :         if (GET_CODE (XVECEXP (pat, 0, i)) == SET)
     570                 :            :           {
     571                 :      92582 :             rtx set_src = SET_SRC (XVECEXP (pat, 0, i));
     572                 :      92582 :             if (GET_CODE (set_src) == COMPARE)
     573                 :            :               compare_set = XVECEXP (pat, 0, i);
     574                 :            :             else
     575                 :      51126 :               alu_set = XVECEXP (pat, 0, i);
     576                 :            :           }
     577                 :            :     }
     578                 :    2692660 :   if (compare_set == NULL_RTX)
     579                 :            :     return false;
     580                 :    2687820 :   src = SET_SRC (compare_set);
     581                 :    2687820 :   if (GET_CODE (src) != COMPARE)
     582                 :            :     return false;
     583                 :            : 
     584                 :            :   /* Macro-fusion for cmp/test MEM-IMM + conditional jmp is not
     585                 :            :      supported.  */
     586                 :    2681900 :   if ((MEM_P (XEXP (src, 0)) && CONST_INT_P (XEXP (src, 1)))
     587                 :    2454490 :       || (MEM_P (XEXP (src, 1)) && CONST_INT_P (XEXP (src, 0))))
     588                 :            :     return false;
     589                 :            : 
     590                 :            :   /* No fusion for RIP-relative address.  */
     591                 :    2454490 :   if (MEM_P (XEXP (src, 0)))
     592                 :     144018 :     addr = XEXP (XEXP (src, 0), 0);
     593                 :    2310470 :   else if (MEM_P (XEXP (src, 1)))
     594                 :     253058 :     addr = XEXP (XEXP (src, 1), 0);
     595                 :            : 
     596                 :     397076 :   if (addr)
     597                 :            :     {
     598                 :     397076 :       ix86_address parts;
     599                 :     397076 :       int ok = ix86_decompose_address (addr, &parts);
     600                 :     397076 :       gcc_assert (ok);
     601                 :            : 
     602                 :     397076 :       if (ix86_rip_relative_addr_p (&parts))
     603                 :      14307 :         return false;
     604                 :            :     }
     605                 :            : 
     606                 :          0 :  handle_stack_protect_test:
     607                 :    2440300 :   test_if = SET_SRC (pc_set (condjmp));
     608                 :    2440300 :   cond = XEXP (test_if, 0);
     609                 :    2440300 :   ccode = GET_CODE (cond);
     610                 :            :   /* Check whether conditional jump use Sign or Overflow Flags.  */
     611                 :    2440300 :   if (!TARGET_FUSE_CMP_AND_BRANCH_SOFLAGS
     612                 :          0 :       && (ccode == GE || ccode == GT || ccode == LE || ccode == LT))
     613                 :            :     return false;
     614                 :            : 
     615                 :            :   /* Return true for TYPE_TEST and TYPE_ICMP.  */
     616                 :    2440300 :   if (condgen_type == TYPE_TEST || condgen_type == TYPE_ICMP)
     617                 :            :     return true;
     618                 :            : 
     619                 :            :   /* The following is the case that macro-fusion for alu + jmp.  */
     620                 :     106256 :   if (!TARGET_FUSE_ALU_AND_BRANCH || !alu_set)
     621                 :            :     return false;
     622                 :            : 
     623                 :            :   /* No fusion for alu op with memory destination operand.  */
     624                 :      41576 :   dest = SET_DEST (alu_set);
     625                 :      41576 :   if (MEM_P (dest))
     626                 :            :     return false;
     627                 :            : 
     628                 :            :   /* Macro-fusion for inc/dec + unsigned conditional jump is not
     629                 :            :      supported.  */
     630                 :      40290 :   if (condgen_type == TYPE_INCDEC
     631                 :        703 :       && (ccode == GEU || ccode == GTU || ccode == LEU || ccode == LTU))
     632                 :          0 :     return false;
     633                 :            : 
     634                 :            :   return true;
     635                 :            : }
     636                 :            : 

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.