Actually add the test case from the previous commit.
From-SVN: r207422
This commit is contained in:
Andrey Belevantsev
parent
861ec4f37e
commit
cbb436643a
1 changed files with 339 additions and 0 deletions
339
gcc/testsuite/g++.dg/pr57662.C
Normal file
339
gcc/testsuite/g++.dg/pr57662.C
Normal file
|
|
@ -0,0 +1,339 @@
|
|||
/* { dg-do compile { target powerpc*-*-* ia64-*-* x86_64-*-* } } */
|
||||
/* { dg-options "-O2 -fselective-scheduling2 -fsel-sched-pipelining" } */
|
||||
|
||||
extern "C" {
|
||||
typedef struct _IO_FILE FILE;
|
||||
extern int putc(int __c, FILE * __stream);
|
||||
extern int strcmp(__const char *__s1, __const char *__s2) throw()
|
||||
__attribute__ ((__pure__)) __attribute__ ((__nonnull__(1, 2)));
|
||||
} typedef union tree_node *tree;
|
||||
struct gcc_options {
|
||||
int x_flag_openmp;
|
||||
};
|
||||
extern struct gcc_options global_options;
|
||||
struct ht_identifier {
|
||||
const unsigned char *str;
|
||||
};
|
||||
enum cpp_ttype {
|
||||
CPP_SEMICOLON, CPP_NAME
|
||||
};
|
||||
struct vl_embed {
|
||||
};
|
||||
struct va_heap {
|
||||
};
|
||||
struct va_gc {
|
||||
typedef vl_embed default_layout;
|
||||
};
|
||||
template < typename T, typename A = va_heap, typename L =
|
||||
typename A::default_layout > struct vec {
|
||||
};
|
||||
enum tree_code {
|
||||
ERROR_MARK,
|
||||
IDENTIFIER_NODE,
|
||||
OMP_SIMD,
|
||||
CILK_SIMD,
|
||||
MAX_TREE_CODES
|
||||
};
|
||||
struct tree_identifier {
|
||||
struct ht_identifier
|
||||
id;
|
||||
};
|
||||
union tree_node {
|
||||
struct tree_identifier
|
||||
identifier;
|
||||
};
|
||||
inline tree
|
||||
tree_check(tree __t, const char *__f, int __l, const char *__g, tree_code __c)
|
||||
{
|
||||
}
|
||||
|
||||
extern tree chainon(tree, tree);
|
||||
extern vec < tree, va_gc > *make_tree_vector(void);
|
||||
typedef unsigned long omp_clause_mask;
|
||||
enum c_omp_clause_split {
|
||||
C_OMP_CLAUSE_SPLIT_TARGET = 0, C_OMP_CLAUSE_SPLIT_COUNT
|
||||
};
|
||||
typedef struct cxx_saved_binding {
|
||||
tree attributes;
|
||||
} cp_decl_specifier_seq;
|
||||
typedef enum pragma_kind {
|
||||
PRAGMA_NONE = 0, PRAGMA_OMP_DECLARE_REDUCTION, PRAGMA_OMP_TARGET
|
||||
} pragma_kind;
|
||||
typedef enum pragma_omp_clause {
|
||||
PRAGMA_OMP_CLAUSE_NONE =
|
||||
0, PRAGMA_OMP_CLAUSE_DEVICE, PRAGMA_OMP_CLAUSE_IF,
|
||||
PRAGMA_OMP_CLAUSE_MAP
|
||||
} pragma_omp_clause;
|
||||
typedef struct cp_token {
|
||||
enum cpp_ttype type:8;
|
||||
union cp_token_value {
|
||||
tree value;
|
||||
} u;
|
||||
} cp_token;
|
||||
typedef struct cp_token *cp_token_position;
|
||||
typedef struct cp_lexer {
|
||||
cp_token_position next_token;
|
||||
bool debugging_p;
|
||||
cp_lexer *lexer;
|
||||
} cp_parser;
|
||||
static FILE *cp_lexer_debug_stream;
|
||||
static inline bool cp_lexer_debugging_p(cp_lexer * lexer)
|
||||
{
|
||||
return lexer->debugging_p;
|
||||
}
|
||||
|
||||
static inline cp_token *cp_lexer_peek_token(cp_lexer * lexer)
|
||||
{
|
||||
if (cp_lexer_debugging_p(lexer)) {
|
||||
putc('\n', cp_lexer_debug_stream);
|
||||
}
|
||||
return lexer->next_token;
|
||||
}
|
||||
|
||||
static inline bool cp_lexer_next_token_is(cp_lexer * lexer, enum cpp_ttype type)
|
||||
{
|
||||
}
|
||||
|
||||
enum {
|
||||
CP_PARSER_FLAGS_NONE = 0x0, CP_PARSER_FLAGS_OPTIONAL =
|
||||
0x1, CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES =
|
||||
0x2, CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS =
|
||||
0x4, CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR = 0x8
|
||||
};
|
||||
typedef int cp_parser_flags;
|
||||
extern tree
|
||||
cp_parser_type_specifier(cp_parser *, cp_parser_flags,
|
||||
cp_decl_specifier_seq *, bool, int *, bool *);
|
||||
static void
|
||||
cp_parser_type_specifier_seq(cp_parser *, bool, bool, cp_decl_specifier_seq *);
|
||||
extern bool cp_next_tokens_can_be_attribute_p(cp_parser *);
|
||||
extern tree cp_parser_attributes_opt(cp_parser *);
|
||||
enum pragma_context {
|
||||
pragma_external,
|
||||
pragma_member,
|
||||
pragma_objc_icode,
|
||||
pragma_stmt,
|
||||
pragma_compound
|
||||
};
|
||||
static bool cp_parser_pragma(cp_parser *, enum pragma_context);
|
||||
static bool cp_parser_translation_unit(cp_parser * parser)
|
||||
{
|
||||
while (true) {
|
||||
cp_token *token;
|
||||
if (token->type == CPP_SEMICOLON) {
|
||||
cp_parser_pragma(parser, pragma_external);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static tree
|
||||
cp_parser_type_id_1(cp_parser * parser, bool is_template_arg,
|
||||
bool is_trailing_return)
|
||||
{
|
||||
cp_decl_specifier_seq type_specifier_seq;
|
||||
cp_parser_type_specifier_seq(parser, false, is_trailing_return,
|
||||
&type_specifier_seq);
|
||||
}
|
||||
|
||||
static tree cp_parser_type_id(cp_parser * parser)
|
||||
{
|
||||
return cp_parser_type_id_1(parser, false, false);
|
||||
}
|
||||
|
||||
static void
|
||||
cp_parser_type_specifier_seq(cp_parser * parser, bool is_declaration,
|
||||
bool is_trailing_return,
|
||||
cp_decl_specifier_seq * type_specifier_seq)
|
||||
{
|
||||
cp_parser_flags flags = CP_PARSER_FLAGS_OPTIONAL;
|
||||
cp_token *start_token = __null;
|
||||
while (true) {
|
||||
tree type_specifier;
|
||||
bool is_cv_qualifier;
|
||||
if (cp_next_tokens_can_be_attribute_p(parser)) {
|
||||
type_specifier_seq->attributes =
|
||||
chainon(type_specifier_seq->attributes,
|
||||
cp_parser_attributes_opt(parser));
|
||||
continue;
|
||||
}
|
||||
if (!start_token)
|
||||
start_token = cp_lexer_peek_token(parser->lexer);
|
||||
type_specifier =
|
||||
cp_parser_type_specifier(parser, flags, type_specifier_seq,
|
||||
false, __null, &is_cv_qualifier);
|
||||
if (!type_specifier) {
|
||||
break;
|
||||
}
|
||||
if (is_declaration && !is_cv_qualifier)
|
||||
flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
|
||||
}
|
||||
}
|
||||
|
||||
static bool
|
||||
cp_parser_omp_for_loop_init(cp_parser * parser, bool parsing_openmp,
|
||||
tree & this_pre_body, vec < tree,
|
||||
va_gc > *for_block, tree & init, tree & decl,
|
||||
tree & real_decl)
|
||||
{
|
||||
cp_decl_specifier_seq type_specifiers;
|
||||
cp_parser_type_specifier_seq(parser, true, false, &type_specifiers);
|
||||
}
|
||||
|
||||
static tree
|
||||
cp_parser_omp_for_loop(cp_parser * parser, enum tree_code code, tree clauses,
|
||||
tree * cclauses)
|
||||
{
|
||||
tree init, cond, incr, body, decl, pre_body = (tree) __null, ret;
|
||||
tree real_decl, initv, condv, incrv, declv;
|
||||
tree this_pre_body, cl;
|
||||
int i, collapse = 1, nbraces = 0;
|
||||
vec < tree, va_gc > *for_block = make_tree_vector();
|
||||
for (i = 0; i < collapse; i++) {
|
||||
bool add_private_clause = false;
|
||||
add_private_clause |=
|
||||
cp_parser_omp_for_loop_init(parser, code != CILK_SIMD,
|
||||
this_pre_body, for_block, init,
|
||||
decl, real_decl);
|
||||
}
|
||||
}
|
||||
|
||||
static tree
|
||||
cp_parser_omp_simd(cp_parser * parser, cp_token * pragma_tok, char *p_name,
|
||||
omp_clause_mask mask, tree * cclauses)
|
||||
{
|
||||
tree clauses, sb, ret;
|
||||
ret = cp_parser_omp_for_loop(parser, OMP_SIMD, clauses, cclauses);
|
||||
}
|
||||
|
||||
static tree
|
||||
cp_parser_omp_distribute(cp_parser * parser, cp_token * pragma_tok,
|
||||
char *p_name, omp_clause_mask mask, tree * cclauses)
|
||||
{
|
||||
if (cp_lexer_next_token_is(parser->lexer, CPP_NAME)) {
|
||||
tree id = cp_lexer_peek_token(parser->lexer)->u.value;
|
||||
const char *p =
|
||||
((const char
|
||||
*)(tree_check((id),
|
||||
"/home/bonzo/develop/trunk/gcc/cp/parser.c",
|
||||
29966, __FUNCTION__,
|
||||
(IDENTIFIER_NODE)))->identifier.id.str);
|
||||
bool simd = false;
|
||||
bool parallel = false;
|
||||
if (strcmp(p, "simd") == 0)
|
||||
simd = true;
|
||||
if (parallel || simd) {
|
||||
if (!global_options.x_flag_openmp) {
|
||||
if (simd)
|
||||
return cp_parser_omp_simd(parser,
|
||||
pragma_tok,
|
||||
p_name, mask,
|
||||
cclauses);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static tree
|
||||
cp_parser_omp_teams(cp_parser * parser, cp_token * pragma_tok, char *p_name,
|
||||
omp_clause_mask mask, tree * cclauses)
|
||||
{
|
||||
if (cp_lexer_next_token_is(parser->lexer, CPP_NAME)) {
|
||||
tree id = cp_lexer_peek_token(parser->lexer)->u.value;
|
||||
const char *p =
|
||||
((const char
|
||||
*)(tree_check((id),
|
||||
"/home/bonzo/develop/trunk/gcc/cp/parser.c",
|
||||
30062, __FUNCTION__,
|
||||
(IDENTIFIER_NODE)))->identifier.id.str);
|
||||
if (strcmp(p, "distribute") == 0) {
|
||||
if (!global_options.x_flag_openmp)
|
||||
return cp_parser_omp_distribute(parser,
|
||||
pragma_tok,
|
||||
p_name, mask,
|
||||
cclauses);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static bool
|
||||
cp_parser_omp_target(cp_parser * parser, cp_token * pragma_tok,
|
||||
enum pragma_context context)
|
||||
{
|
||||
if (context != pragma_stmt && context != pragma_compound) {
|
||||
tree id = cp_lexer_peek_token(parser->lexer)->u.value;
|
||||
const char *p =
|
||||
((const char
|
||||
*)(tree_check((id),
|
||||
"/home/bonzo/develop/trunk/gcc/cp/parser.c",
|
||||
30201, __FUNCTION__,
|
||||
(IDENTIFIER_NODE)))->identifier.id.str);
|
||||
if (strcmp(p, "teams") == 0) {
|
||||
tree cclauses[C_OMP_CLAUSE_SPLIT_COUNT];
|
||||
char p_name[sizeof
|
||||
("#pragma omp target teams distribute "
|
||||
"parallel for simd")];
|
||||
if (!global_options.x_flag_openmp)
|
||||
return cp_parser_omp_teams(parser, pragma_tok,
|
||||
p_name,
|
||||
((((omp_clause_mask)
|
||||
1) <<
|
||||
PRAGMA_OMP_CLAUSE_DEVICE)
|
||||
|
|
||||
(((omp_clause_mask)
|
||||
1) <<
|
||||
PRAGMA_OMP_CLAUSE_MAP)
|
||||
|
|
||||
(((omp_clause_mask)
|
||||
1) <<
|
||||
PRAGMA_OMP_CLAUSE_IF)),
|
||||
cclauses);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
cp_parser_omp_declare_reduction(cp_parser * parser, cp_token * pragma_tok,
|
||||
enum pragma_context)
|
||||
{
|
||||
tree reduc_id = (tree) __null, orig_reduc_id = (tree) __null, type;
|
||||
while (true) {
|
||||
type = cp_parser_type_id(parser);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
cp_parser_omp_declare(cp_parser * parser, cp_token * pragma_tok,
|
||||
enum pragma_context context)
|
||||
{
|
||||
if (cp_lexer_next_token_is(parser->lexer, CPP_NAME)) {
|
||||
tree id = cp_lexer_peek_token(parser->lexer)->u.value;
|
||||
const char *p =
|
||||
((const char
|
||||
*)(tree_check((id),
|
||||
"/home/bonzo/develop/trunk/gcc/cp/parser.c",
|
||||
30883, __FUNCTION__,
|
||||
(IDENTIFIER_NODE)))->identifier.id.str);
|
||||
if (strcmp(p, "simd") == 0) {
|
||||
cp_parser_omp_declare_reduction(parser, pragma_tok,
|
||||
context);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static cp_parser *the_parser;
|
||||
static bool cp_parser_pragma(cp_parser * parser, enum pragma_context context)
|
||||
{
|
||||
cp_token *pragma_tok;
|
||||
unsigned int id;
|
||||
switch (id) {
|
||||
case PRAGMA_OMP_DECLARE_REDUCTION:
|
||||
cp_parser_omp_declare(parser, pragma_tok, context);
|
||||
case PRAGMA_OMP_TARGET:
|
||||
return cp_parser_omp_target(parser, pragma_tok, context);
|
||||
}
|
||||
}
|
||||
|
||||
void c_parse_file(void)
|
||||
{
|
||||
cp_parser_translation_unit(the_parser);
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue