* c-parse.in (maybe_type_qual): Delete.
(maybe_volatile, simple_asm_expr, asmdef, asm_stmt)
(asm_argument): New grammar rules.
(extdef_1): Use asmdef.
(maybeasm): Move down with other asm rules; use simple_asm_expr.
(xexpr): Move up with other expression rules.
(stmt): Use asm_stmt.
* c-typeck.c (build_asm_expr): New function - body mostly
pulled from build_asm_stmt.
(build_asm_stmt): Just handle tacking on the volatile qualifier.
* c-tree.h (build_asm_expr, build_asm_stmt): Update prototypes.
From-SVN: r77723
+2004-02-12 Zack Weinberg <zack@codesourcery.com>
+
+ * c-parse.in (maybe_type_qual): Delete.
+ (maybe_volatile, simple_asm_expr, asmdef, asm_stmt)
+ (asm_argument): New grammar rules.
+ (extdef_1): Use asmdef.
+ (maybeasm): Move down with other asm rules; use simple_asm_expr.
+ (xexpr): Move up with other expression rules.
+ (stmt): Use asm_stmt.
+
+ * c-typeck.c (build_asm_expr): New function - body mostly
+ pulled from build_asm_stmt.
+ (build_asm_stmt): Just handle tacking on the volatile qualifier.
+ * c-tree.h (build_asm_expr, build_asm_stmt): Update prototypes.
+
2004-02-12 Richard Sandiford <rsandifo@redhat.com>
PR bootstrap/13617
2004-02-10 Matt Kraai <kraai@alumni.cmu.edu>
- * doc/install.texi: Remove extra cd.
+ * doc/install.texi: Remove extra cd.
2004-02-10 Ziemowit Laski <zlaski@apple.com>
* config/m68k/linux.h, config/m68k/m68k.c: Remove traling whitespace.
2004-02-08 Andreas Schwab <schwab@suse.de>
- Bernardo Innocenti <bernie@develer.com>
+ Bernardo Innocenti <bernie@develer.com>
* config/m68k/m68k.h (REGISTER_NAMES): Prefix each name with
REGISTER_PREFIX.
%type <ttype> typespec_reserved_nonattr typespec_reserved_attr
%type <ttype> typespec_nonreserved_nonattr
-%type <ttype> scspec SCSPEC STATIC TYPESPEC TYPE_QUAL maybe_type_qual
-%type <ttype> initdecls notype_initdecls initdcl notype_initdcl
-%type <ttype> init maybeasm
+%type <ttype> scspec SCSPEC STATIC TYPESPEC TYPE_QUAL maybe_volatile
+%type <ttype> initdecls notype_initdecls initdcl notype_initdcl init
+%type <ttype> simple_asm_expr maybeasm asmdef asm_stmt asm_argument
%type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
%type <ttype> maybe_attribute attributes attribute attribute_list attrib
%type <ttype> any_word
extdef_1:
fndef
| datadef
+ | asmdef
+ | extension extdef
+ { RESTORE_EXT_FLAGS ($1); }
@@ifobjc
| objcdef
@@end_ifobjc
- | ASM_KEYWORD '(' expr ')' ';'
- { STRIP_NOPS ($3);
- if ((TREE_CODE ($3) == ADDR_EXPR
- && TREE_CODE (TREE_OPERAND ($3, 0)) == STRING_CST)
- || TREE_CODE ($3) == STRING_CST)
- assemble_asm ($3);
- else
- error ("argument of `asm' is not a constant string"); }
- | extension extdef
- { RESTORE_EXT_FLAGS ($1); }
;
datadef:
| notype_initdecls ',' maybe_resetattrs notype_initdcl
;
-maybeasm:
- /* empty */
- { $$ = NULL_TREE; }
- | ASM_KEYWORD '(' STRING ')'
- { $$ = $3; }
- ;
-
initdcl:
declarator maybeasm maybe_attribute '='
{ $<ttype>$ = start_decl ($1, current_declspecs, 1,
{ check_for_loop_decls (); }
;
+xexpr:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | expr
+ ;
+
/* Parse a single real statement, not including any labels. */
stmt:
compstmt
| RETURN expr ';'
{ stmt_count++;
$$ = c_expand_return ($2); }
- | ASM_KEYWORD maybe_type_qual '(' expr ')' ';'
- { stmt_count++;
- $$ = simple_asm_stmt ($4); }
- /* This is the case with just output operands. */
- | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ')' ';'
- { stmt_count++;
- $$ = build_asm_stmt ($2, $4, $6, NULL_TREE, NULL_TREE); }
- /* This is the case with input operands as well. */
- | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':'
- asm_operands ')' ';'
- { stmt_count++;
- $$ = build_asm_stmt ($2, $4, $6, $8, NULL_TREE); }
- /* This is the case with clobbered registers as well. */
- | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':'
- asm_operands ':' asm_clobbers ')' ';'
- { stmt_count++;
- $$ = build_asm_stmt ($2, $4, $6, $8, $10); }
+ | asm_stmt
| GOTO identifier ';'
{ tree decl;
stmt_count++;
}
;
-/* Either a type-qualifier or nothing. First thing in an `asm' statement. */
+/* Asm expressions and statements */
-maybe_type_qual:
- /* empty */
+/* simple_asm_expr is used in restricted contexts, where a full
+ expression with inputs and outputs does not make sense. */
+simple_asm_expr:
+ ASM_KEYWORD '(' STRING ')'
+ { $$ = $3; }
+ ;
+
+/* maybeasm: used for assembly names for declarations */
+maybeasm:
+ /* empty */
{ $$ = NULL_TREE; }
- | TYPE_QUAL
- { }
+ | simple_asm_expr
;
-xexpr:
+/* asmdef: asm() outside a function body. */
+asmdef:
+ simple_asm_expr ';'
+ { assemble_asm ($1); }
+ ;
+
+/* Full-blown asm statement with inputs, outputs, clobbers, and
+ volatile tag allowed. */
+asm_stmt:
+ ASM_KEYWORD maybe_volatile '(' asm_argument ')' ';'
+ { stmt_count++;
+ $$ = build_asm_stmt ($2, $4); }
+ ;
+
+asm_argument:
+ /* no operands */
+ STRING
+ { $$ = build_asm_expr ($1, 0, 0, 0, true); }
+ /* output operands */
+ | STRING ':' asm_operands
+ { $$ = build_asm_expr ($1, $3, 0, 0, false); }
+ /* output and input operands */
+ | STRING ':' asm_operands ':' asm_operands
+ { $$ = build_asm_expr ($1, $3, $5, 0, false); }
+ /* output and input operands and clobbers */
+ | STRING ':' asm_operands ':' asm_operands ':' asm_clobbers
+ { $$ = build_asm_expr ($1, $3, $5, $7, false); }
+ ;
+
+/* Either 'volatile' or nothing. First thing in an `asm' statement. */
+
+maybe_volatile:
/* empty */
- { $$ = NULL_TREE; }
- | expr
+ { $$ = 0; }
+ | TYPE_QUAL
+ { if ($1 != ridpointers[RID_VOLATILE])
+ {
+ warning ("%E qualifier ignored on asm", $1);
+ $$ = 0;
+ }
+ else
+ $$ = $1;
+ }
;
/* These are the operands other than the first string and colon
extern void pedwarn_c99 (const char *, ...) ATTRIBUTE_PRINTF_1;
extern tree c_start_case (tree);
extern void c_finish_case (void);
-extern tree simple_asm_stmt (tree);
-extern tree build_asm_stmt (tree, tree, tree, tree, tree);
+extern tree build_asm_expr (tree, tree, tree, tree, bool);
+extern tree build_asm_stmt (tree, tree);
extern tree c_convert_parm_for_inlining (tree, tree, tree, int);
/* Set to 0 at beginning of a function definition, set to 1 if
constructor_range_stack = 0;
}
\f
-/* Build a simple asm-statement, from one string literal. */
+/* Build a complete asm-statement, whose components are a CV_QUALIFIER
+ (guaranteed to be 'volatile' or null) and ARGS (represented using
+ an ASM_STMT node). */
tree
-simple_asm_stmt (tree expr)
+build_asm_stmt (tree cv_qualifier, tree args)
{
- STRIP_NOPS (expr);
-
- if (TREE_CODE (expr) == ADDR_EXPR)
- expr = TREE_OPERAND (expr, 0);
-
- if (TREE_CODE (expr) == STRING_CST)
- {
- tree stmt;
-
- /* Simple asm statements are treated as volatile. */
- stmt = add_stmt (build_stmt (ASM_STMT, ridpointers[(int) RID_VOLATILE],
- expr, NULL_TREE, NULL_TREE, NULL_TREE));
- ASM_INPUT_P (stmt) = 1;
- return stmt;
- }
-
- error ("argument of `asm' is not a constant string");
- return NULL_TREE;
+ if (!TREE_OPERAND (args, 0))
+ TREE_OPERAND (args, 0) = cv_qualifier;
+ return add_stmt (args);
}
-/* Build an asm-statement, whose components are a CV_QUALIFIER, a
- STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */
-
+/* Build an asm-expr, whose components are a STRING, some OUTPUTS,
+ some INPUTS, and some CLOBBERS. The latter three may be NULL.
+ SIMPLE indicates whether there was anything at all after the
+ string in the asm expression -- asm("blah") and asm("blah" : )
+ are subtly different. We use a ASM_STMT node to represent this. */
tree
-build_asm_stmt (tree cv_qualifier, tree string, tree outputs, tree inputs,
- tree clobbers)
+build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
+ bool simple)
{
tree tail;
-
- if (TREE_CODE (string) != STRING_CST)
- {
- error ("asm template is not a string constant");
- return NULL_TREE;
- }
-
- if (cv_qualifier != NULL_TREE
- && cv_qualifier != ridpointers[(int) RID_VOLATILE])
- {
- warning ("%s qualifier ignored on asm",
- IDENTIFIER_POINTER (cv_qualifier));
- cv_qualifier = NULL_TREE;
- }
+ tree args;
/* We can remove output conversions that change the type,
but not the mode. */
for (tail = inputs; tail; tail = TREE_CHAIN (tail))
TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
- return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
- outputs, inputs, clobbers));
+ args = build_stmt (ASM_STMT, 0, string, outputs, inputs, clobbers);
+
+ /* Simple asm statements are treated as volatile. */
+ if (simple)
+ {
+ TREE_OPERAND (args, 0) = ridpointers[RID_VOLATILE];
+ ASM_INPUT_P (args) = 1;
+ }
+ return args;
}
/* Expand an ASM statement with operands, handling output operands
projects / platform / upstream / gcc.git / commitdiff