LCOV - code coverage report
Current view: top level - objdir/gcc - tm-constrs.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2 2 100.0 %
Date: 2020-03-28 11:57:23 Functions: 1 1 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Generated automatically by the program 'build/genpreds'
       2                 :            :    from the machine description file '../../gcc/config/i386/i386.md'.  */
       3                 :            : 
       4                 :            : #ifndef GCC_TM_CONSTRS_H
       5                 :            : #define GCC_TM_CONSTRS_H
       6                 :            : 
       7                 :            : static inline bool
       8                 :  720717000 : satisfies_constraint_m (rtx op)
       9                 :            : {
      10                 :  990467000 :   return (GET_CODE (op) == MEM) && (
      11                 :            : #line 26 "../../gcc/common.md"
      12                 :            : (memory_address_addr_space_p (GET_MODE (op), XEXP (op, 0),
      13                 :            :                                                  MEM_ADDR_SPACE (op))));
      14                 :            : }
      15                 :            : static inline bool
      16                 :            : satisfies_constraint_o (rtx op)
      17                 :            : {
      18                 :            :   return (GET_CODE (op) == MEM) && (
      19                 :            : #line 32 "../../gcc/common.md"
      20                 :            : (offsettable_nonstrict_memref_p (op)));
      21                 :            : }
      22                 :            : static inline bool
      23                 :            : satisfies_constraint_V (rtx op)
      24                 :            : {
      25                 :            :   return (GET_CODE (op) == MEM) && ((
      26                 :            : #line 41 "../../gcc/common.md"
      27                 :            : (memory_address_addr_space_p (GET_MODE (op), XEXP (op, 0),
      28                 :            :                                                  MEM_ADDR_SPACE (op)))) && (!(
      29                 :            : #line 43 "../../gcc/common.md"
      30                 :            : (offsettable_nonstrict_memref_p (op)))));
      31                 :            : }
      32                 :            : static inline bool
      33                 :            : satisfies_constraint__l (rtx op)
      34                 :            : {
      35                 :            :   return (GET_CODE (op) == MEM) && ((
      36                 :            : #line 50 "../../gcc/common.md"
      37                 :            : (GET_CODE (XEXP (op, 0)) == PRE_DEC)) || (
      38                 :            : #line 51 "../../gcc/common.md"
      39                 :            : (GET_CODE (XEXP (op, 0)) == POST_DEC)));
      40                 :            : }
      41                 :            : static inline bool
      42                 :            : satisfies_constraint__g (rtx op)
      43                 :            : {
      44                 :            :   return (GET_CODE (op) == MEM) && ((
      45                 :            : #line 57 "../../gcc/common.md"
      46                 :            : (GET_CODE (XEXP (op, 0)) == PRE_INC)) || (
      47                 :            : #line 58 "../../gcc/common.md"
      48                 :            : (GET_CODE (XEXP (op, 0)) == POST_INC)));
      49                 :            : }
      50                 :            : static inline bool
      51                 :            : satisfies_constraint_p (rtx ARG_UNUSED (op))
      52                 :            : {
      53                 :            :   return 
      54                 :            : #line 62 "../../gcc/common.md"
      55                 :            : (address_operand (op, VOIDmode));
      56                 :            : }
      57                 :            : static inline bool
      58                 :            : satisfies_constraint_i (rtx op)
      59                 :            : {
      60                 :            :   return (
      61                 :            : #line 66 "../../gcc/common.md"
      62                 :            : (CONSTANT_P (op))) && (
      63                 :            : #line 67 "../../gcc/common.md"
      64                 :            : (!flag_pic || LEGITIMATE_PIC_OPERAND_P (op)));
      65                 :            : }
      66                 :            : static inline bool
      67                 :            : satisfies_constraint_s (rtx op)
      68                 :            : {
      69                 :            :   return (
      70                 :            : #line 71 "../../gcc/common.md"
      71                 :            : (CONSTANT_P (op))) && ((
      72                 :            : #line 72 "../../gcc/common.md"
      73                 :            : (!CONST_SCALAR_INT_P (op))) && (
      74                 :            : #line 73 "../../gcc/common.md"
      75                 :            : (!flag_pic || LEGITIMATE_PIC_OPERAND_P (op))));
      76                 :            : }
      77                 :            : static inline bool
      78                 :            : satisfies_constraint_n (rtx op)
      79                 :            : {
      80                 :            :   return (
      81                 :            : #line 77 "../../gcc/common.md"
      82                 :            : (CONST_SCALAR_INT_P (op))) && (
      83                 :            : #line 78 "../../gcc/common.md"
      84                 :            : (!flag_pic || LEGITIMATE_PIC_OPERAND_P (op)));
      85                 :            : }
      86                 :            : static inline bool
      87                 :            : satisfies_constraint_E (rtx op)
      88                 :            : {
      89                 :            :   return (
      90                 :            : #line 82 "../../gcc/common.md"
      91                 :            : (CONST_DOUBLE_AS_FLOAT_P (op))) || (
      92                 :            : #line 83 "../../gcc/common.md"
      93                 :            : (GET_CODE (op) == CONST_VECTOR
      94                 :            :                     && GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT));
      95                 :            : }
      96                 :            : static inline bool
      97                 :            : satisfies_constraint_F (rtx op)
      98                 :            : {
      99                 :            :   return (
     100                 :            : #line 89 "../../gcc/common.md"
     101                 :            : (CONST_DOUBLE_AS_FLOAT_P (op))) || (
     102                 :            : #line 90 "../../gcc/common.md"
     103                 :            : (GET_CODE (op) == CONST_VECTOR
     104                 :            :                     && GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT));
     105                 :            : }
     106                 :            : static inline bool
     107                 :            : satisfies_constraint_X (rtx ARG_UNUSED (op))
     108                 :            : {
     109                 :            :   return 
     110                 :            : #line 95 "../../gcc/common.md"
     111                 :            : (true);
     112                 :            : }
     113                 :            : static inline bool
     114                 :            : satisfies_constraint_Bf (rtx op)
     115                 :            : {
     116                 :            :   machine_mode mode = GET_MODE (op);
     117                 :            :   return flags_reg_operand (op, mode);
     118                 :            : }
     119                 :            : static inline bool
     120                 :            : satisfies_constraint_Bg (rtx op)
     121                 :            : {
     122                 :            :   machine_mode mode = GET_MODE (op);
     123                 :            :   return GOT_memory_operand (op, mode);
     124                 :            : }
     125                 :            : static inline bool
     126                 :            : satisfies_constraint_Bm (rtx op)
     127                 :            : {
     128                 :            :   machine_mode mode = GET_MODE (op);
     129                 :            :   return vector_memory_operand (op, mode);
     130                 :            : }
     131                 :            : static inline bool
     132                 :            : satisfies_constraint_Bc (rtx op)
     133                 :            : {
     134                 :            :   machine_mode mode = GET_MODE (op);
     135                 :            :   return (memory_operand (op, mode)) && (
     136                 :            : #line 180 "../../gcc/config/i386/constraints.md"
     137                 :            : (constant_address_p (XEXP (op, 0))));
     138                 :            : }
     139                 :            : static inline bool
     140                 :            : satisfies_constraint_Bn (rtx op)
     141                 :            : {
     142                 :            :   machine_mode mode = GET_MODE (op);
     143                 :            :   return norex_memory_operand (op, mode);
     144                 :            : }
     145                 :            : static inline bool
     146                 :            : satisfies_constraint_Bs (rtx op)
     147                 :            : {
     148                 :            :   machine_mode mode = GET_MODE (op);
     149                 :            :   return ((!(
     150                 :            : #line 188 "../../gcc/config/i386/constraints.md"
     151                 :            : (TARGET_INDIRECT_BRANCH_REGISTER))) && ((!(
     152                 :            : #line 189 "../../gcc/config/i386/constraints.md"
     153                 :            : (TARGET_X32))) && (sibcall_memory_operand (op, mode)))) || ((
     154                 :            : #line 191 "../../gcc/config/i386/constraints.md"
     155                 :            : (TARGET_X32 && Pmode == DImode)) && (GOT_memory_operand (op, mode)));
     156                 :            : }
     157                 :            : static inline bool
     158                 :            : satisfies_constraint_Bw (rtx op)
     159                 :            : {
     160                 :            :   machine_mode mode = GET_MODE (op);
     161                 :            :   return ((!(
     162                 :            : #line 196 "../../gcc/config/i386/constraints.md"
     163                 :            : (TARGET_INDIRECT_BRANCH_REGISTER))) && ((!(
     164                 :            : #line 197 "../../gcc/config/i386/constraints.md"
     165                 :            : (TARGET_X32))) && (memory_operand (op, mode)))) || ((
     166                 :            : #line 199 "../../gcc/config/i386/constraints.md"
     167                 :            : (TARGET_X32 && Pmode == DImode)) && (GOT_memory_operand (op, mode)));
     168                 :            : }
     169                 :            : static inline bool
     170                 :            : satisfies_constraint_Bz (rtx op)
     171                 :            : {
     172                 :            :   machine_mode mode = GET_MODE (op);
     173                 :            :   return constant_call_address_operand (op, mode);
     174                 :            : }
     175                 :            : static inline bool
     176                 :            : satisfies_constraint_BC (rtx op)
     177                 :            : {
     178                 :            :   machine_mode mode = GET_MODE (op);
     179                 :            :   return (
     180                 :            : #line 208 "../../gcc/config/i386/constraints.md"
     181                 :            : (TARGET_SSE)) && ((
     182                 :            : #line 209 "../../gcc/config/i386/constraints.md"
     183                 :            : (op == constm1_rtx)) || (vector_all_ones_operand (op, mode)));
     184                 :            : }
     185                 :            : static inline bool
     186                 :            : satisfies_constraint_I (rtx op)
     187                 :            : {
     188                 :            :   HOST_WIDE_INT ival = 0;
     189                 :            :   if (CONST_INT_P (op))
     190                 :            :     ival = INTVAL (op);
     191                 :            :   return (GET_CODE (op) == CONST_INT) && (
     192                 :            : #line 216 "../../gcc/config/i386/constraints.md"
     193                 :            : (IN_RANGE (ival, 0, 31)));
     194                 :            : }
     195                 :            : static inline bool
     196                 :            : satisfies_constraint_J (rtx op)
     197                 :            : {
     198                 :            :   HOST_WIDE_INT ival = 0;
     199                 :            :   if (CONST_INT_P (op))
     200                 :            :     ival = INTVAL (op);
     201                 :            :   return (GET_CODE (op) == CONST_INT) && (
     202                 :            : #line 221 "../../gcc/config/i386/constraints.md"
     203                 :            : (IN_RANGE (ival, 0, 63)));
     204                 :            : }
     205                 :            : static inline bool
     206                 :            : satisfies_constraint_K (rtx op)
     207                 :            : {
     208                 :            :   HOST_WIDE_INT ival = 0;
     209                 :            :   if (CONST_INT_P (op))
     210                 :            :     ival = INTVAL (op);
     211                 :            :   return (GET_CODE (op) == CONST_INT) && (
     212                 :            : #line 226 "../../gcc/config/i386/constraints.md"
     213                 :            : (IN_RANGE (ival, -128, 127)));
     214                 :            : }
     215                 :            : static inline bool
     216                 :            : satisfies_constraint_L (rtx op)
     217                 :            : {
     218                 :            :   HOST_WIDE_INT ival = 0;
     219                 :            :   if (CONST_INT_P (op))
     220                 :            :     ival = INTVAL (op);
     221                 :            :   return (GET_CODE (op) == CONST_INT) && (
     222                 :            : #line 232 "../../gcc/config/i386/constraints.md"
     223                 :            : (ival == 0xff || ival == 0xffff
     224                 :            :                     || ival == (HOST_WIDE_INT) 0xffffffff));
     225                 :            : }
     226                 :            : static inline bool
     227                 :            : satisfies_constraint_M (rtx op)
     228                 :            : {
     229                 :            :   HOST_WIDE_INT ival = 0;
     230                 :            :   if (CONST_INT_P (op))
     231                 :            :     ival = INTVAL (op);
     232                 :            :   return (GET_CODE (op) == CONST_INT) && (
     233                 :            : #line 238 "../../gcc/config/i386/constraints.md"
     234                 :            : (IN_RANGE (ival, 0, 3)));
     235                 :            : }
     236                 :            : static inline bool
     237                 :            : satisfies_constraint_N (rtx op)
     238                 :            : {
     239                 :            :   HOST_WIDE_INT ival = 0;
     240                 :            :   if (CONST_INT_P (op))
     241                 :            :     ival = INTVAL (op);
     242                 :            :   return (GET_CODE (op) == CONST_INT) && (
     243                 :            : #line 244 "../../gcc/config/i386/constraints.md"
     244                 :            : (IN_RANGE (ival, 0, 255)));
     245                 :            : }
     246                 :            : static inline bool
     247                 :            : satisfies_constraint_O (rtx op)
     248                 :            : {
     249                 :            :   HOST_WIDE_INT ival = 0;
     250                 :            :   if (CONST_INT_P (op))
     251                 :            :     ival = INTVAL (op);
     252                 :            :   return (GET_CODE (op) == CONST_INT) && (
     253                 :            : #line 249 "../../gcc/config/i386/constraints.md"
     254                 :            : (IN_RANGE (ival, 0, 127)));
     255                 :            : }
     256                 :            : static inline bool
     257                 :            : satisfies_constraint_G (rtx op)
     258                 :            : {
     259                 :            :   return (GET_CODE (op) == CONST_DOUBLE) && (
     260                 :            : #line 258 "../../gcc/config/i386/constraints.md"
     261                 :            : (standard_80387_constant_p (op) > 0));
     262                 :            : }
     263                 :            : static inline bool
     264                 :            : satisfies_constraint_C (rtx op)
     265                 :            : {
     266                 :            :   machine_mode mode = GET_MODE (op);
     267                 :            :   return (
     268                 :            : #line 263 "../../gcc/config/i386/constraints.md"
     269                 :            : (op == const0_rtx)) || (const0_operand (op, mode));
     270                 :            : }
     271                 :            : static inline bool
     272                 :            : satisfies_constraint_e (rtx op)
     273                 :            : {
     274                 :            :   machine_mode mode = GET_MODE (op);
     275                 :            :   return x86_64_immediate_operand (op, mode);
     276                 :            : }
     277                 :            : static inline bool
     278                 :            : satisfies_constraint_We (rtx op)
     279                 :            : {
     280                 :            :   machine_mode mode = GET_MODE (op);
     281                 :            :   return (x86_64_immediate_operand (op, mode)) && (
     282                 :            : #line 282 "../../gcc/config/i386/constraints.md"
     283                 :            : (GET_MODE (op) != VOIDmode));
     284                 :            : }
     285                 :            : static inline bool
     286                 :            : satisfies_constraint_Wz (rtx op)
     287                 :            : {
     288                 :            :   machine_mode mode = GET_MODE (op);
     289                 :            :   return (x86_64_zext_immediate_operand (op, mode)) && (
     290                 :            : #line 289 "../../gcc/config/i386/constraints.md"
     291                 :            : (GET_MODE (op) != VOIDmode));
     292                 :            : }
     293                 :            : static inline bool
     294                 :            : satisfies_constraint_Wd (rtx op)
     295                 :            : {
     296                 :            :   machine_mode mode = GET_MODE (op);
     297                 :            :   return x86_64_hilo_int_operand (op, mode);
     298                 :            : }
     299                 :            : static inline bool
     300                 :            : satisfies_constraint_Wf (rtx op)
     301                 :            : {
     302                 :            :   machine_mode mode = GET_MODE (op);
     303                 :            :   return x86_64_dwzext_immediate_operand (op, mode);
     304                 :            : }
     305                 :            : static inline bool
     306                 :            : satisfies_constraint_Z (rtx op)
     307                 :            : {
     308                 :            :   machine_mode mode = GET_MODE (op);
     309                 :            :   return x86_64_zext_immediate_operand (op, mode);
     310                 :            : }
     311                 :            : static inline bool
     312                 :            : satisfies_constraint_Tv (rtx op)
     313                 :            : {
     314                 :            :   machine_mode mode = GET_MODE (op);
     315                 :            :   return vsib_address_operand (op, mode);
     316                 :            : }
     317                 :            : static inline bool
     318                 :            : satisfies_constraint_Ts (rtx op)
     319                 :            : {
     320                 :            :   machine_mode mode = GET_MODE (op);
     321                 :            :   return address_no_seg_operand (op, mode);
     322                 :            : }
     323                 :            : #endif /* tm-constrs.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.