2016-12-24 François Dumont <fdumont@gcc.gnu.org>
[official-gcc.git] / gcc / optabs-libfuncs.c
blob79a07d68b2c90a941392bef4281d765e6338de79
1 /* Mapping from optabs to underlying library functions
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "target.h"
25 #include "insn-codes.h"
26 #include "optabs-libfuncs.h"
27 #include "libfuncs.h"
28 #include "optabs-query.h"
29 #include "tree.h"
30 #include "stringpool.h"
31 #include "varasm.h"
32 #include "stor-layout.h"
33 #include "rtl.h"
35 struct target_libfuncs default_target_libfuncs;
36 #if SWITCHABLE_TARGET
37 struct target_libfuncs *this_target_libfuncs = &default_target_libfuncs;
38 #endif
40 #define libfunc_hash \
41 (this_target_libfuncs->x_libfunc_hash)
43 /* Prefixes for the current version of decimal floating point (BID vs. DPD) */
44 #if ENABLE_DECIMAL_BID_FORMAT
45 #define DECIMAL_PREFIX "bid_"
46 #else
47 #define DECIMAL_PREFIX "dpd_"
48 #endif
50 /* Used for libfunc_hash. */
52 hashval_t
53 libfunc_hasher::hash (libfunc_entry *e)
55 return ((e->mode1 + e->mode2 * NUM_MACHINE_MODES) ^ e->op);
58 /* Used for libfunc_hash. */
60 bool
61 libfunc_hasher::equal (libfunc_entry *e1, libfunc_entry *e2)
63 return e1->op == e2->op && e1->mode1 == e2->mode1 && e1->mode2 == e2->mode2;
66 /* Return libfunc corresponding operation defined by OPTAB converting
67 from MODE2 to MODE1. Trigger lazy initialization if needed, return NULL
68 if no libfunc is available. */
69 rtx
70 convert_optab_libfunc (convert_optab optab, machine_mode mode1,
71 machine_mode mode2)
73 struct libfunc_entry e;
74 struct libfunc_entry **slot;
76 /* ??? This ought to be an assert, but not all of the places
77 that we expand optabs know about the optabs that got moved
78 to being direct. */
79 if (!(optab >= FIRST_CONV_OPTAB && optab <= LAST_CONVLIB_OPTAB))
80 return NULL_RTX;
82 e.op = optab;
83 e.mode1 = mode1;
84 e.mode2 = mode2;
85 slot = libfunc_hash->find_slot (&e, NO_INSERT);
86 if (!slot)
88 const struct convert_optab_libcall_d *d
89 = &convlib_def[optab - FIRST_CONV_OPTAB];
91 if (d->libcall_gen == NULL)
92 return NULL;
94 d->libcall_gen (optab, d->libcall_basename, mode1, mode2);
95 slot = libfunc_hash->find_slot (&e, NO_INSERT);
96 if (!slot)
97 return NULL;
99 return (*slot)->libfunc;
102 /* Return libfunc corresponding operation defined by OPTAB in MODE.
103 Trigger lazy initialization if needed, return NULL if no libfunc is
104 available. */
106 optab_libfunc (optab optab, machine_mode mode)
108 struct libfunc_entry e;
109 struct libfunc_entry **slot;
111 /* ??? This ought to be an assert, but not all of the places
112 that we expand optabs know about the optabs that got moved
113 to being direct. */
114 if (!(optab >= FIRST_NORM_OPTAB && optab <= LAST_NORMLIB_OPTAB))
115 return NULL_RTX;
117 e.op = optab;
118 e.mode1 = mode;
119 e.mode2 = VOIDmode;
120 slot = libfunc_hash->find_slot (&e, NO_INSERT);
121 if (!slot)
123 const struct optab_libcall_d *d
124 = &normlib_def[optab - FIRST_NORM_OPTAB];
126 if (d->libcall_gen == NULL)
127 return NULL;
129 d->libcall_gen (optab, d->libcall_basename, d->libcall_suffix, mode);
130 slot = libfunc_hash->find_slot (&e, NO_INSERT);
131 if (!slot)
132 return NULL;
134 return (*slot)->libfunc;
137 /* Initialize the libfunc fields of an entire group of entries in some
138 optab. Each entry is set equal to a string consisting of a leading
139 pair of underscores followed by a generic operation name followed by
140 a mode name (downshifted to lowercase) followed by a single character
141 representing the number of operands for the given operation (which is
142 usually one of the characters '2', '3', or '4').
144 OPTABLE is the table in which libfunc fields are to be initialized.
145 OPNAME is the generic (string) name of the operation.
146 SUFFIX is the character which specifies the number of operands for
147 the given generic operation.
148 MODE is the mode to generate for. */
150 static void
151 gen_libfunc (optab optable, const char *opname, int suffix,
152 machine_mode mode)
154 unsigned opname_len = strlen (opname);
155 const char *mname = GET_MODE_NAME (mode);
156 unsigned mname_len = strlen (mname);
157 int prefix_len = targetm.libfunc_gnu_prefix ? 6 : 2;
158 int len = prefix_len + opname_len + mname_len + 1 + 1;
159 char *libfunc_name = XALLOCAVEC (char, len);
160 char *p;
161 const char *q;
163 p = libfunc_name;
164 *p++ = '_';
165 *p++ = '_';
166 if (targetm.libfunc_gnu_prefix)
168 *p++ = 'g';
169 *p++ = 'n';
170 *p++ = 'u';
171 *p++ = '_';
173 for (q = opname; *q;)
174 *p++ = *q++;
175 for (q = mname; *q; q++)
176 *p++ = TOLOWER (*q);
177 *p++ = suffix;
178 *p = '\0';
180 set_optab_libfunc (optable, mode,
181 ggc_alloc_string (libfunc_name, p - libfunc_name));
184 /* Like gen_libfunc, but verify that integer operation is involved. */
186 void
187 gen_int_libfunc (optab optable, const char *opname, char suffix,
188 machine_mode mode)
190 int maxsize = 2 * BITS_PER_WORD;
191 int minsize = BITS_PER_WORD;
193 if (GET_MODE_CLASS (mode) != MODE_INT)
194 return;
195 if (maxsize < LONG_LONG_TYPE_SIZE)
196 maxsize = LONG_LONG_TYPE_SIZE;
197 if (minsize > INT_TYPE_SIZE
198 && (trapv_binoptab_p (optable)
199 || trapv_unoptab_p (optable)))
200 minsize = INT_TYPE_SIZE;
201 if (GET_MODE_BITSIZE (mode) < minsize
202 || GET_MODE_BITSIZE (mode) > maxsize)
203 return;
204 gen_libfunc (optable, opname, suffix, mode);
207 /* Like gen_libfunc, but verify that FP and set decimal prefix if needed. */
209 void
210 gen_fp_libfunc (optab optable, const char *opname, char suffix,
211 machine_mode mode)
213 char *dec_opname;
215 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
216 gen_libfunc (optable, opname, suffix, mode);
217 if (DECIMAL_FLOAT_MODE_P (mode))
219 dec_opname = XALLOCAVEC (char, sizeof (DECIMAL_PREFIX) + strlen (opname));
220 /* For BID support, change the name to have either a bid_ or dpd_ prefix
221 depending on the low level floating format used. */
222 memcpy (dec_opname, DECIMAL_PREFIX, sizeof (DECIMAL_PREFIX) - 1);
223 strcpy (dec_opname + sizeof (DECIMAL_PREFIX) - 1, opname);
224 gen_libfunc (optable, dec_opname, suffix, mode);
228 /* Like gen_libfunc, but verify that fixed-point operation is involved. */
230 void
231 gen_fixed_libfunc (optab optable, const char *opname, char suffix,
232 machine_mode mode)
234 if (!ALL_FIXED_POINT_MODE_P (mode))
235 return;
236 gen_libfunc (optable, opname, suffix, mode);
239 /* Like gen_libfunc, but verify that signed fixed-point operation is
240 involved. */
242 void
243 gen_signed_fixed_libfunc (optab optable, const char *opname, char suffix,
244 machine_mode mode)
246 if (!SIGNED_FIXED_POINT_MODE_P (mode))
247 return;
248 gen_libfunc (optable, opname, suffix, mode);
251 /* Like gen_libfunc, but verify that unsigned fixed-point operation is
252 involved. */
254 void
255 gen_unsigned_fixed_libfunc (optab optable, const char *opname, char suffix,
256 machine_mode mode)
258 if (!UNSIGNED_FIXED_POINT_MODE_P (mode))
259 return;
260 gen_libfunc (optable, opname, suffix, mode);
263 /* Like gen_libfunc, but verify that FP or INT operation is involved. */
265 void
266 gen_int_fp_libfunc (optab optable, const char *name, char suffix,
267 machine_mode mode)
269 if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
270 gen_fp_libfunc (optable, name, suffix, mode);
271 if (INTEGRAL_MODE_P (mode))
272 gen_int_libfunc (optable, name, suffix, mode);
275 /* Like gen_libfunc, but verify that FP or INT operation is involved
276 and add 'v' suffix for integer operation. */
278 void
279 gen_intv_fp_libfunc (optab optable, const char *name, char suffix,
280 machine_mode mode)
282 if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
283 gen_fp_libfunc (optable, name, suffix, mode);
284 if (GET_MODE_CLASS (mode) == MODE_INT)
286 int len = strlen (name);
287 char *v_name = XALLOCAVEC (char, len + 2);
288 strcpy (v_name, name);
289 v_name[len] = 'v';
290 v_name[len + 1] = 0;
291 gen_int_libfunc (optable, v_name, suffix, mode);
295 /* Like gen_libfunc, but verify that FP or INT or FIXED operation is
296 involved. */
298 void
299 gen_int_fp_fixed_libfunc (optab optable, const char *name, char suffix,
300 machine_mode mode)
302 if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
303 gen_fp_libfunc (optable, name, suffix, mode);
304 if (INTEGRAL_MODE_P (mode))
305 gen_int_libfunc (optable, name, suffix, mode);
306 if (ALL_FIXED_POINT_MODE_P (mode))
307 gen_fixed_libfunc (optable, name, suffix, mode);
310 /* Like gen_libfunc, but verify that FP or INT or signed FIXED operation is
311 involved. */
313 void
314 gen_int_fp_signed_fixed_libfunc (optab optable, const char *name, char suffix,
315 machine_mode mode)
317 if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
318 gen_fp_libfunc (optable, name, suffix, mode);
319 if (INTEGRAL_MODE_P (mode))
320 gen_int_libfunc (optable, name, suffix, mode);
321 if (SIGNED_FIXED_POINT_MODE_P (mode))
322 gen_signed_fixed_libfunc (optable, name, suffix, mode);
325 /* Like gen_libfunc, but verify that INT or FIXED operation is
326 involved. */
328 void
329 gen_int_fixed_libfunc (optab optable, const char *name, char suffix,
330 machine_mode mode)
332 if (INTEGRAL_MODE_P (mode))
333 gen_int_libfunc (optable, name, suffix, mode);
334 if (ALL_FIXED_POINT_MODE_P (mode))
335 gen_fixed_libfunc (optable, name, suffix, mode);
338 /* Like gen_libfunc, but verify that INT or signed FIXED operation is
339 involved. */
341 void
342 gen_int_signed_fixed_libfunc (optab optable, const char *name, char suffix,
343 machine_mode mode)
345 if (INTEGRAL_MODE_P (mode))
346 gen_int_libfunc (optable, name, suffix, mode);
347 if (SIGNED_FIXED_POINT_MODE_P (mode))
348 gen_signed_fixed_libfunc (optable, name, suffix, mode);
351 /* Like gen_libfunc, but verify that INT or unsigned FIXED operation is
352 involved. */
354 void
355 gen_int_unsigned_fixed_libfunc (optab optable, const char *name, char suffix,
356 machine_mode mode)
358 if (INTEGRAL_MODE_P (mode))
359 gen_int_libfunc (optable, name, suffix, mode);
360 if (UNSIGNED_FIXED_POINT_MODE_P (mode))
361 gen_unsigned_fixed_libfunc (optable, name, suffix, mode);
364 /* Initialize the libfunc fields of an entire group of entries of an
365 inter-mode-class conversion optab. The string formation rules are
366 similar to the ones for init_libfuncs, above, but instead of having
367 a mode name and an operand count these functions have two mode names
368 and no operand count. */
370 void
371 gen_interclass_conv_libfunc (convert_optab tab,
372 const char *opname,
373 machine_mode tmode,
374 machine_mode fmode)
376 size_t opname_len = strlen (opname);
377 size_t mname_len = 0;
379 const char *fname, *tname;
380 const char *q;
381 int prefix_len = targetm.libfunc_gnu_prefix ? 6 : 2;
382 char *libfunc_name, *suffix;
383 char *nondec_name, *dec_name, *nondec_suffix, *dec_suffix;
384 char *p;
386 /* If this is a decimal conversion, add the current BID vs. DPD prefix that
387 depends on which underlying decimal floating point format is used. */
388 const size_t dec_len = sizeof (DECIMAL_PREFIX) - 1;
390 mname_len = strlen (GET_MODE_NAME (tmode)) + strlen (GET_MODE_NAME (fmode));
392 nondec_name = XALLOCAVEC (char, prefix_len + opname_len + mname_len + 1 + 1);
393 nondec_name[0] = '_';
394 nondec_name[1] = '_';
395 if (targetm.libfunc_gnu_prefix)
397 nondec_name[2] = 'g';
398 nondec_name[3] = 'n';
399 nondec_name[4] = 'u';
400 nondec_name[5] = '_';
403 memcpy (&nondec_name[prefix_len], opname, opname_len);
404 nondec_suffix = nondec_name + opname_len + prefix_len;
406 dec_name = XALLOCAVEC (char, 2 + dec_len + opname_len + mname_len + 1 + 1);
407 dec_name[0] = '_';
408 dec_name[1] = '_';
409 memcpy (&dec_name[2], DECIMAL_PREFIX, dec_len);
410 memcpy (&dec_name[2+dec_len], opname, opname_len);
411 dec_suffix = dec_name + dec_len + opname_len + 2;
413 fname = GET_MODE_NAME (fmode);
414 tname = GET_MODE_NAME (tmode);
416 if (DECIMAL_FLOAT_MODE_P (fmode) || DECIMAL_FLOAT_MODE_P (tmode))
418 libfunc_name = dec_name;
419 suffix = dec_suffix;
421 else
423 libfunc_name = nondec_name;
424 suffix = nondec_suffix;
427 p = suffix;
428 for (q = fname; *q; p++, q++)
429 *p = TOLOWER (*q);
430 for (q = tname; *q; p++, q++)
431 *p = TOLOWER (*q);
433 *p = '\0';
435 set_conv_libfunc (tab, tmode, fmode,
436 ggc_alloc_string (libfunc_name, p - libfunc_name));
439 /* Same as gen_interclass_conv_libfunc but verify that we are producing
440 int->fp conversion. */
442 void
443 gen_int_to_fp_conv_libfunc (convert_optab tab,
444 const char *opname,
445 machine_mode tmode,
446 machine_mode fmode)
448 if (GET_MODE_CLASS (fmode) != MODE_INT)
449 return;
450 if (GET_MODE_CLASS (tmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (tmode))
451 return;
452 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
455 /* ufloat_optab is special by using floatun for FP and floatuns decimal fp
456 naming scheme. */
458 void
459 gen_ufloat_conv_libfunc (convert_optab tab,
460 const char *opname ATTRIBUTE_UNUSED,
461 machine_mode tmode,
462 machine_mode fmode)
464 if (DECIMAL_FLOAT_MODE_P (tmode))
465 gen_int_to_fp_conv_libfunc (tab, "floatuns", tmode, fmode);
466 else
467 gen_int_to_fp_conv_libfunc (tab, "floatun", tmode, fmode);
470 /* Same as gen_interclass_conv_libfunc but verify that we are producing
471 fp->int conversion. */
473 void
474 gen_int_to_fp_nondecimal_conv_libfunc (convert_optab tab,
475 const char *opname,
476 machine_mode tmode,
477 machine_mode fmode)
479 if (GET_MODE_CLASS (fmode) != MODE_INT)
480 return;
481 if (GET_MODE_CLASS (tmode) != MODE_FLOAT)
482 return;
483 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
486 /* Same as gen_interclass_conv_libfunc but verify that we are producing
487 fp->int conversion with no decimal floating point involved. */
489 void
490 gen_fp_to_int_conv_libfunc (convert_optab tab,
491 const char *opname,
492 machine_mode tmode,
493 machine_mode fmode)
495 if (GET_MODE_CLASS (fmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (fmode))
496 return;
497 if (GET_MODE_CLASS (tmode) != MODE_INT)
498 return;
499 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
502 /* Initialize the libfunc fields of an of an intra-mode-class conversion optab.
503 The string formation rules are
504 similar to the ones for init_libfunc, above. */
506 void
507 gen_intraclass_conv_libfunc (convert_optab tab, const char *opname,
508 machine_mode tmode, machine_mode fmode)
510 size_t opname_len = strlen (opname);
511 size_t mname_len = 0;
513 const char *fname, *tname;
514 const char *q;
515 int prefix_len = targetm.libfunc_gnu_prefix ? 6 : 2;
516 char *nondec_name, *dec_name, *nondec_suffix, *dec_suffix;
517 char *libfunc_name, *suffix;
518 char *p;
520 /* If this is a decimal conversion, add the current BID vs. DPD prefix that
521 depends on which underlying decimal floating point format is used. */
522 const size_t dec_len = sizeof (DECIMAL_PREFIX) - 1;
524 mname_len = strlen (GET_MODE_NAME (tmode)) + strlen (GET_MODE_NAME (fmode));
526 nondec_name = XALLOCAVEC (char, 2 + opname_len + mname_len + 1 + 1);
527 nondec_name[0] = '_';
528 nondec_name[1] = '_';
529 if (targetm.libfunc_gnu_prefix)
531 nondec_name[2] = 'g';
532 nondec_name[3] = 'n';
533 nondec_name[4] = 'u';
534 nondec_name[5] = '_';
536 memcpy (&nondec_name[prefix_len], opname, opname_len);
537 nondec_suffix = nondec_name + opname_len + prefix_len;
539 dec_name = XALLOCAVEC (char, 2 + dec_len + opname_len + mname_len + 1 + 1);
540 dec_name[0] = '_';
541 dec_name[1] = '_';
542 memcpy (&dec_name[2], DECIMAL_PREFIX, dec_len);
543 memcpy (&dec_name[2 + dec_len], opname, opname_len);
544 dec_suffix = dec_name + dec_len + opname_len + 2;
546 fname = GET_MODE_NAME (fmode);
547 tname = GET_MODE_NAME (tmode);
549 if (DECIMAL_FLOAT_MODE_P (fmode) || DECIMAL_FLOAT_MODE_P (tmode))
551 libfunc_name = dec_name;
552 suffix = dec_suffix;
554 else
556 libfunc_name = nondec_name;
557 suffix = nondec_suffix;
560 p = suffix;
561 for (q = fname; *q; p++, q++)
562 *p = TOLOWER (*q);
563 for (q = tname; *q; p++, q++)
564 *p = TOLOWER (*q);
566 *p++ = '2';
567 *p = '\0';
569 set_conv_libfunc (tab, tmode, fmode,
570 ggc_alloc_string (libfunc_name, p - libfunc_name));
573 /* Pick proper libcall for trunc_optab. We need to chose if we do
574 truncation or extension and interclass or intraclass. */
576 void
577 gen_trunc_conv_libfunc (convert_optab tab,
578 const char *opname,
579 machine_mode tmode,
580 machine_mode fmode)
582 if (GET_MODE_CLASS (tmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (tmode))
583 return;
584 if (GET_MODE_CLASS (fmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (fmode))
585 return;
586 if (tmode == fmode)
587 return;
589 if ((GET_MODE_CLASS (tmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (fmode))
590 || (GET_MODE_CLASS (fmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (tmode)))
591 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
593 if (GET_MODE_PRECISION (fmode) <= GET_MODE_PRECISION (tmode))
594 return;
596 if ((GET_MODE_CLASS (tmode) == MODE_FLOAT
597 && GET_MODE_CLASS (fmode) == MODE_FLOAT)
598 || (DECIMAL_FLOAT_MODE_P (fmode) && DECIMAL_FLOAT_MODE_P (tmode)))
599 gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
602 /* Pick proper libcall for extend_optab. We need to chose if we do
603 truncation or extension and interclass or intraclass. */
605 void
606 gen_extend_conv_libfunc (convert_optab tab,
607 const char *opname ATTRIBUTE_UNUSED,
608 machine_mode tmode,
609 machine_mode fmode)
611 if (GET_MODE_CLASS (tmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (tmode))
612 return;
613 if (GET_MODE_CLASS (fmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (fmode))
614 return;
615 if (tmode == fmode)
616 return;
618 if ((GET_MODE_CLASS (tmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (fmode))
619 || (GET_MODE_CLASS (fmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (tmode)))
620 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
622 if (GET_MODE_PRECISION (fmode) > GET_MODE_PRECISION (tmode))
623 return;
625 if ((GET_MODE_CLASS (tmode) == MODE_FLOAT
626 && GET_MODE_CLASS (fmode) == MODE_FLOAT)
627 || (DECIMAL_FLOAT_MODE_P (fmode) && DECIMAL_FLOAT_MODE_P (tmode)))
628 gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
631 /* Pick proper libcall for fract_optab. We need to chose if we do
632 interclass or intraclass. */
634 void
635 gen_fract_conv_libfunc (convert_optab tab,
636 const char *opname,
637 machine_mode tmode,
638 machine_mode fmode)
640 if (tmode == fmode)
641 return;
642 if (!(ALL_FIXED_POINT_MODE_P (tmode) || ALL_FIXED_POINT_MODE_P (fmode)))
643 return;
645 if (GET_MODE_CLASS (tmode) == GET_MODE_CLASS (fmode))
646 gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
647 else
648 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
651 /* Pick proper libcall for fractuns_optab. */
653 void
654 gen_fractuns_conv_libfunc (convert_optab tab,
655 const char *opname,
656 machine_mode tmode,
657 machine_mode fmode)
659 if (tmode == fmode)
660 return;
661 /* One mode must be a fixed-point mode, and the other must be an integer
662 mode. */
663 if (!((ALL_FIXED_POINT_MODE_P (tmode) && GET_MODE_CLASS (fmode) == MODE_INT)
664 || (ALL_FIXED_POINT_MODE_P (fmode)
665 && GET_MODE_CLASS (tmode) == MODE_INT)))
666 return;
668 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
671 /* Pick proper libcall for satfract_optab. We need to chose if we do
672 interclass or intraclass. */
674 void
675 gen_satfract_conv_libfunc (convert_optab tab,
676 const char *opname,
677 machine_mode tmode,
678 machine_mode fmode)
680 if (tmode == fmode)
681 return;
682 /* TMODE must be a fixed-point mode. */
683 if (!ALL_FIXED_POINT_MODE_P (tmode))
684 return;
686 if (GET_MODE_CLASS (tmode) == GET_MODE_CLASS (fmode))
687 gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
688 else
689 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
692 /* Pick proper libcall for satfractuns_optab. */
694 void
695 gen_satfractuns_conv_libfunc (convert_optab tab,
696 const char *opname,
697 machine_mode tmode,
698 machine_mode fmode)
700 if (tmode == fmode)
701 return;
702 /* TMODE must be a fixed-point mode, and FMODE must be an integer mode. */
703 if (!(ALL_FIXED_POINT_MODE_P (tmode) && GET_MODE_CLASS (fmode) == MODE_INT))
704 return;
706 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
709 /* Hashtable callbacks for libfunc_decls. */
711 struct libfunc_decl_hasher : ggc_ptr_hash<tree_node>
713 static hashval_t
714 hash (tree entry)
716 return IDENTIFIER_HASH_VALUE (DECL_NAME (entry));
719 static bool
720 equal (tree decl, tree name)
722 return DECL_NAME (decl) == name;
726 /* A table of previously-created libfuncs, hashed by name. */
727 static GTY (()) hash_table<libfunc_decl_hasher> *libfunc_decls;
729 /* Build a decl for a libfunc named NAME. */
731 tree
732 build_libfunc_function (const char *name)
734 /* ??? We don't have any type information; pretend this is "int foo ()". */
735 tree decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
736 get_identifier (name),
737 build_function_type (integer_type_node, NULL_TREE));
738 DECL_EXTERNAL (decl) = 1;
739 TREE_PUBLIC (decl) = 1;
740 DECL_ARTIFICIAL (decl) = 1;
741 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
742 DECL_VISIBILITY_SPECIFIED (decl) = 1;
743 gcc_assert (DECL_ASSEMBLER_NAME (decl));
745 /* Zap the nonsensical SYMBOL_REF_DECL for this. What we're left with
746 are the flags assigned by targetm.encode_section_info. */
747 SET_SYMBOL_REF_DECL (XEXP (DECL_RTL (decl), 0), NULL);
749 return decl;
752 /* Return a libfunc for NAME, creating one if we don't already have one.
753 The returned rtx is a SYMBOL_REF. */
756 init_one_libfunc (const char *name)
758 tree id, decl;
759 hashval_t hash;
761 if (libfunc_decls == NULL)
762 libfunc_decls = hash_table<libfunc_decl_hasher>::create_ggc (37);
764 /* See if we have already created a libfunc decl for this function. */
765 id = get_identifier (name);
766 hash = IDENTIFIER_HASH_VALUE (id);
767 tree *slot = libfunc_decls->find_slot_with_hash (id, hash, INSERT);
768 decl = *slot;
769 if (decl == NULL)
771 /* Create a new decl, so that it can be passed to
772 targetm.encode_section_info. */
773 decl = build_libfunc_function (name);
774 *slot = decl;
776 return XEXP (DECL_RTL (decl), 0);
779 /* Adjust the assembler name of libfunc NAME to ASMSPEC. */
782 set_user_assembler_libfunc (const char *name, const char *asmspec)
784 tree id, decl;
785 hashval_t hash;
787 id = get_identifier (name);
788 hash = IDENTIFIER_HASH_VALUE (id);
789 tree *slot = libfunc_decls->find_slot_with_hash (id, hash, NO_INSERT);
790 gcc_assert (slot);
791 decl = (tree) *slot;
792 set_user_assembler_name (decl, asmspec);
793 return XEXP (DECL_RTL (decl), 0);
796 /* Call this to reset the function entry for one optab (OPTABLE) in mode
797 MODE to NAME, which should be either 0 or a string constant. */
799 void
800 set_optab_libfunc (optab op, machine_mode mode, const char *name)
802 rtx val;
803 struct libfunc_entry e;
804 struct libfunc_entry **slot;
806 e.op = op;
807 e.mode1 = mode;
808 e.mode2 = VOIDmode;
810 if (name)
811 val = init_one_libfunc (name);
812 else
813 val = 0;
814 slot = libfunc_hash->find_slot (&e, INSERT);
815 if (*slot == NULL)
816 *slot = ggc_alloc<libfunc_entry> ();
817 (*slot)->op = op;
818 (*slot)->mode1 = mode;
819 (*slot)->mode2 = VOIDmode;
820 (*slot)->libfunc = val;
823 /* Call this to reset the function entry for one conversion optab
824 (OPTABLE) from mode FMODE to mode TMODE to NAME, which should be
825 either 0 or a string constant. */
827 void
828 set_conv_libfunc (convert_optab optab, machine_mode tmode,
829 machine_mode fmode, const char *name)
831 rtx val;
832 struct libfunc_entry e;
833 struct libfunc_entry **slot;
835 e.op = optab;
836 e.mode1 = tmode;
837 e.mode2 = fmode;
839 if (name)
840 val = init_one_libfunc (name);
841 else
842 val = 0;
843 slot = libfunc_hash->find_slot (&e, INSERT);
844 if (*slot == NULL)
845 *slot = ggc_alloc<libfunc_entry> ();
846 (*slot)->op = optab;
847 (*slot)->mode1 = tmode;
848 (*slot)->mode2 = fmode;
849 (*slot)->libfunc = val;
852 /* Call this to initialize the contents of the optabs
853 appropriately for the current target machine. */
855 void
856 init_optabs (void)
858 if (libfunc_hash)
859 libfunc_hash->empty ();
860 else
861 libfunc_hash = hash_table<libfunc_hasher>::create_ggc (10);
863 /* Fill in the optabs with the insns we support. */
864 init_all_optabs (this_fn_optabs);
866 /* The ffs function operates on `int'. Fall back on it if we do not
867 have a libgcc2 function for that width. */
868 if (INT_TYPE_SIZE < BITS_PER_WORD)
869 set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE, MODE_INT, 0),
870 "ffs");
872 /* Explicitly initialize the bswap libfuncs since we need them to be
873 valid for things other than word_mode. */
874 if (targetm.libfunc_gnu_prefix)
876 set_optab_libfunc (bswap_optab, SImode, "__gnu_bswapsi2");
877 set_optab_libfunc (bswap_optab, DImode, "__gnu_bswapdi2");
879 else
881 set_optab_libfunc (bswap_optab, SImode, "__bswapsi2");
882 set_optab_libfunc (bswap_optab, DImode, "__bswapdi2");
885 /* Use cabs for double complex abs, since systems generally have cabs.
886 Don't define any libcall for float complex, so that cabs will be used. */
887 if (complex_double_type_node)
888 set_optab_libfunc (abs_optab, TYPE_MODE (complex_double_type_node),
889 "cabs");
891 unwind_sjlj_register_libfunc = init_one_libfunc ("_Unwind_SjLj_Register");
892 unwind_sjlj_unregister_libfunc
893 = init_one_libfunc ("_Unwind_SjLj_Unregister");
895 /* Allow the target to add more libcalls or rename some, etc. */
896 targetm.init_libfuncs ();
899 /* A helper function for init_sync_libfuncs. Using the basename BASE,
900 install libfuncs into TAB for BASE_N for 1 <= N <= MAX. */
902 static void
903 init_sync_libfuncs_1 (optab tab, const char *base, int max)
905 machine_mode mode;
906 char buf[64];
907 size_t len = strlen (base);
908 int i;
910 gcc_assert (max <= 8);
911 gcc_assert (len + 3 < sizeof (buf));
913 memcpy (buf, base, len);
914 buf[len] = '_';
915 buf[len + 1] = '0';
916 buf[len + 2] = '\0';
918 mode = QImode;
919 for (i = 1; i <= max; i *= 2)
921 buf[len + 1] = '0' + i;
922 set_optab_libfunc (tab, mode, buf);
923 mode = GET_MODE_2XWIDER_MODE (mode);
927 void
928 init_sync_libfuncs (int max)
930 if (!flag_sync_libcalls)
931 return;
933 init_sync_libfuncs_1 (sync_compare_and_swap_optab,
934 "__sync_val_compare_and_swap", max);
935 init_sync_libfuncs_1 (sync_lock_test_and_set_optab,
936 "__sync_lock_test_and_set", max);
938 init_sync_libfuncs_1 (sync_old_add_optab, "__sync_fetch_and_add", max);
939 init_sync_libfuncs_1 (sync_old_sub_optab, "__sync_fetch_and_sub", max);
940 init_sync_libfuncs_1 (sync_old_ior_optab, "__sync_fetch_and_or", max);
941 init_sync_libfuncs_1 (sync_old_and_optab, "__sync_fetch_and_and", max);
942 init_sync_libfuncs_1 (sync_old_xor_optab, "__sync_fetch_and_xor", max);
943 init_sync_libfuncs_1 (sync_old_nand_optab, "__sync_fetch_and_nand", max);
945 init_sync_libfuncs_1 (sync_new_add_optab, "__sync_add_and_fetch", max);
946 init_sync_libfuncs_1 (sync_new_sub_optab, "__sync_sub_and_fetch", max);
947 init_sync_libfuncs_1 (sync_new_ior_optab, "__sync_or_and_fetch", max);
948 init_sync_libfuncs_1 (sync_new_and_optab, "__sync_and_and_fetch", max);
949 init_sync_libfuncs_1 (sync_new_xor_optab, "__sync_xor_and_fetch", max);
950 init_sync_libfuncs_1 (sync_new_nand_optab, "__sync_nand_and_fetch", max);
953 #include "gt-optabs-libfuncs.h"