2011-04-20 10:21:25 +02:00
|
|
|
/* Internal functions.
|
2015-01-05 13:33:28 +01:00
|
|
|
Copyright (C) 2011-2015 Free Software Foundation, Inc.
|
2011-04-20 10:21:25 +02:00
|
|
|
|
|
|
|
This file is part of GCC.
|
|
|
|
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
|
|
the terms of the GNU General Public License as published by the Free
|
|
|
|
Software Foundation; either version 3, or (at your option) any later
|
|
|
|
version.
|
|
|
|
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with GCC; see the file COPYING3. If not see
|
|
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
#ifndef GCC_INTERNAL_FN_H
|
|
|
|
#define GCC_INTERNAL_FN_H
|
|
|
|
|
2015-10-27 21:16:04 +01:00
|
|
|
/* INTEGER_CST values for IFN_UNIQUE function arg-0. */
|
|
|
|
enum ifn_unique_kind {
|
internal-fn.def (IFN_GOACC_DIM_SIZE, [...]): New.
* internal-fn.def (IFN_GOACC_DIM_SIZE, IFN_GOACC_DIM_POS,
IFN_GOACC_LOOP): New.
* internal-fn.h (enum ifn_unique_kind): Add IFN_UNIQUE_OACC_FORK,
IFN_UNIQUE_OACC_JOIN, IFN_UNIQUE_OACC_HEAD_MARK,
IFN_UNIQUE_OACC_TAIL_MARK.
(enum ifn_goacc_loop_kind): New.
* internal-fn.c (expand_UNIQUE): Add IFN_UNIQUE_OACC_FORK,
IFN_UNIQUE_OACC_JOIN cases.
(expand_GOACC_DIM_SIZE, expand_GOACC_DIM_POS): New.
(expand_GOACC_LOOP): New.
* target-insns.def (oacc_dim_pos, oacc_dim_size): New.
* omp-low.c: Include gimple-pretty-print.h.
(struct oacc_loop): New.
(enum oacc_loop_flags): New.
(oacc_thread_numbers): New.
(oacc_xform_loop): New.
(new_oacc_loop_raw, new_oacc_loop_outer, new_oacc_loop,
new_oacc_loop_routine, finish_oacc_loop, free_oacc_loop): New,
(dump_oacc_loop_part, dump_oacc_loop, debug_oacc_loop): New,
(oacc_loop_discover_walk, oacc_loop_sibling_nrevers,
oacc_loop_discovery): New.
(oacc_loop_xform_head_tail, oacc_loop_xform_loop,
oacc_loop_process): New.
(oacc_loop_fixed_partitions, oacc_loop_partition): New.
(execute_oacc_device_lower): Discover & process loops. Process
internal fns.
* target.def (goacc.fork_join): Change sense of hook, clarify
documentation.
* doc/tm.texi: Regenerated.
From-SVN: r229466
2015-10-28 00:46:39 +01:00
|
|
|
IFN_UNIQUE_UNSPEC, /* Undifferentiated UNIQUE. */
|
|
|
|
|
|
|
|
/* FORK and JOIN mark the points at which OpenACC partitioned
|
|
|
|
execution is entered or exited.
|
|
|
|
return: data dependency value
|
|
|
|
arg-1: data dependency var
|
|
|
|
arg-2: INTEGER_CST argument, indicating the axis. */
|
|
|
|
IFN_UNIQUE_OACC_FORK,
|
|
|
|
IFN_UNIQUE_OACC_JOIN,
|
|
|
|
|
|
|
|
/* HEAD_MARK and TAIL_MARK are used to demark the sequence entering
|
|
|
|
or leaving partitioned execution.
|
|
|
|
return: data dependency value
|
|
|
|
arg-1: data dependency var
|
|
|
|
arg-2: INTEGER_CST argument, remaining markers in this sequence
|
|
|
|
arg-3...: varargs on primary header */
|
|
|
|
IFN_UNIQUE_OACC_HEAD_MARK,
|
|
|
|
IFN_UNIQUE_OACC_TAIL_MARK
|
|
|
|
};
|
|
|
|
|
|
|
|
/* INTEGER_CST values for IFN_GOACC_LOOP arg-0. Allows the precise
|
|
|
|
stepping of the compute geometry over the loop iterations to be
|
|
|
|
deferred until it is known which compiler is generating the code.
|
|
|
|
The action is encoded in a constant first argument.
|
|
|
|
|
|
|
|
CHUNK_MAX = LOOP (CODE_CHUNKS, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
|
|
|
|
STEP = LOOP (CODE_STEP, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
|
|
|
|
OFFSET = LOOP (CODE_OFFSET, DIR, RANGE, STEP, CHUNK_SIZE, MASK, CHUNK_NO)
|
|
|
|
BOUND = LOOP (CODE_BOUND, DIR, RANGE, STEP, CHUNK_SIZE, MASK, OFFSET)
|
|
|
|
|
|
|
|
DIR - +1 for up loop, -1 for down loop
|
|
|
|
RANGE - Range of loop (END - BASE)
|
|
|
|
STEP - iteration step size
|
|
|
|
CHUNKING - size of chunking, (constant zero for no chunking)
|
|
|
|
CHUNK_NO - chunk number
|
|
|
|
MASK - partitioning mask. */
|
|
|
|
|
|
|
|
enum ifn_goacc_loop_kind {
|
|
|
|
IFN_GOACC_LOOP_CHUNKS, /* Number of chunks. */
|
|
|
|
IFN_GOACC_LOOP_STEP, /* Size of each thread's step. */
|
|
|
|
IFN_GOACC_LOOP_OFFSET, /* Initial iteration value. */
|
|
|
|
IFN_GOACC_LOOP_BOUND /* Limit of iteration value. */
|
2015-10-27 21:16:04 +01:00
|
|
|
};
|
|
|
|
|
2015-11-04 17:57:36 +01:00
|
|
|
/* The GOACC_REDUCTION function defines a generic interface to support
|
|
|
|
gang, worker and vector reductions. All calls are of the following
|
|
|
|
form:
|
|
|
|
|
|
|
|
V = REDUCTION (CODE, REF_TO_RES, LOCAL_VAR, LEVEL, OP, OFFSET)
|
|
|
|
|
|
|
|
REF_TO_RES - is a reference to the original reduction varl, may be NULL
|
|
|
|
LOCAL_VAR is the intermediate reduction variable
|
|
|
|
LEVEL corresponds to the GOMP_DIM of the reduction
|
|
|
|
OP is the tree code of the reduction operation
|
|
|
|
OFFSET may be used as an offset into a reduction array for the
|
|
|
|
reductions occuring at this level.
|
|
|
|
In general the return value is LOCAL_VAR, which creates a data
|
|
|
|
dependency between calls operating on the same reduction. */
|
|
|
|
|
|
|
|
enum ifn_goacc_reduction_kind {
|
|
|
|
IFN_GOACC_REDUCTION_SETUP,
|
|
|
|
IFN_GOACC_REDUCTION_INIT,
|
|
|
|
IFN_GOACC_REDUCTION_FINI,
|
|
|
|
IFN_GOACC_REDUCTION_TEARDOWN
|
|
|
|
};
|
|
|
|
|
2014-08-11 08:06:29 +02:00
|
|
|
/* Initialize internal function tables. */
|
|
|
|
|
|
|
|
extern void init_internal_fns ();
|
|
|
|
|
2011-04-20 10:21:25 +02:00
|
|
|
/* Return the name of internal function FN. The name is only meaningful
|
|
|
|
for dumps; it has no linkage. */
|
|
|
|
|
2011-04-28 03:25:01 +02:00
|
|
|
extern const char *const internal_fn_name_array[];
|
|
|
|
|
2011-04-20 10:21:25 +02:00
|
|
|
static inline const char *
|
|
|
|
internal_fn_name (enum internal_fn fn)
|
|
|
|
{
|
|
|
|
return internal_fn_name_array[(int) fn];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the ECF_* flags for function FN. */
|
|
|
|
|
2011-04-28 03:25:01 +02:00
|
|
|
extern const int internal_fn_flags_array[];
|
|
|
|
|
2011-04-20 10:21:25 +02:00
|
|
|
static inline int
|
|
|
|
internal_fn_flags (enum internal_fn fn)
|
|
|
|
{
|
|
|
|
return internal_fn_flags_array[(int) fn];
|
|
|
|
}
|
|
|
|
|
2014-08-11 08:06:29 +02:00
|
|
|
/* Return fnspec for function FN. */
|
|
|
|
|
|
|
|
extern GTY(()) const_tree internal_fn_fnspec_array[IFN_LAST + 1];
|
|
|
|
|
|
|
|
static inline const_tree
|
|
|
|
internal_fn_fnspec (enum internal_fn fn)
|
|
|
|
{
|
|
|
|
return internal_fn_fnspec_array[(int) fn];
|
|
|
|
}
|
|
|
|
|
Add basic support for direct_optab internal functions
This patch adds a concept of internal functions that map directly to an
optab (here called "direct internal functions"). The function can only
be used if the associated optab can be used.
We currently have four functions like that:
- LOAD_LANES
- STORE_LANES
- MASK_LOAD
- MASK_STORE
so the patch converts them to the new infrastructure. These four
all need different types of optabs, but future patches will add
regular unary and binary ones.
In general we need one or two modes to decide whether an optab is
supported, depending on whether it's a convert_optab or not.
This in turn means that we need up to two types to decide whether
an internal function is supported. The patch records which types
are needed for each internal function, using -1 if the return type
should be used and N>=0 if the type of argument N should be used.
(LOAD_LANES and STORE_LANES are unusual in that both optab modes
come from the same array type.)
Tested on x86_64-linux-gnu, aarch64-linux-gnu and arm-linux-gnueabi.
gcc/
* coretypes.h (tree_pair): New type.
* internal-fn.def (DEF_INTERNAL_OPTAB_FN): New macro. Use it
for MASK_LOAD, LOAD_LANES, MASK_STORE and STORE_LANES.
* internal-fn.h (direct_internal_fn_info): New structure.
(direct_internal_fn_array): Declare.
(direct_internal_fn_p, direct_internal_fn): New functions.
(direct_internal_fn_types, direct_internal_fn_supported_p): Declare.
* internal-fn.c (not_direct, mask_load_direct, load_lanes_direct)
(mask_store_direct, store_lanes_direct): New macros.
(direct_internal_fn_array) New array.
(get_multi_vector_move): Return the optab handler without asserting
that it is available.
(expand_LOAD_LANES): Rename to...
(expand_load_lanes_optab_fn): ...this and add an optab argument.
(expand_STORE_LANES): Rename to...
(expand_store_lanes_optab_fn): ...this and add an optab argument.
(expand_MASK_LOAD): Rename to...
(expand_mask_load_optab_fn): ...this and add an optab argument.
(expand_MASK_STORE): Rename to...
(expand_mask_store_optab_fn): ...this and add an optab argument.
(direct_internal_fn_types, direct_optab_supported_p)
(multi_vector_optab_supported_p, direct_internal_fn_supported_p)
(direct_internal_fn_supported_p): New functions.
(direct_mask_load_optab_supported_p): New macro.
(direct_load_lanes_optab_supported_p): Likewise.
(direct_mask_store_optab_supported_p): Likewise.
(direct_store_lanes_optab_supported_p): Likewise.
From-SVN: r230473
2015-11-17 19:37:45 +01:00
|
|
|
/* Describes an internal function that maps directly to an optab. */
|
|
|
|
struct direct_internal_fn_info
|
|
|
|
{
|
|
|
|
/* optabs can be parameterized by one or two modes. These fields describe
|
|
|
|
how to select those modes from the types of the return value and
|
|
|
|
arguments. A value of -1 says that the mode is determined by the
|
|
|
|
return type while a value N >= 0 says that the mode is determined by
|
|
|
|
the type of argument N. A value of -2 says that this internal
|
|
|
|
function isn't directly mapped to an optab. */
|
|
|
|
signed int type0 : 8;
|
|
|
|
signed int type1 : 8;
|
|
|
|
};
|
|
|
|
|
|
|
|
extern const direct_internal_fn_info direct_internal_fn_array[IFN_LAST + 1];
|
|
|
|
|
|
|
|
/* Return true if FN is mapped directly to an optab. */
|
|
|
|
|
|
|
|
inline bool
|
|
|
|
direct_internal_fn_p (internal_fn fn)
|
|
|
|
{
|
|
|
|
return direct_internal_fn_array[fn].type0 >= -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return optab information about internal function FN. Only meaningful
|
|
|
|
if direct_internal_fn_p (FN). */
|
|
|
|
|
|
|
|
inline const direct_internal_fn_info &
|
|
|
|
direct_internal_fn (internal_fn fn)
|
|
|
|
{
|
|
|
|
gcc_checking_assert (direct_internal_fn_p (fn));
|
|
|
|
return direct_internal_fn_array[fn];
|
|
|
|
}
|
|
|
|
|
|
|
|
extern tree_pair direct_internal_fn_types (internal_fn, tree, tree *);
|
|
|
|
extern tree_pair direct_internal_fn_types (internal_fn, gcall *);
|
|
|
|
extern bool direct_internal_fn_supported_p (internal_fn, tree_pair);
|
|
|
|
extern bool direct_internal_fn_supported_p (internal_fn, tree);
|
|
|
|
|
2014-11-19 18:00:54 +01:00
|
|
|
extern void expand_internal_call (gcall *);
|
2011-04-20 10:21:25 +02:00
|
|
|
|
|
|
|
#endif
|