optabs-query.h revision 1.3 
1/* IR-agnostic target query functions relating to optabs
2   Copyright (C) 2001-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 3, or (at your option)
9any later version.
10
11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3.  If not see
18<http://www.gnu.org/licenses/>.  */
19
20#ifndef GCC_OPTABS_QUERY_H
21#define GCC_OPTABS_QUERY_H
22
23#include "insn-opinit.h"
24
25/* Return the insn used to implement mode MODE of OP, or CODE_FOR_nothing
26   if the target does not have such an insn.  */
27
28inline enum insn_code
29optab_handler (optab op, machine_mode mode)
30{
31  unsigned scode = (op << 16) | mode;
32  gcc_assert (op > LAST_CONV_OPTAB);
33  return raw_optab_handler (scode);
34}
35
36/* Return the insn used to perform conversion OP from mode FROM_MODE
37   to mode TO_MODE; return CODE_FOR_nothing if the target does not have
38   such an insn.  */
39
40inline enum insn_code
41convert_optab_handler (convert_optab op, machine_mode to_mode,
42		       machine_mode from_mode)
43{
44  unsigned scode = (op << 16) | (from_mode << 8) | to_mode;
45  gcc_assert (op > unknown_optab && op <= LAST_CONV_OPTAB);
46  return raw_optab_handler (scode);
47}
48
49enum insn_code convert_optab_handler (convert_optab, machine_mode,
50				      machine_mode, optimization_type);
51
52/* Return the insn used to implement mode MODE of OP, or CODE_FOR_nothing
53   if the target does not have such an insn.  */
54
55inline enum insn_code
56direct_optab_handler (direct_optab op, machine_mode mode)
57{
58  return optab_handler (op, mode);
59}
60
61enum insn_code direct_optab_handler (convert_optab, machine_mode,
62				     optimization_type);
63
64/* Return true if UNOPTAB is for a trapping-on-overflow operation.  */
65
66inline bool
67trapv_unoptab_p (optab unoptab)
68{
69  return (unoptab == negv_optab
70	  || unoptab == absv_optab);
71}
72
73/* Return true if BINOPTAB is for a trapping-on-overflow operation.  */
74
75inline bool
76trapv_binoptab_p (optab binoptab)
77{
78  return (binoptab == addv_optab
79	  || binoptab == subv_optab
80	  || binoptab == smulv_optab);
81}
82
83/* Return insn code for a comparison operator with VMODE
84   resultin MASK_MODE, unsigned if UNS is true.  */
85
86static inline enum insn_code
87get_vec_cmp_icode (machine_mode vmode, machine_mode mask_mode, bool uns)
88{
89  optab tab = uns ? vec_cmpu_optab : vec_cmp_optab;
90  return convert_optab_handler (tab, vmode, mask_mode);
91}
92
93/* Return insn code for a comparison operator with VMODE
94   resultin MASK_MODE (only for EQ/NE).  */
95
96static inline enum insn_code
97get_vec_cmp_eq_icode (machine_mode vmode, machine_mode mask_mode)
98{
99  return convert_optab_handler (vec_cmpeq_optab, vmode, mask_mode);
100}
101
102/* Return insn code for a conditional operator with a comparison in
103   mode CMODE, unsigned if UNS is true, resulting in a value of mode VMODE.  */
104
105inline enum insn_code
106get_vcond_icode (machine_mode vmode, machine_mode cmode, bool uns)
107{
108  enum insn_code icode = CODE_FOR_nothing;
109  if (uns)
110    icode = convert_optab_handler (vcondu_optab, vmode, cmode);
111  else
112    icode = convert_optab_handler (vcond_optab, vmode, cmode);
113  return icode;
114}
115
116/* Return insn code for a conditional operator with a mask mode
117   MMODE resulting in a value of mode VMODE.  */
118
119static inline enum insn_code
120get_vcond_mask_icode (machine_mode vmode, machine_mode mmode)
121{
122  return convert_optab_handler (vcond_mask_optab, vmode, mmode);
123}
124
125/* Return insn code for a conditional operator with a comparison in
126   mode CMODE (only EQ/NE), resulting in a value of mode VMODE.  */
127
128static inline enum insn_code
129get_vcond_eq_icode (machine_mode vmode, machine_mode cmode)
130{
131  return convert_optab_handler (vcondeq_optab, vmode, cmode);
132}
133
134/* Enumerates the possible extraction_insn operations.  */
135enum extraction_pattern { EP_insv, EP_extv, EP_extzv };
136
137/* Describes an instruction that inserts or extracts a bitfield.  */
138struct extraction_insn
139{
140  /* The code of the instruction.  */
141  enum insn_code icode;
142
143  /* The mode that the structure operand should have.  This is byte_mode
144     when using the legacy insv, extv and extzv patterns to access memory.  */
145  machine_mode struct_mode;
146
147  /* The mode of the field to be inserted or extracted, and by extension
148     the mode of the insertion or extraction itself.  */
149  machine_mode field_mode;
150
151  /* The mode of the field's bit position.  This is only important
152     when the position is variable rather than constant.  */
153  machine_mode pos_mode;
154};
155
156bool get_best_reg_extraction_insn (extraction_insn *,
157				   enum extraction_pattern,
158				   unsigned HOST_WIDE_INT, machine_mode);
159bool get_best_mem_extraction_insn (extraction_insn *,
160				   enum extraction_pattern,
161				   HOST_WIDE_INT, HOST_WIDE_INT, machine_mode);
162
163enum insn_code can_extend_p (machine_mode, machine_mode, int);
164enum insn_code can_float_p (machine_mode, machine_mode, int);
165enum insn_code can_fix_p (machine_mode, machine_mode, int, bool *);
166bool can_conditionally_move_p (machine_mode mode);
167bool can_vec_perm_p (machine_mode, bool, const unsigned char *);
168enum insn_code widening_optab_handler (optab, machine_mode, machine_mode);
169/* Find a widening optab even if it doesn't widen as much as we want.  */
170#define find_widening_optab_handler(A,B,C,D) \
171  find_widening_optab_handler_and_mode (A, B, C, D, NULL)
172enum insn_code find_widening_optab_handler_and_mode (optab, machine_mode,
173						     machine_mode, int,
174						     machine_mode *);
175int can_mult_highpart_p (machine_mode, bool);
176bool can_vec_mask_load_store_p (machine_mode, machine_mode, bool);
177bool can_compare_and_swap_p (machine_mode, bool);
178bool can_atomic_exchange_p (machine_mode, bool);
179bool can_atomic_load_p (machine_mode);
180bool lshift_cheap_p (bool);
181
182#endif
183