Viewing file:  pr57662.C (8.92 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/* { dg-do compile { target powerpc*-*-* ia64-*-* i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -fselective-scheduling2 -fsel-sched-pipelining -Wno-return-type" } */
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,
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, true,
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);
}
|
