* c-decl.c (grokdeclarator): Use ISO word.
* cppinit.c: Remove leading capital from diagnostic messages, as
per GNU coding standards.
* diagnostic.c: Similarly.
* emit-rtl.c: Similarly.
* final.c: Similarly.
* gcc.c: Similarly.
* tradcpp.c: Similarly.
* config/arm/arm.c: Similarly.
* config/arm/arm.h: Similarly.
* config/avr/avr.c: Similarly.
* config/avr/avr.h: Similarly.
* config/c4x/c4x.c: Similarly.
* config/cris/cris.c: Similarly.
* config/cris/cris.h: Similarly.
* config/d30v/d30v.c: Similarly.
* config/dsp16xx/dsp16xx.c: Similarly.
* config/dsp16xx/dsp16xx.h: Similarly.
* config/h8300/h8300.c: Similarly.
* config/i386/i386.c: Similarly.
* config/i386/xm-djgpp.h: Similarly.
* config/i960/i960.h: Similarly.
* config/m32r/m32r.c: Similarly.
* config/m68hc11/m68hc11.c: Similarly.
* config/m88k/m88k.c: Similarly.
* config/m88k/m88k.h: Similarly.
* config/mcore/mcore.c: Similarly.
* config/mcore/mcore.h: Similarly.
* config/mips/mips.c: Similarly.
* config/mmix/mmix.c: Similarly.
* config/pa/pa.c: Similarly.
* config/rs6000/rs6000.c: Similarly.
* config/rs6000/sysv4.h: Similarly.
* config/s390/s390.c: Similarly.
* config/sparc/sparc.c: Similarly.
* config/v850/v850-c.c: Similarly.
* config/v850/v850.c: Similarly.
ch:
* actions.c: Remove leading capital from diagnostic messages, as
per GNU coding standards.
* decl.c: Similarly.
* expr.c: Similarly.
* inout.c: Similarly.
* lang.c: Similarly.
* loop.c: Similarly.
* nloop.c: Similarly.
* parse.c: Similarly.
* satisfy.c: Similarly.
* tasking.c: Similarly.
* tree.c: Similarly.
* typeck.c: Similarly.
cp:
* typeck2.c: Remove leading capital from diagnostic messages, as
per GNU coding standards.
f:
* com.c: Remove leading capital from diagnostic messages, as
per GNU coding standards.
* g77spec.c: Similarly.
* lex.c: Similarly.
java:
* expr.c: Remove leading capital from diagnostic messages, as
per GNU coding standards.
* jcf-io.c: Similarly.
* jcf-parse.c: Similarly.
* jv-scan.c: Similarly.
* jvspec.c: Similarly.
* mangle.c: Similarly.
From-SVN: r47558
+2001-12-03 Neil Booth <neil@daikokuya.demon.co.uk>
+
+ * c-decl.c (grokdeclarator): Use ISO word.
+ * cppinit.c: Remove leading capital from diagnostic messages, as
+ per GNU coding standards.
+ * emit-rtl.c: Similarly.
+ * final.c: Similarly.
+ * gcc.c: Similarly.
+ * tradcpp.c: Similarly.
+ * config/arm/arm.c: Similarly.
+ * config/arm/arm.h: Similarly.
+ * config/avr/avr.c: Similarly.
+ * config/avr/avr.h: Similarly.
+ * config/c4x/c4x.c: Similarly.
+ * config/cris/cris.c: Similarly.
+ * config/cris/cris.h: Similarly.
+ * config/d30v/d30v.c: Similarly.
+ * config/dsp16xx/dsp16xx.c: Similarly.
+ * config/dsp16xx/dsp16xx.h: Similarly.
+ * config/h8300/h8300.c: Similarly.
+ * config/i386/i386.c: Similarly.
+ * config/i386/xm-djgpp.h: Similarly.
+ * config/i960/i960.h: Similarly.
+ * config/m32r/m32r.c: Similarly.
+ * config/m68hc11/m68hc11.c: Similarly.
+ * config/m88k/m88k.c: Similarly.
+ * config/m88k/m88k.h: Similarly.
+ * config/mcore/mcore.c: Similarly.
+ * config/mcore/mcore.h: Similarly.
+ * config/mips/mips.c: Similarly.
+ * config/mmix/mmix.c: Similarly.
+ * config/pa/pa.c: Similarly.
+ * config/rs6000/rs6000.c: Similarly.
+ * config/rs6000/sysv4.h: Similarly.
+ * config/s390/s390.c: Similarly.
+ * config/sparc/sparc.c: Similarly.
+ * config/v850/v850-c.c: Similarly.
+ * config/v850/v850.c: Similarly.
+
2001-12-03 Zack Weinberg <zack@codesourcery.com>
* rs6000.h (RETURN_IN_MEMORY): Cast result of
Functions aren't allowed as array elements. */
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
&& (constp || volatilep))
- pedwarn ("ANSI C forbids const or volatile function types");
+ pedwarn ("ISO C forbids const or volatile function types");
#endif
/* Build the array type itself, then merge any constancy or
basic_block bb = NOTE_BASIC_BLOCK (x);
num_bb_notes++;
if (bb->index != last_bb_num_seen + 1)
- internal_error ("basic blocks not numbered consecutively.");
+ internal_error ("basic blocks not numbered consecutively");
last_bb_num_seen = bb->index;
}
num_bb_notes, n_basic_blocks);
if (err)
- internal_error ("verify_flow_info failed.");
+ internal_error ("verify_flow_info failed");
/* Clean up. */
free (bb_info);
+2001-12-03 Neil Booth <neil@daikokuya.demon.co.uk>
+
+ * actions.c: Remove leading capital from diagnostic messages, as
+ per GNU coding standards.
+ * decl.c: Similarly.
+ * expr.c: Similarly.
+ * inout.c: Similarly.
+ * lang.c: Similarly.
+ * loop.c: Similarly.
+ * nloop.c: Similarly.
+ * parse.c: Similarly.
+ * satisfy.c: Similarly.
+ * tasking.c: Similarly.
+ * tree.c: Similarly.
+ * typeck.c: Similarly.
+
2001-11-29 Joseph S. Myers <jsm28@cam.ac.uk>
* Make-lang.in (CHILL.generated-manpages): New dummy target.
tree high = TREE_OPERAND (label, 1);
if (TREE_CODE (low) != INTEGER_CST)
{
- error ("Lower bound of range must be a discrete literal expression");
+ error ("lower bound of range must be a discrete literal expression");
expr = error_mark_node;
}
if (TREE_CODE (high) != INTEGER_CST)
{
- error ("Upper bound of range must be a discrete literal expression");
+ error ("upper bound of range must be a discrete literal expression");
expr = error_mark_node;
}
if (expr != error_mark_node)
}
else
{
- error ("The CASE label is not valid");
+ error ("CASE label is not valid");
expr = error_mark_node;
}
}
if (labels != NULL_TREE || selector != NULL_TREE)
- error ("The number of CASE selectors does not match the number of CASE label lists");
+ error ("number of CASE selectors does not match the number of CASE label lists");
return larg;
}
tree type = TREE_TYPE (decl);
if (CH_IS_BUFFER_MODE (type) || CH_IS_EVENT_MODE (type))
{
- error ("You may not assign a value to a BUFFER or EVENT location");
+ error ("you may not assign a value to a BUFFER or EVENT location");
return;
}
}
if (! CH_LOCATION_P (lhs))
{
- error ("Can only set LENGTH of array location");
+ error ("can only set LENGTH of array location");
return;
}
}
if (!found)
{
- error_with_decl (alias, "Nothing named `%s' to grant.");
+ error_with_decl (alias, "nothing named `%s' to grant");
DECL_ABSTRACT_ORIGIN (alias) = error_mark_node;
}
}
if (!unnamed_value_warned)
{
unnamed_value_warned = 1;
- warning ("undefined value in SET mode is obsolete and deprecated.");
+ warning ("undefined value in SET mode is obsolete and deprecated");
}
sprintf (buf, "__star_%d", next_dummy_enum_value++);
name = get_identifier (buf);
{
int length = list_length (args);
if (length < min_length)
- error ("Too few arguments in call to `%s'", IDENTIFIER_POINTER (name));
+ error ("too few arguments in call to `%s'", IDENTIFIER_POINTER (name));
else if (max_length != -1 && length > max_length)
- error ("Too many arguments in call to `%s'", IDENTIFIER_POINTER (name));
+ error ("too many arguments in call to `%s'", IDENTIFIER_POINTER (name));
else
return length;
return -1;
/* check for ptr is really a POINTER */
if (TREE_CODE (type) != POINTER_TYPE)
{
- error ("cannot dereference, not a pointer.");
+ error ("cannot dereference, not a pointer");
return error_mark_node;
}
if (decl == NULL_TREE || TREE_CODE (decl) != TYPE_DECL)
{
if (pass == 2)
- error ("missing '.' operator or undefined mode name `%s'.",
+ error ("missing '.' operator or undefined mode name `%s'",
IDENTIFIER_POINTER (mode));
#if 0
- error ("You have forgotten the '.' operator which must");
+ error ("you have forgotten the '.' operator which must");
error (" precede a STRUCT field reference, or `%s' is an undefined mode",
IDENTIFIER_POINTER (mode));
#endif
}
else if (type == ptr_type_node)
{
- error ("Can't dereference PTR value using unary `->'.");
+ error ("can't dereference PTR value using unary `->'");
return error_mark_node;
}
}
}
- error ("No field named `%s'", IDENTIFIER_POINTER (field_name));
+ error ("no field named `%s'", IDENTIFIER_POINTER (field_name));
return error_mark_node;
}
had_errors = 1;
else if (TREE_CODE (TREE_TYPE (exp)) != INTEGER_TYPE)
{
- error ("argument %d to ABSTIME must be of integer type.", i);
+ error ("argument %d to ABSTIME must be of integer type", i);
had_errors = 1;
}
tmp = TREE_CHAIN (tmp);
/* check for ptr is referable */
if (! CH_REFERABLE (ptr))
{
- error ("parameter 1 must be referable.");
+ error ("parameter 1 must be referable");
err++;
}
/* check for pointer */
else if (TREE_CODE (TREE_TYPE (ptr)) != POINTER_TYPE)
{
- error ("mode mismatch in parameter 1.");
+ error ("mode mismatch in parameter 1");
err++;
}
/* check for size > 0 if it is a constant */
if (TREE_CODE (size) == INTEGER_CST && TREE_INT_CST_LOW (size) <= 0)
{
- error ("parameter 2 must be a positive integer.");
+ error ("parameter 2 must be a positive integer");
err++;
}
if (err)
/* check for ptr is referable */
if (! CH_REFERABLE (ptr))
{
- error ("parameter 1 must be referable.");
+ error ("parameter 1 must be referable");
err++;
}
/* check for pointer */
else if (TREE_CODE (TREE_TYPE (ptr)) != POINTER_TYPE)
{
- error ("mode mismatch in parameter 1.");
+ error ("mode mismatch in parameter 1");
err++;
}
/* check for size > 0 if it is a constant */
if (TREE_CODE (size) == INTEGER_CST && TREE_INT_CST_LOW (size) <= 0)
{
- error ("parameter 2 must be a positive integer.");
+ error ("parameter 2 must be a positive integer");
err++;
}
if (err)
/* check for pointer */
if (TREE_CODE (TREE_TYPE (ptr)) != POINTER_TYPE)
{
- error ("mode mismatch in parameter 1.");
+ error ("mode mismatch in parameter 1");
return error_mark_node;
}
/* check for expression is referable */
if (! CH_REFERABLE (expr))
{
- error ("expression for DESCR-builtin must be referable.");
+ error ("expression for DESCR-builtin must be referable");
return error_mark_node;
}
if (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
{
- error ("argument to `%s' must be of integer type.", IDENTIFIER_POINTER (fnname));
+ error ("argument to `%s' must be of integer type", IDENTIFIER_POINTER (fnname));
return error_mark_node;
}
/* check if we have a mode */
if (TREE_CODE_CLASS (TREE_CODE (type)) != 't')
{
- error ("First argument to `%s' must be a mode", chill_name);
+ error ("first argument to `%s' must be a mode", chill_name);
return error_mark_node;
}
/* check first argument to be NEWMODE TIME */
if (TREE_TYPE (t) != abs_timing_type_node)
{
- error ("argument 1 to INTTIME must be of mode TIME.");
+ error ("argument 1 to INTTIME must be of mode TIME");
had_errors = 1;
}
}
/* FIXME: what's about ranges can't hold the result ?? */
if (write_error)
- error ("%s.", errmsg);
+ error ("%s", errmsg);
}
/* next location */
tmp = TREE_CHAIN (tmp);
need_unsigned);
if (temp == NULL_TREE)
{
- error ("No integer mode which matches expression's mode");
+ error ("no integer mode which matches expression's mode");
return integer_zero_node;
}
temp = convert (temp, expr);
if (TREE_CODE (TREE_TYPE (expr)) == ENUMERAL_TYPE
&& CH_ENUM_IS_NUMBERED (TREE_TYPE (expr)))
{
- error ("Cannot take SUCC or PRED of a numbered SET");
+ error ("cannot take SUCC or PRED of a numbered SET");
return error_mark_node;
}
{
if (TREE_TYPE (TREE_TYPE (expr)) == void_type_node)
{
- error ("SUCC or PRED must not be done on a PTR.");
+ error ("SUCC or PRED must not be done on a PTR");
return error_mark_node;
}
- pedwarn ("SUCC or PRED for a reference type is not standard.");
+ pedwarn ("SUCC or PRED for a reference type is not standard");
return fold (build (op, TREE_TYPE (expr),
expr,
size_in_bytes (TREE_TYPE (TREE_TYPE (expr)))));
if (TREE_CODE (cond) == INTEGER_CST
&& tree_int_cst_equal (cond, integer_one_node))
{
- error ("Taking the %s of a value already at its %s value",
+ error ("taking the %s of a value already at its %s value",
op == PLUS_EXPR ? "SUCC" : "PRED",
op == PLUS_EXPR ? "maximum" : "minimum");
return error_mark_node;
case NE_EXPR:
return invert_truthvalue (build_compare_string_expr (EQ_EXPR, op0, op1));
default:
- error ("Invalid operation on array of chars");
+ error ("invalid operation on array of chars");
return error_mark_node;
}
op1 = convert (build_pointer_type (TREE_TYPE (op1)), op1);
if ((op0f || op1f)
&& code != EQ_EXPR && code != NE_EXPR)
- error ("Cannot use %s operator on PROC mode variable",
+ error ("cannot use %s operator on PROC mode variable",
tree_code_name[(int)code]);
}
}
/* this nerver should happen */
- error_with_decl (decl, "function \"really_grant_this\" called for `%s'.");
+ error_with_decl (decl, "function \"really_grant_this\" called for `%s'");
return 1;
}
\f
attr = TREE_VALUE (TREE_CHAIN (list));
break;
default:
- error ("Too many arguments in call to MODIFY");
+ error ("too many arguments in call to MODIFY");
had_errors = 1;
break;
}
/* we must have an index */
if (!len)
{
- error ("Too few arguments in call to `readrecord'");
+ error ("too few arguments in call to `readrecord'");
return error_mark_node;
}
index = TREE_VALUE (optionals);
len = list_length (optionals);
if (indexmode != void_type_node && len != 2)
{
- error ("Too few arguments in call to `writerecord'");
+ error ("too few arguments in call to `writerecord'");
return error_mark_node;
}
if (indexmode != void_type_node)
enumname = "__IO_LongRangeLoc";
break;
default:
- error ("Cannot process %d bits integer for READTEXT argument %d.",
+ error ("cannot process %d bits integer for READTEXT argument %d",
type_size, idxcnt + 1 + argoffset);
continue;
}
enumname = "__IO_LongLoc";
break;
default:
- error ("Cannot process %d bits integer for READTEXT argument %d.",
+ error ("cannot process %d bits integer for READTEXT argument %d",
type_size, idxcnt + 1 + argoffset);
continue;
}
goto try_long;
}
}
- error ("Cannot process %d bits integer WRITETEXT argument %d.",
+ error ("cannot process %d bits integer WRITETEXT argument %d",
type_size, idxcnt + 1 + argoffset);
continue;
}
else
{
/* datatype is not yet implemented, issue a warning */
- error ("cannot process mode of argument %d for %sTEXT.", idxcnt + 1 + argoffset,
+ error ("cannot process mode of argument %d for %sTEXT", idxcnt + 1 + argoffset,
do_read ? "READ" : "WRITE");
enumname = "__IO_UNUSED";
}
}
if (exprlist == NULL_TREE)
{
- error ("Too few arguments in call to `writetext'");
+ error ("too few arguments in call to `writetext'");
return error_mark_node;
}
format_str = TREE_VALUE (exprlist);
}
if (exprlist == NULL_TREE)
{
- error ("Too few arguments in call to `readtext'");
+ error ("too few arguments in call to `readtext'");
return error_mark_node;
}
format_str = TREE_VALUE (exprlist);
explicit_ignore_case = 1;
if (special_UC)
{
- error ("Ignoring case upon input and");
- error ("making special words uppercase wouldn't work.");
+ error ("ignoring case upon input and");
+ error ("making special words uppercase wouldn't work");
}
else
ignore_case = 1;
{
if (explicit_ignore_case)
{
- error ("Making special words uppercase and");
- error (" ignoring case upon input wouldn't work.");
+ error ("making special words uppercase and");
+ error (" ignoring case upon input wouldn't work");
}
else
special_UC = 1, ignore_case = 0;
ip->itype = DO_LOC_VARYING;
else
{
- error ("Loop's IN expression is not a composite object");
+ error ("loop's IN expression is not a composite object");
return;
}
}
if (TREE_CODE (TREE_TYPE (array_type)) == BOOLEAN_TYPE)
{
- error ("Can't iterate through array of BOOL");
+ error ("can't iterate through array of BOOL");
firstp->error_flag = 1;
return firstp->error_flag;
}
ip->itype = DO_LOC_VARYING;
else
{
- error ("Loop's IN expression is not a composite object");
+ error ("loop's IN expression is not a composite object");
return;
}
}
if (TREE_CODE (TREE_TYPE (array_type)) == BOOLEAN_TYPE)
{
- error ("Can't iterate through array of BOOL");
+ error ("can't iterate through array of BOOL");
ip->error_flag = 1;
return ip->error_flag;
}
if (result_never_set
&& TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl)))
!= VOID_TYPE)
- warning ("No RETURN or RESULT in procedure");
+ warning ("no RETURN or RESULT in procedure");
chill_expand_return (NULL_TREE, 1);
}
}
{
push_handler ();
parse_opt_actions ();
- expect (OD, "Missing 'OD' after 'DO'");
+ expect (OD, "missing 'OD' after 'DO'");
parse_opt_handler ();
parse_opt_end_label_semi_colon (label);
return;
parse_opt_actions ();
if (! ignoring)
build_loop_end ();
- expect (OD, "Missing 'OD' after 'DO'");
+ expect (OD, "missing 'OD' after 'DO'");
/* Note that the handler is inside the reach of the DO. */
parse_opt_handler ();
end_loop_scope (label);
no_handler_action:
if (parse_opt_handler () != NULL_TREE && pass == 1)
- error ("no handler is permitted on this action.");
+ error ("no handler is permitted on this action");
parse_semi_colon ();
return 1;
#if YYDEBUG != 0
yydebug = value;
#else
- warning ("YYDEBUG not defined.");
+ warning ("YYDEBUG not defined");
#endif
}
#endif
{
if (!pointer_type_breaks_cycle)
{
- error_with_decl (decl, "Cycle: `%s' depends on ...");
+ error_with_decl (decl, "cycle: `%s' depends on ...");
cycle_error_print (prev_chain, decl);
error_with_decl (decl, " `%s'");
return error_mark_node;
/* check for value should be assigned is out of range */
if (TREE_INT_CST_LOW (*tasking_code_ptr) >
TREE_INT_CST_LOW (TYPE_MAX_VALUE (chill_taskingcode_type_node)))
- error ("Tasking code %ld out of range for `%s'.",
+ error ("tasking code %ld out of range for `%s'",
(long) TREE_INT_CST_LOW (*tasking_code_ptr),
IDENTIFIER_POINTER (name));
}
/* check for value should be assigned is out of range */
if (TREE_INT_CST_LOW (*tasking_code_ptr) >
TREE_INT_CST_LOW (TYPE_MAX_VALUE (chill_taskingcode_type_node)))
- error ("Tasking code %ld out of range for `%s'.",
+ error ("tasking code %ld out of range for `%s'",
(long) TREE_INT_CST_LOW (*tasking_code_ptr),
IDENTIFIER_POINTER (name));
}
{
for (field = parnamelist; field != NULL_TREE;
field = TREE_CHAIN (field))
- error ("invalid attribute for argument `%s' (only IN or LOC allowed).",
+ error ("invalid attribute for argument `%s' (only IN or LOC allowed)",
IDENTIFIER_POINTER (TREE_VALUE (field)));
}
}
else if (TREE_CODE (process_decl) != FUNCTION_DECL
|| ! CH_DECL_PROCESS (process_decl))
{
- error ("You may only START a process, not a proc");
+ error ("you may only START a process, not a proc");
process_decl = NULL_TREE;
}
else if (DECL_EXTERNAL (process_decl))
if (optset == NULL_TREE) ;
else if (!CH_REFERABLE (optset))
{
- error ("SET expression not a location.");
+ error ("SET expression not a location");
optset = NULL_TREE;
}
else if (!CH_IS_INSTANCE_MODE (TREE_TYPE (optset)))
result = (tree)(DECL_TASKING_CODE_DECL (decl));
else
{
- error ("GEN_CODE argument must be a process or signal name.");
+ error ("GEN_CODE argument must be a process or signal name");
return error_mark_node;
}
CH_DERIVED_FLAG (result) = 1;
tree_cons (NULL_TREE, arg2, NULL_TREE)));
}
- error ("QUEUE_LENGTH argument must be a BUFFER/EVENT location.");
+ error ("QUEUE_LENGTH argument must be a BUFFER/EVENT location");
return error_mark_node;
}
\f
/* issue a warning in case of -Wall */
if (extra_warnings)
{
- warning ("Signal sent without priority");
+ warning ("signal sent without priority");
warning (" and no default priority was set.");
warning (" PRIORITY defaulted to 0");
}
tree_cons (NULL_TREE, copy_number, NULL_TREE)));
/* as our system doesn't allow that and Z.200 specifies it,
we issue a warning */
- warning ("SEND to ANY copy of process `%s'.", IDENTIFIER_POINTER (process_name));
+ warning ("SEND to ANY copy of process `%s'", IDENTIFIER_POINTER (process_name));
}
}
else if (! CH_IS_INSTANCE_MODE (TREE_TYPE (optsendto)))
{
if (!current_rc_state)
{
- error ("internal error: RECEIVE CASE stack invalid.");
+ error ("internal error: RECEIVE CASE stack invalid");
abort ();
}
return current_rc_state->if_generated;
if (! CH_REFERABLE (buffer))
{
- error ("BUFFER in RECEIVE CASE alternative must be a location.");
+ error ("BUFFER in RECEIVE CASE alternative must be a location");
return error_mark_node;
}
if (TREE_CHAIN (loclist) != NULL_TREE)
{
- error ("buffer receive alternative requires only 1 defining occurrence.");
+ error ("buffer receive alternative requires only 1 defining occurrence");
return error_mark_node;
}
had_errors = 1;
else if (! CH_COMPATIBLE (var, buftype))
{
- error ("incompatible modes in receive buffer alternative.");
+ error ("incompatible modes in receive buffer alternative");
had_errors = 1;
}
if (! CH_LOCATION_P (var))
{
- error ("defining occurrence in receive buffer alternative must be a location.");
+ error ("defining occurrence in receive buffer alternative must be a location");
had_errors = 1;
}
{
if (loclist == NULL_TREE)
{
- error ("buffer receive alternative without `IN location'.");
+ error ("buffer receive alternative without `IN location'");
return error_mark_node;
}
return build_receive_buffer_case_label (signame, loclist);
}
- error ("RECEIVE CASE alternative must specify a SIGNAL name or BUFFER location.");
+ error ("RECEIVE CASE alternative must specify a SIGNAL name or BUFFER location");
return error_mark_node;
}
\f
if (! CH_REFERABLE (evloc) || ! CH_IS_EVENT_MODE (TREE_TYPE (evloc)))
{
- error ("CONTINUE requires an event location.");
+ error ("CONTINUE requires an event location");
return;
}
optpriority = integer_zero_node;
else if (TREE_CODE (TREE_TYPE (optpriority)) != INTEGER_TYPE)
{
- error ("PRIORITY must be of integer type.");
+ error ("PRIORITY must be of integer type");
optpriority = integer_zero_node;
}
temp1 = null_pointer_node;
else if (! CH_IS_EVENT_MODE (TREE_TYPE (event)) || ! CH_REFERABLE (event))
{
- error ("delay alternative must be an EVENT location.");
+ error ("delay alternative must be an EVENT location");
temp1 = null_pointer_node;
}
else
had_errors = 1;
else if (! CH_IS_EVENT_MODE (TREE_TYPE (event)) || ! CH_REFERABLE (event))
{
- error ("DELAY action requires an event location.");
+ error ("DELAY action requires an event location");
had_errors = 1;
}
return;
if (TREE_CODE (TREE_TYPE (optpriority)) != INTEGER_TYPE)
{
- error ("PRIORITY in DELAY action must be of integer type.");
+ error ("PRIORITY in DELAY action must be of integer type");
return;
}
}
if (extra_warnings)
{
warning ("DELAY action without priority.");
- warning (" PRIORITY defaulted to 0.");
+ warning (" PRIORITY defaulted to 0");
}
optpriority = integer_zero_node;
}
{
if (! CH_IS_BUFFER_MODE (TREE_TYPE (buffer)) || ! CH_REFERABLE (buffer))
{
- error ("send buffer action requires a BUFFER location.");
+ error ("send buffer action requires a BUFFER location");
had_errors = 1;
}
else
{
if (TREE_CHAIN (value) != NULL_TREE)
{
- error ("there must be only 1 value for send buffer action.");
+ error ("there must be only 1 value for send buffer action");
had_errors = 1;
}
else
value = convert (TREE_TYPE (buffer_mode_decl), value);
if (value == NULL_TREE || TREE_CODE (value) == ERROR_MARK)
{
- error ("convert failed for send buffer action.");
+ error ("convert failed for send buffer action");
had_errors = 1;
}
}
else
{
- error ("incompatible modes in send buffer action.");
+ error ("incompatible modes in send buffer action");
had_errors = 1;
}
}
/* issue a warning in case of -Wall */
if (extra_warnings)
{
- warning ("Buffer sent without priority");
+ warning ("buffer sent without priority");
warning (" and no default priority was set.");
- warning (" PRIORITY defaulted to 0.");
+ warning (" PRIORITY defaulted to 0");
}
optpriority = integer_zero_node;
}
had_errors = 1;
else if (TREE_CODE (TREE_TYPE (optpriority)) != INTEGER_TYPE)
{
- error ("PRIORITY must be of integer type.");
+ error ("PRIORITY must be of integer type");
had_errors = 1;
}
if (optwith != NULL_TREE)
{
- error ("WITH not allowed for send buffer action.");
+ error ("WITH not allowed for send buffer action");
had_errors = 1;
}
if (optto != NULL_TREE)
{
- error ("TO not allowed for send buffer action.");
+ error ("TO not allowed for send buffer action");
had_errors = 1;
}
if (had_errors)
if (TREE_TYPE (abstime) != abs_timing_type_node)
{
- error ("absolute time value must be of mode TIME.");
+ error ("absolute time value must be of mode TIME");
abstime = convert (abs_timing_type_node, build_int_2 (0, 0));
}
filename = force_addr_of (get_chill_filename ());
if (TREE_TYPE (duration_value) != duration_timing_type_node)
{
- error ("duration primitive value must be of mode DURATION.");
+ error ("duration primitive value must be of mode DURATION");
duration_value = convert (duration_timing_type_node, build_int_2 (0,0));
}
TREE_PURPOSE (TREE_PURPOSE (toid)) = duration_value;
if (TREE_TYPE (duration) != duration_timing_type_node)
{
- error ("duration primitive value must be of mode DURATION.");
+ error ("duration primitive value must be of mode DURATION");
duration = convert (duration_timing_type_node, build_int_2 (0,0));
}
TREE_PURPOSE (value) = decl_temp1 (get_identifier ("AFTER_duration"),
if (! discrete_type_p (domain))
{
- error ("Can only build a powerset from a discrete mode");
+ error ("can only build a powerset from a discrete mode");
return error_mark_node;
}
if (TREE_VALUE (temp) != NULL_TREE)
{
if (! host_integerp (TREE_VALUE (temp), 0))
- error ("Stepsize in STEP must be an integer constant");
+ error ("stepsize in STEP must be an integer constant");
else
{
if (tree_int_cst_sgn (TREE_VALUE (temp)) <= 0)
- error ("Stepsize in STEP must be > 0");
+ error ("stepsize in STEP must be > 0");
else
stepsize_specified = 1;
stepsize = tree_low_cst (TREE_VALUE (temp), 1);
if (stepsize != natural_length)
- sorry ("Stepsize in STEP must be the natural width of the array element mode");
+ sorry ("stepsize in STEP must be the natural width of the array element mode");
}
}
temp = TREE_PURPOSE (temp);
if (! host_integerp (TREE_PURPOSE (temp), 0))
- error ("Starting word in POS must be an integer constant");
+ error ("starting word in POS must be an integer constant");
else
{
if (tree_int_cst_sgn (TREE_PURPOSE (temp)) < 0)
- error ("Starting word in POS must be >= 0");
+ error ("starting word in POS must be >= 0");
if (! integer_zerop (TREE_PURPOSE (temp)))
- sorry ("Starting word in POS within STEP must be 0");
+ sorry ("starting word in POS within STEP must be 0");
word = tree_low_cst (TREE_PURPOSE (temp), 0);
}
int wordsize = TYPE_PRECISION (chill_integer_type_node);
if (! host_integerp (TREE_PURPOSE (temp), 0))
{
- error ("Starting bit in POS must be an integer constant");
+ error ("starting bit in POS must be an integer constant");
start_bit_error = 1;
}
else
{
if (! integer_zerop (TREE_PURPOSE (temp)))
- sorry ("Starting bit in POS within STEP must be 0");
+ sorry ("starting bit in POS within STEP must be 0");
if (tree_int_cst_sgn (TREE_PURPOSE (temp)) < 0)
{
- error ("Starting bit in POS must be >= 0");
+ error ("starting bit in POS must be >= 0");
start_bit = 0;
start_bit_error = 1;
}
start_bit = tree_low_cst (TREE_PURPOSE (temp), 0);
if (start_bit >= wordsize)
{
- error ("Starting bit in POS must be < the width of a word");
+ error ("starting bit in POS must be < the width of a word");
start_bit = 0;
start_bit_error = 1;
}
{
if (! host_integerp (TREE_VALUE (temp), 0))
{
- error ("Length in POS must be an integer constant");
+ error ("length in POS must be an integer constant");
length_error = 1;
}
else
{
length = tree_low_cst (TREE_VALUE (temp), 0);
if (length <= 0)
- error ("Length in POS must be > 0");
+ error ("length in POS must be > 0");
}
}
else
{
if (! host_integerp (TREE_VALUE (temp), 0))
{
- error ("End bit in POS must be an integer constant");
+ error ("end bit in POS must be an integer constant");
length_error = 1;
}
else
if (end_bit < start_bit)
{
- error ("End bit in POS must be >= the start bit");
+ error ("end bit in POS must be >= the start bit");
end_bit = wordsize - 1;
length_error = 1;
}
else if (end_bit >= wordsize)
{
- error ("End bit in POS must be < the width of a word");
+ error ("end bit in POS must be < the width of a word");
end_bit = wordsize - 1;
length_error = 1;
}
}
if (! length_error && length != natural_length)
- sorry ("The length specified on POS within STEP must be the natural length of the array element type");
+ sorry ("the length specified on POS within STEP must be the natural length of the array element type");
}
}
if (! length_error && stepsize_specified && stepsize < length)
- error ("Step size in STEP must be >= the length in POS");
+ error ("step size in STEP must be >= the length in POS");
if (length == 1)
TYPE_PACKED (array_type) = 1;
if (! host_integerp (TREE_PURPOSE (temp), 0))
{
- error ("Starting word in POS must be an integer constant");
+ error ("starting word in POS must be an integer constant");
pos_error = 1;
}
else
{
if (tree_int_cst_sgn (TREE_PURPOSE (temp)) < 0)
{
- error ("Starting word in POS must be >= 0");
+ error ("starting word in POS must be >= 0");
word = 0;
pos_error = 1;
}
{
if (! host_integerp (TREE_PURPOSE (temp), 0))
{
- error ("Starting bit in POS must be an integer constant");
+ error ("starting bit in POS must be an integer constant");
start_bit = *next_struct_offset - offset;
pos_error = 1;
}
{
if (tree_int_cst_sgn (TREE_PURPOSE (temp)) < 0)
{
- error ("Starting bit in POS must be >= 0");
+ error ("starting bit in POS must be >= 0");
start_bit = *next_struct_offset - offset;
pos_error = 1;
}
start_bit = tree_low_cst (TREE_PURPOSE (temp), 0);
if (start_bit >= wordsize)
{
- error ("Starting bit in POS must be < the width of a word");
+ error ("starting bit in POS must be < the width of a word");
start_bit = *next_struct_offset - offset;
pos_error = 1;
}
{
if (! host_integerp (TREE_VALUE (temp), 0))
{
- error ("Length in POS must be an integer constant");
+ error ("length in POS must be an integer constant");
pos_error = 1;
}
else
{
if (tree_int_cst_sgn (TREE_VALUE (temp)) < 0)
{
- error ("Length in POS must be > 0");
+ error ("length in POS must be > 0");
length = natural_length;
pos_error = 1;
}
{
if (! host_integerp (TREE_VALUE (temp), 0))
{
- error ("End bit in POS must be an integer constant");
+ error ("end bit in POS must be an integer constant");
pos_error = 1;
}
else
if (end_bit < start_bit)
{
- error ("End bit in POS must be >= the start bit");
+ error ("end bit in POS must be >= the start bit");
pos_error = 1;
}
else if (end_bit >= wordsize)
{
- error ("End bit in POS must be < the width of a word");
+ error ("end bit in POS must be < the width of a word");
pos_error = 1;
}
else
if (length != natural_length && ! pos_error)
{
- sorry ("The length specified on POS must be the natural length of the field type");
+ sorry ("the length specified on POS must be the natural length of the field type");
length = natural_length;
}
}
}
if (pos_error)
- error ("If one field has a POS layout, then all fields must have a POS layout");
+ error ("if one field has a POS layout, then all fields must have a POS layout");
/* Now DECL_INITIAL is null on all fields. */
if (TARGET_THUMB && !(insn_flags & FL_THUMB))
{
- warning ("target CPU does not support THUMB instructions.");
+ warning ("target CPU does not support THUMB instructions");
target_flags &= ~ARM_FLAG_THUMB;
}
if (TARGET_APCS_FRAME && TARGET_THUMB)
{
- /* warning ("ignoring -mapcs-frame because -mthumb was used."); */
+ /* warning ("ignoring -mapcs-frame because -mthumb was used"); */
target_flags &= ~ARM_FLAG_APCS_FRAME;
}
from here where no function is being compiled currently. */
if ((target_flags & (THUMB_FLAG_LEAF_BACKTRACE | THUMB_FLAG_BACKTRACE))
&& TARGET_ARM)
- warning ("enabling backtrace support is only meaningful when compiling for the Thumb.");
+ warning ("enabling backtrace support is only meaningful when compiling for the Thumb");
if (TARGET_ARM && TARGET_CALLEE_INTERWORKING)
- warning ("enabling callee interworking support is only meaningful when compiling for the Thumb.");
+ warning ("enabling callee interworking support is only meaningful when compiling for the Thumb");
if (TARGET_ARM && TARGET_CALLER_INTERWORKING)
- warning ("enabling caller interworking support is only meaningful when compiling for the Thumb.");
+ warning ("enabling caller interworking support is only meaningful when compiling for the Thumb");
/* If interworking is enabled then APCS-32 must be selected as well. */
if (TARGET_INTERWORK)
arm_pic_register = 10;
if (TARGET_APCS_FLOAT)
- warning ("Passing floating point arguments in fp regs not yet supported");
+ warning ("passing floating point arguments in fp regs not yet supported");
/* Initialise boolean versions of the flags, for use in the arm.md file. */
arm_fast_multiply = (insn_flags & FL_FAST_MULT) != 0;
else if (streq (target_fp_name, "3"))
arm_fpu_arch = FP_SOFT3;
else
- error ("Invalid floating point emulation option: -mfpe-%s",
+ error ("invalid floating point emulation option: -mfpe-%s",
target_fp_name);
}
else
if (size == 8 || size == 32)
arm_structure_size_boundary = size;
else
- warning ("Structure size boundary can only be set to 8 or 32");
+ warning ("structure size boundary can only be set to 8 or 32");
}
if (arm_pic_register_string != NULL)
|| pic_register == HARD_FRAME_POINTER_REGNUM
|| pic_register == STACK_POINTER_REGNUM
|| pic_register >= PC_REGNUM)
- error ("Unable to use '%s' for PIC register", arm_pic_register_string);
+ error ("unable to use '%s' for PIC register", arm_pic_register_string);
else
arm_pic_register = pic_register;
}
if (value == 0)
{
debug_rtx (addr);
- warning ("Unable to compute real location of stacked parameter");
+ warning ("unable to compute real location of stacked parameter");
value = 8; /* XXX magic hack */
}
if (IS_INTERRUPT (func_type))
{
- error ("Interrupt Service Routines cannot be coded in Thumb mode.");
+ error ("interrupt Service Routines cannot be coded in Thumb mode");
return;
}
#define CPP_INTERWORK_SPEC " \
%{mthumb-interwork: \
- %{mno-thumb-interwork: %eIncompatible interworking options} \
+ %{mno-thumb-interwork: %eincompatible interworking options} \
-D__THUMB_INTERWORK__} \
%{!mthumb-interwork:%{!mno-thumb-interwork:%(cpp_interwork_default)}} \
"
if (!t->name)
{
- fprintf (stderr, "Unknown MCU `%s' specified\nKnown MCU names:\n",
+ fprintf (stderr, "unknown MCU `%s' specified\nKnown MCU names:\n",
avr_mcu_name);
for (t = avr_mcu_types; t->name; t++)
fprintf (stderr," %s\n", t->name);
else if (code == 'o')
{
if (GET_CODE (addr) != PLUS)
- fatal_insn ("Bad address, not (reg+disp):", addr);
+ fatal_insn ("bad address, not (reg+disp):", addr);
print_operand (file, XEXP (addr, 1), 0);
}
{
print_operand_address (file, XEXP (addr,0));
if (REGNO (XEXP (addr, 0)) == REG_X)
- fatal_insn ("Internal compiler bug.\nBad address:"
+ fatal_insn ("internal compiler error. Bad address:"
,addr);
fputc ('+', file);
print_operand (file, XEXP (addr,1), code);
long val;
REAL_VALUE_TYPE rv;
if (GET_MODE (x) != SFmode)
- fatal_insn ("Internal compiler bug. Unknown mode:", x);
+ fatal_insn ("internal compiler error. Unknown mode:", x);
REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
REAL_VALUE_TO_TARGET_SINGLE (rv, val);
asm_fprintf (file, "0x%lx", val);
operands[1] = src;
return "";
}
- fatal_insn ("Invalid insn:", insn);
+ fatal_insn ("invalid insn:", insn);
return "";
}
{
int disp = INTVAL (XEXP (x,1));
if (REGNO (XEXP (x,0)) != REG_Y)
- fatal_insn ("Incorrect insn:",insn);
+ fatal_insn ("incorrect insn:",insn);
if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (src)))
return *l = 3, (AS2 (adiw,r28,%o1-63) CR_TAB
if (disp > MAX_LD_OFFSET (GET_MODE (src)))
{
if (REGNO (XEXP (base, 0)) != REG_Y)
- fatal_insn ("Incorrect insn:",insn);
+ fatal_insn ("incorrect insn:",insn);
if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (src)))
return *l = 4, (AS2 (adiw,r28,%o1-62) CR_TAB
else if (GET_CODE (base) == PRE_DEC) /* (--R) */
{
if (reg_overlap_mentioned_p (dest, XEXP (base, 0)))
- fatal_insn ("Incorrect insn:", insn);
+ fatal_insn ("incorrect insn:", insn);
*l = 2;
return (AS2 (ld,%B0,%1) CR_TAB
else if (GET_CODE (base) == POST_INC) /* (R++) */
{
if (reg_overlap_mentioned_p (dest, XEXP (base, 0)))
- fatal_insn ("Incorrect insn:", insn);
+ fatal_insn ("incorrect insn:", insn);
*l = 2;
return (AS2 (ld,%A0,%1) CR_TAB
AS2 (lds,%B0,%B1));
}
- fatal_insn ("Unknown move insn:",insn);
+ fatal_insn ("unknown move insn:",insn);
return "";
}
if (disp > MAX_LD_OFFSET (GET_MODE (src)))
{
if (REGNO (XEXP (base, 0)) != REG_Y)
- fatal_insn ("Incorrect insn:",insn);
+ fatal_insn ("incorrect insn:",insn);
if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (src)))
return *l = 6, (AS2 (adiw,r28,%o1-60) CR_TAB
AS2 (lds,%C0,%C1) CR_TAB
AS2 (lds,%D0,%D1));
- fatal_insn ("Unknown move insn:",insn);
+ fatal_insn ("unknown move insn:",insn);
return "";
}
if (disp > MAX_LD_OFFSET (GET_MODE (dest)))
{
if (reg_base != REG_Y)
- fatal_insn ("Incorrect insn:",insn);
+ fatal_insn ("incorrect insn:",insn);
if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (dest)))
return *l = 6, (AS2 (adiw,r28,%o0-60) CR_TAB
AS2 (st,%0,%B1) CR_TAB
AS2 (st,%0,%C1) CR_TAB
AS2 (st,%0,%D1));
- fatal_insn ("Unknown move insn:",insn);
+ fatal_insn ("unknown move insn:",insn);
return "";
}
operands[1] = src;
return "";
}
- fatal_insn ("Invalid insn:", insn);
+ fatal_insn ("invalid insn:", insn);
return "";
}
{
int disp = INTVAL (XEXP (x,1));
if (REGNO (XEXP (x,0)) != REG_Y)
- fatal_insn ("Incorrect insn:",insn);
+ fatal_insn ("incorrect insn:",insn);
if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (dest)))
return *l = 3, (AS2 (adiw,r28,%o0-63) CR_TAB
if (disp > MAX_LD_OFFSET (GET_MODE (dest)))
{
if (reg_base != REG_Y)
- fatal_insn ("Incorrect insn:",insn);
+ fatal_insn ("incorrect insn:",insn);
if (disp <= 63 + MAX_LD_OFFSET (GET_MODE (dest)))
return *l = 4, (AS2 (adiw,r28,%o0-62) CR_TAB
else if (GET_CODE (base) == POST_INC) /* (R++) */
return *l=2, (AS2 (st,%0,%A1) CR_TAB
AS2 (st,%0,%B1));
- fatal_insn ("Unknown move insn:",insn);
+ fatal_insn ("unknown move insn:",insn);
return "";
}
}
}
else
- fatal_insn ("Bad shift insn:", insn);
+ fatal_insn ("bad shift insn:", insn);
if (second_label)
{
}
}
else if (CONSTANT_P (operands[2]))
- fatal_insn ("Internal compiler bug.\nIncorrect shift:", insn);
+ fatal_insn ("internal compiler error. Incorrect shift:", insn);
out_shift_with_cnt (AS1 (lsl,%0),
insn, operands, len, 1);
}
}
else if (CONSTANT_P (operands[2]))
- fatal_insn ("Internal compiler bug.\nIncorrect shift:", insn);
+ fatal_insn ("internal compiler error. Incorrect shift:", insn);
out_shift_with_cnt (AS1 (asr,%0),
insn, operands, len, 1);
}
}
else if (CONSTANT_P (operands[2]))
- fatal_insn ("Internal compiler bug.\nIncorrect shift:", insn);
+ fatal_insn ("internal compiler error. Incorrect shift:", insn);
out_shift_with_cnt (AS1 (lsr,%0),
insn, operands, len, 1);
{
if (DECL_INITIAL (*node) == NULL_TREE && !DECL_EXTERNAL (*node))
{
- warning ("Only initialized variables can be placed into "
- "program memory area.");
+ warning ("only initialized variables can be placed into "
+ "program memory area");
*no_add_attrs = true;
}
}
the most combinations to be found. */
#define TRAMPOLINE_TEMPLATE(FILE) \
- internal_error ("Trampolines not supported\n")
+ internal_error ("trampolines not supported")
/* Length in units of the trampoline for entering a nested function. */
case 40: target_flags |= C40_FLAG; break;
case 44: target_flags |= C44_FLAG; break;
default:
- warning ("Unknown CPU version %d, using 40.\n", c4x_cpu_version);
+ warning ("unknown CPU version %d, using 40.\n", c4x_cpu_version);
c4x_cpu_version = 40;
target_flags |= C40_FLAG;
}
requires more than 32767 words of local temporary
storage! */
if (size > 32767)
- error ("ISR %s requires %d words of local vars, max is 32767.",
+ error ("ISR %s requires %d words of local vars, max is 32767",
current_function_name, size);
insn = emit_insn (gen_addqi3 (gen_rtx_REG (QImode, SP_REGNO),
return 0;
case CONST_DOUBLE:
- fatal_insn ("Using CONST_DOUBLE for address", addr);
+ fatal_insn ("using CONST_DOUBLE for address", addr);
default:
return 0;
mode = GET_MODE (op);
if (mode != QImode && mode != Pmode)
- fatal_insn ("Mode not QImode", op);
+ fatal_insn ("mode not QImode", op);
if (GET_CODE (op) == CONST_INT)
return c4x_L_constant (op) || c4x_J_constant (op);
mode = GET_MODE (op);
if (mode != QImode && mode != Pmode)
- fatal_insn ("Mode not QImode", op);
+ fatal_insn ("mode not QImode", op);
if (GET_CODE (op) == CONST_INT)
return c4x_L_constant (op) || c4x_N_constant (op) || c4x_J_constant (op);
*disp = 0;
if (GET_CODE (op) != MEM)
- fatal_insn ("Invalid indirect memory address", op);
+ fatal_insn ("invalid indirect memory address", op);
op = XEXP (op, 0);
switch (GET_CODE (op))
/* Fallthrough. */
default:
- fatal_insn ("Invalid indirect (S) memory address", op);
+ fatal_insn ("invalid indirect (S) memory address", op);
}
}
cfoa_size, current_function_args_size);
if (cris_max_stackframe && framesize > cris_max_stackframe)
- warning ("Stackframe too big: %d bytes", framesize);
+ warning ("stackframe too big: %d bytes", framesize);
}
/* Return nonzero if there are regs mentioned in the insn that are not all
/* Do a sanity check to avoid generating invalid code. */
if (current_function_epilogue_delay_list)
- internal_error ("Allocated but unused delay list in epilogue");
+ internal_error ("allocated but unused delay list in epilogue");
}
return;
}
thoroughly), assert the assumption that all usage of
__builtin_eh_return are handled above. */
if (current_function_calls_eh_return)
- internal_error ("Unexpected function type needing stack adjustment for\
+ internal_error ("unexpected function type needing stack adjustment for\
__builtin_eh_return");
/* If we pushed some register parameters, then adjust the stack for
{
case REG:
if (REGNO (operand) > 15)
- internal_error ("Internal: Bad register: %d", REGNO (operand));
+ internal_error ("internal error: bad register: %d", REGNO (operand));
fprintf (file, "$%s", reg_names[REGNO (operand)]);
return;
register. */
if (cris_reg_overlap_mentioned_p (cc_status.value1,
cc_status.value2))
- internal_error ("Internal: sideeffect-insn affecting main effect");
+ internal_error ("internal error: sideeffect-insn affecting main effect");
return;
}
else if ((REG_P (XEXP (XVECEXP (exp, 0, 0), 1))
}
/* If we get here, the caller got its initial tests wrong. */
- internal_error ("Internal: cris_side_effect_mode_ok with bad operands");
+ internal_error ("internal error: cris_side_effect_mode_ok with bad operands");
}
/* The function reg_overlap_mentioned_p in CVS (still as of 2001-05-16)
return 0;
default:
- fatal_insn ("Unrecognized supposed constant", x);
+ fatal_insn ("unrecognized supposed constant", x);
}
return 1;
return 0;
default:
- fatal_insn ("Unrecognized supposed constant", x);
+ fatal_insn ("unrecognized supposed constant", x);
}
return 1;
return 0;
default:
- fatal_insn ("Unrecognized supposed constant in cris_global_pic_symbol",
+ fatal_insn ("unrecognized supposed constant in cris_global_pic_symbol",
x);
}
cris_cpu_version = 10;
if (cris_cpu_version < 0 || cris_cpu_version > 10)
- error ("Unknown CRIS version specification in -march= or -mcpu= : %s",
+ error ("unknown CRIS version specification in -march= or -mcpu= : %s",
cris_cpu_str);
/* Set the target flags. */
cris_tune = 10;
if (cris_tune < 0 || cris_tune > 10)
- error ("Unknown CRIS cpu version specification in -mtune= : %s",
+ error ("unknown CRIS cpu version specification in -mtune= : %s",
cris_tune_str);
if (cris_tune >= CRIS_CPU_SVINTO)
if ((write_symbols == DWARF_DEBUG
|| write_symbols == DWARF2_DEBUG) && ! TARGET_ELF)
{
- warning ("Specified -g option is invalid with -maout and -melinux");
+ warning ("that particular -g option is invalid with -maout and -melinux");
write_symbols = DBX_DEBUG;
}
GO_IF_LEGITIMATE_ADDRESS, but we're here for your
safety. */
if (side_effects_p (addr))
- fatal_insn ("Unexpected side-effects in address", addr);
+ fatal_insn ("unexpected side-effects in address", addr);
emit_insn (gen_rtx_SET
(VOIDmode,
postincrements. They should be stopped in
GO_IF_LEGITIMATE_ADDRESS, but we're here for your safety. */
if (side_effects_p (addr))
- fatal_insn ("Unexpected side-effects in address", addr);
+ fatal_insn ("unexpected side-effects in address", addr);
emit_insn (gen_rtx_SET
(VOIDmode,
if (GET_CODE (XEXP (x, 0)) != CODE_LABEL
&& (GET_CODE (XEXP (x, 0)) != NOTE
|| NOTE_LINE_NUMBER (XEXP (x, 0)) != NOTE_INSN_DELETED_LABEL))
- fatal_insn ("Unexpected address expression", x);
+ fatal_insn ("unexpected address expression", x);
if (flag_pic)
{
}
else
/* Labels are never marked as global symbols. */
- fatal_insn ("Unexpected PIC symbol", x);
+ fatal_insn ("unexpected PIC symbol", x);
/* Sanity check. */
if (! current_function_uses_pic_offset_table)
- internal_error ("Emitting PIC operand, but PIC register isn't set up");
+ internal_error ("emitting PIC operand, but PIC register isn't set up");
break;
}
case NOTE:
if (NOTE_LINE_NUMBER (x) != NOTE_INSN_DELETED_LABEL)
- fatal_insn ("Unexpected NOTE as addr_const:", x);
+ fatal_insn ("unexpected NOTE as addr_const:", x);
case CODE_LABEL:
case CONST_INT:
case CONST_DOUBLE:
/* Node: Profiling */
#define FUNCTION_PROFILER(FILE, LABELNO) \
- error ("No FUNCTION_PROFILER for CRIS")
+ error ("no FUNCTION_PROFILER for CRIS")
/* No profiling for the time being. */
#define FUNCTION_BLOCK_PROFILER(FILE, LABELNO) \
- error ("No FUNCTION_BLOCK_PROFILER for CRIS")
+ error ("no FUNCTION_BLOCK_PROFILER for CRIS")
/* No profiling for the time being. */
#define BLOCK_PROFILER(FILE, BLOCKNO) \
- error ("No BLOCK_PROFILER for CRIS")
+ error ("no BLOCK_PROFILER for CRIS")
/* FIXME: Some of the undefined macros might be mandatory. If so, fix
documentation. */
if (ok_p
&& (hard_regno_mode_ok[(int)mode1][regno]
!= hard_regno_mode_ok[(int)mode2][regno]))
- error ("Bad modes_tieable_p for register %s, mode1 %s, mode2 %s",
+ error ("bad modes_tieable_p for register %s, mode1 %s, mode2 %s",
reg_names[regno], GET_MODE_NAME (mode1),
GET_MODE_NAME (mode2));
}
return;
}
- fatal_insn ("Bad insn to d30v_print_operand_address:", x);
+ fatal_insn ("bad insn to d30v_print_operand_address:", x);
}
\f
switch (GET_CODE (x))
{
default:
- fatal_insn ("Bad insn to d30v_print_operand_memory_reference:", x);
+ fatal_insn ("bad insn to d30v_print_operand_memory_reference:", x);
break;
case SUBREG:
if (GET_CODE (x0) == REG && GPR_P (REGNO (x0)))
fprintf (stream, "%s%s", reg_names[REGNO (x0) + offset0], suffix);
else
- fatal_insn ("Bad insn to d30v_print_operand_memory_reference:", x);
+ fatal_insn ("bad insn to d30v_print_operand_memory_reference:", x);
}
fputs (",", stream);
GET_MODE (x1));
x1 = SUBREG_REG (x1);
if (GET_CODE (x1) != REG)
- fatal_insn ("Bad insn to d30v_print_operand_memory_reference:", x);
+ fatal_insn ("bad insn to d30v_print_operand_memory_reference:", x);
/* fall through */
case REG:
break;
default:
- fatal_insn ("Bad insn to d30v_print_operand_memory_reference:", x);
+ fatal_insn ("bad insn to d30v_print_operand_memory_reference:", x);
}
}
case 'f': /* Print a SF floating constant as an int */
if (GET_CODE (x) != CONST_DOUBLE)
- fatal_insn ("Bad insn to d30v_print_operand, 'f' modifier:", x);
+ fatal_insn ("bad insn to d30v_print_operand, 'f' modifier:", x);
REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
REAL_VALUE_TO_TARGET_SINGLE (rv, num);
case 'A': /* Print accumulator number without an `a' in front of it. */
if (GET_CODE (x) != REG || !ACCUM_P (REGNO (x)))
- fatal_insn ("Bad insn to d30v_print_operand, 'A' modifier:", x);
+ fatal_insn ("bad insn to d30v_print_operand, 'A' modifier:", x);
putc ('0' + REGNO (x) - ACCUM_FIRST, stream);
break;
case 'M': /* Print a memory reference for ld/st */
if (GET_CODE (x) != MEM)
- fatal_insn ("Bad insn to d30v_print_operand, 'M' modifier:", x);
+ fatal_insn ("bad insn to d30v_print_operand, 'M' modifier:", x);
d30v_print_operand_memory_reference (stream, XEXP (x, 0));
break;
fputs ((letter == 'T') ? "tnz" : "tzr", stream);
else
- fatal_insn ("Bad insn to print_operand, 'F' or 'T' modifier:", x);
+ fatal_insn ("bad insn to print_operand, 'F' or 'T' modifier:", x);
break;
case 'B': /* emit offset single bit to change */
fprintf (stream, "%d", 31 - log);
else
- fatal_insn ("Bad insn to print_operand, 'B' modifier:", x);
+ fatal_insn ("bad insn to print_operand, 'B' modifier:", x);
break;
case 'E': /* Print u if this is zero extend, nothing if sign extend. */
if (GET_CODE (x) == ZERO_EXTEND)
putc ('u', stream);
else if (GET_CODE (x) != SIGN_EXTEND)
- fatal_insn ("Bad insn to print_operand, 'E' modifier:", x);
+ fatal_insn ("bad insn to print_operand, 'E' modifier:", x);
break;
case 'R': /* Return appropriate cmp instruction for relational test. */
case GEU: fputs ("cmpuge", stream); break;
default:
- fatal_insn ("Bad insn to print_operand, 'R' modifier:", x);
+ fatal_insn ("bad insn to print_operand, 'R' modifier:", x);
}
break;
fprintf (stream, "%d", (int) (32 - INTVAL (x)));
else
- fatal_insn ("Bad insn to print_operand, 's' modifier:", x);
+ fatal_insn ("bad insn to print_operand, 's' modifier:", x);
break;
case 'S': /* Subtract 32. */
fprintf (stream, "%d", (int)(INTVAL (x) - 32));
else
- fatal_insn ("Bad insn to print_operand, 's' modifier:", x);
+ fatal_insn ("bad insn to print_operand, 's' modifier:", x);
break;
d30v_print_operand_address (stream, x);
else
- fatal_insn ("Bad insn in d30v_print_operand, 0 case", x);
+ fatal_insn ("bad insn in d30v_print_operand, 0 case", x);
return;
{
char buf[80];
- sprintf (buf, "Invalid asm template character '%%%c'", letter);
+ sprintf (buf, "invalid asm template character '%%%c'", letter);
fatal_insn (buf, x);
}
}
&& GPR_P (REGNO (operands[1])))
return "st2w %1,%M0";
- fatal_insn ("Bad call to d30v_move_2words", insn);
+ fatal_insn ("bad call to d30v_move_2words", insn);
}
\f
N_("Debug memory address support in compiler") }, \
\
{ "asm-optimize", 0, \
- N_("Make adjacent short instructions parallel if possible.") }, \
+ N_("Make adjacent short instructions parallel if possible") }, \
\
{ "no-asm-optimize", 0, \
- N_("Do not make adjacent short instructions parallel.") }, \
+ N_("Do not make adjacent short instructions parallel") }, \
\
{ "extmem", 0, \
N_("Link programs/data to be in external memory by default") }, \
if (SMALL_INTVAL(current_frame_info.var_size) && ((current_frame_info.var_size & 0x8000) == 0))
fprintf (file, "\t%s=%ld\n\t*%s++%s\n", reg_names[REG_J], current_frame_info.var_size, sp, reg_names[REG_J]);
else
- fatal_error ("Stack size > 32k");
+ fatal_error ("stack size > 32k");
}
}
if (current_frame_info.args_size == 1)
fprintf (file, "\t*%s++\n", sp);
else
- error ("Stack size > 32k");
+ error ("stack size > 32k");
}
if (frame_pointer_needed)
else if (GET_CODE (XEXP(addr,1)) == CONST_INT)
offset = INTVAL(XEXP(addr,1)) + 1;
else
- fatal_error ("Invalid addressing mode");
+ fatal_error ("invalid addressing mode");
fprintf (asm_out_file, "\t*(%d)=%s\n", offset + 31, reg_names[REGNO(operands[1]) + 1]);
}
else if (letter == 'm')
fprintf (file, "%s", himode_reg_name[REGNO (op)]);
else
- output_operand_lossage ("Bad register extension code");
+ output_operand_lossage ("bad register extension code");
}
else if (code == MEM)
output_address (XEXP(op,0));
if (offset >= -31 && offset <= 0)
offset = 31 + offset;
else
- fatal_error ("Invalid offset in ybase addressing");
+ fatal_error ("invalid offset in ybase addressing");
}
else
- fatal_error ("Invalid register in ybase addressing");
+ fatal_error ("invalid register in ybase addressing");
fprintf (file, "*(%d)", offset);
break;
shift_asm_ptr_first = lshift_right_asm_first;
}
else
- fatal_error ("Invalid shift operator in emit_1600_core_shift");
+ fatal_error ("invalid shift operator in emit_1600_core_shift");
while (shift_amount != 0)
{
else if (mode == HImode)
emit_insn (gen_rtx_SET (VOIDmode, cc0_rtx, x));
else
- fatal_error ("Invalid mode for gen_tst_reg");
+ fatal_error ("invalid mode for gen_tst_reg");
return cc0_rtx;
}
force_reg (HImode,y))));
}
else
- fatal_error ("Invalid mode for integer comparison in gen_compare_reg");
+ fatal_error ("invalid mode for integer comparison in gen_compare_reg");
return cc0_rtx;
}
%{mmap3:m3_crt0.o%s} \
%{mmap4:m4_crt0.o%s} \
%{!mmap*: %{!ifile*: m4_crt0.o%s} %{ifile*: \
-%eA -ifile option requires a -map option}}"
+%ea -ifile option requires a -map option}}"
/* Specify the end file to link with */
%{mmap3:m3_crtn.o%s} \
%{mmap4:m4_crtn.o%s} \
%{!mmap*: %{!ifile*: m4_crtn.o%s} %{ifile*: \
-%eA -ifile option requires a -map option}}"
+%ea -ifile option requires a -map option}}"
/* Tell gcc where to look for the startfile */
for profiling a function entry. */
#define FUNCTION_PROFILER(FILE, LABELNO) \
- internal_error ("Profiling not implemented yet.")
+ internal_error ("profiling not implemented yet")
/* Output assembler code to FILE to initialize this source file's
basic block profiling info, if that has not already been done. */
#define FUNCTION_BLOCK_PROFILER(FILE, LABELNO) \
- internal_error ("Profiling not implemented yet.")
+ internal_error ("profiling not implemented yet")
/* Output assembler code to FILE to increment the entry-count for
the BLOCKNO'th basic block in this source file. */
#define BLOCK_PROFILER(FILE, BLOCKNO) \
- internal_error ("Profiling not implemented yet.")
+ internal_error ("profiling not implemented yet")
/* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
#define EXIT_IGNORE_STACK (0)
#define TRAMPOLINE_TEMPLATE(FILE) \
- internal_error ("Trampolines not yet implemented");
+ internal_error ("trampolines not yet implemented");
/* Length in units of the trampoline for entering a nested function.
This is a dummy value */
CXT is an RTX for the static chain value for the function. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
- internal_error ("Trampolines not yet implemented");
+ internal_error ("trampolines not yet implemented");
/* A C expression which is nonzero if a function must have and use a
frame pointer. If its value is nonzero the functions will have a
/* This is how to output an insn to push a register on the stack.
It need not be very fast code since it is used only for profiling */
#define ASM_OUTPUT_REG_PUSH(FILE,REGNO) \
- internal_error ("Profiling not implemented yet.");
+ internal_error ("profiling not implemented yet");
/* This is how to output an insn to pop a register from the stack.
It need not be very fast code since it is used only for profiling */
#define ASM_OUTPUT_REG_POP(FILE,REGNO) \
- internal_error ("Profiling not implemented yet.");
+ internal_error ("profiling not implemented yet");
\f
/* OUTPUT OF DISPATCH TABLES */
if (!TARGET_H8300S && TARGET_MAC)
{
- error ("-ms2600 is used without -ms.");
+ error ("-ms2600 is used without -ms");
target_flags |= 1;
}
}
{
if (DECL_INITIAL (decl) == NULL_TREE)
{
- warning ("Only initialized variables can be placed into the 8-bit area.");
+ warning ("only initialized variables can be placed into the 8-bit area");
*no_add_attrs = true;
}
else
{
if (DECL_INITIAL (decl) == NULL_TREE)
{
- warning ("Only initialized variables can be placed into the 8-bit area.");
+ warning ("only initialized variables can be placed into the 8-bit area");
*no_add_attrs = true;
}
else
#undef SUBTARGET_SWITCHES
#define SUBTARGET_SWITCHES \
- { "no-bnu210", -MASK_BNU210, "Ignored (obsolete)." }, \
- { "bnu210", MASK_BNU210, "Ignored (obsolete)." },
+ { "no-bnu210", -MASK_BNU210, "Ignored (obsolete)" }, \
+ { "bnu210", MASK_BNU210, "Ignored (obsolete)" },
/* Warn that -mbnu210 is now obsolete. */
#undef SUBTARGET_OVERRIDE_OPTIONS
{ \
if (target_flags & MASK_BNU210) \
{ \
- warning ("-mbnu210 is ignored (option is obsolete)."); \
+ warning ("-mbnu210 is ignored (option is obsolete)"); \
} \
} \
while (0)
if (!strcmp (ix86_cmodel_string, "small"))
ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
else if (flag_pic)
- sorry ("Code model %s not supported in PIC mode", ix86_cmodel_string);
+ sorry ("code model %s not supported in PIC mode", ix86_cmodel_string);
else if (!strcmp (ix86_cmodel_string, "32"))
ix86_cmodel = CM_32;
else if (!strcmp (ix86_cmodel_string, "kernel") && !flag_pic)
ix86_cmodel = flag_pic ? CM_SMALL_PIC : CM_SMALL;
}
if ((TARGET_64BIT == 0) != (ix86_cmodel == CM_32))
- error ("Code model `%s' not supported in the %s bit mode.",
+ error ("code model `%s' not supported in the %s bit mode",
ix86_cmodel_string, TARGET_64BIT ? "64" : "32");
if (ix86_cmodel == CM_LARGE)
- sorry ("Code model `large' not supported yet.");
+ sorry ("code model `large' not supported yet");
if ((TARGET_64BIT != 0) != ((target_flags & MASK_64BIT) != 0))
- sorry ("%i-bit mode not compiled in.",
+ sorry ("%i-bit mode not compiled in",
(target_flags & MASK_64BIT) ? 64 : 32);
if (ix86_arch_string != 0)
if (TARGET_64BIT)
{
if (TARGET_ALIGN_DOUBLE)
- error ("-malign-double makes no sense in the 64bit mode.");
+ error ("-malign-double makes no sense in the 64bit mode");
if (TARGET_RTD)
- error ("-mrtd calling convention not supported in the 64bit mode.");
+ error ("-mrtd calling convention not supported in the 64bit mode");
/* Enable by default the SSE and MMX builtins. */
target_flags |= MASK_SSE2 | MASK_SSE | MASK_MMX | MASK_128BIT_LONG_DOUBLE;
}
switch (code)
{
case 0:
- error ("Extended registers have no high halves\n");
+ error ("extended registers have no high halves");
break;
case 1:
fprintf (file, "r%ib", REGNO (x) - FIRST_REX_INT_REG + 8);
fprintf (file, "r%i", REGNO (x) - FIRST_REX_INT_REG + 8);
break;
default:
- error ("Unsupported operand size for extended register.\n");
+ error ("unsupported operand size for extended register");
break;
}
return;
len+=4;
break;
default:
- fatal_insn ("Unknown insn mode", insn);
+ fatal_insn ("unknown insn mode", insn);
}
}
}
#define HALF_PIC_NUMBER_REFS 0
#define HALF_PIC_ENCODE(DECL)
#define HALF_PIC_DECLARE(NAME)
-#define HALF_PIC_INIT() error ("half-pic init called on systems that don't support it.")
+#define HALF_PIC_INIT() error ("half-pic init called on systems that don't support it")
#define HALF_PIC_ADDRESS_P(X) 0
#define HALF_PIC_PTR(X) X
#define HALF_PIC_FINISH(STREAM)
{ "no-mix-sse-i387", -MASK_MIX_SSE_I387, \
N_("Do not use both SSE and i387 instruction sets for floating point arithmetics") },\
{ "128bit-long-double", MASK_128BIT_LONG_DOUBLE, \
- N_("sizeof(long double) is 16.") }, \
+ N_("sizeof(long double) is 16") }, \
{ "96bit-long-double", -MASK_128BIT_LONG_DOUBLE, \
- N_("sizeof(long double) is 12.") }, \
+ N_("sizeof(long double) is 12") }, \
{ "64", MASK_64BIT, \
N_("Generate 64bit x86-64 code") }, \
{ "32", -MASK_64BIT, \
abort ();
if (i386_pe_dllexport_name_p (oldname))
{
- error ("`%s' declared as both exported to and imported from a DLL.",
+ error ("`%s' declared as both exported to and imported from a DLL",
IDENTIFIER_POINTER (DECL_NAME (decl)));
return;
}
to try and figure out what's wrong. */ \
char *djgpp = getenv ("DJGPP"); \
if (djgpp == NULL) \
- fatal ("Environment variable DJGPP not defined."); \
+ fatal ("environment variable DJGPP not defined"); \
else if (access (djgpp, R_OK) == 0) \
- fatal ("Environment variable DJGPP points to missing file '%s'.", \
+ fatal ("environment variable DJGPP points to missing file '%s'", \
djgpp); \
else \
- fatal ("Environment variable DJGPP points to corrupt file '%s'.", \
+ fatal ("environment variable DJGPP points to corrupt file '%s'", \
djgpp); \
} \
standard_exec_prefix = update_path (standard_exec_prefix, NULL); \
} \
/* ??? See the LONG_DOUBLE_TYPE_SIZE definition below. */ \
if (TARGET_LONG_DOUBLE_64) \
- warning ("The -mlong-double-64 option does not work yet.");\
+ warning ("the -mlong-double-64 option does not work yet");\
i960_initialize (); \
}
#define TARGET_OPTIONS \
{ \
{ "fixed-range=", &ia64_fixed_range_string, \
- N_("Specify range of registers to make fixed.")}, \
+ N_("Specify range of registers to make fixed")}, \
}
/* Sometimes certain combinations of command options do not make sense on a
if (GET_CODE (x) != CONST_DOUBLE
|| GET_MODE_CLASS (GET_MODE (x)) != MODE_FLOAT)
- fatal_insn ("Bad insn for 'A'", x);
+ fatal_insn ("bad insn for 'A'", x);
REAL_VALUE_FROM_CONST_DOUBLE (d, x);
REAL_VALUE_TO_DECIMAL (d, "%.20e", str);
fprintf (file, "%s", str);
if (GET_CODE (addr) == PRE_INC)
{
if (GET_CODE (XEXP (addr, 0)) != REG)
- fatal_insn ("Pre-increment address is not a register", x);
+ fatal_insn ("pre-increment address is not a register", x);
fprintf (file, "@+%s", reg_names[REGNO (XEXP (addr, 0))]);
}
else if (GET_CODE (addr) == PRE_DEC)
{
if (GET_CODE (XEXP (addr, 0)) != REG)
- fatal_insn ("Pre-decrement address is not a register", x);
+ fatal_insn ("pre-decrement address is not a register", x);
fprintf (file, "@-%s", reg_names[REGNO (XEXP (addr, 0))]);
}
else if (GET_CODE (addr) == POST_INC)
{
if (GET_CODE (XEXP (addr, 0)) != REG)
- fatal_insn ("Post-increment address is not a register", x);
+ fatal_insn ("post-increment address is not a register", x);
fprintf (file, "@%s+", reg_names[REGNO (XEXP (addr, 0))]);
}
fputs (reg_names[REGNO (base)], file);
}
else
- fatal_insn ("Bad address", addr);
+ fatal_insn ("bad address", addr);
}
else if (GET_CODE (base) == LO_SUM)
{
fputs (reg_names[REGNO (XEXP (base, 0))], file);
}
else
- fatal_insn ("Bad address", addr);
+ fatal_insn ("bad address", addr);
break;
case LO_SUM :
if (GET_CODE (XEXP (addr, 0)) != REG)
- fatal_insn ("Lo_sum not of register", addr);
+ fatal_insn ("lo_sum not of register", addr);
if (small_data_operand (XEXP (addr, 1), VOIDmode))
fputs ("sda(", file);
else
else
{
/* !!!! SCz wrong here. */
- fatal_insn ("Move insn not handled", insn);
+ fatal_insn ("move insn not handled", insn);
}
}
else
break;
default:
- fatal_insn ("Invalid register in the move instruction", insn);
+ fatal_insn ("invalid register in the move instruction", insn);
break;
}
return;
/* Operand 1 must be a hard register. */
if (!H_REG_P (operands[1]))
{
- fatal_insn ("Invalid operand in the instruction", insn);
+ fatal_insn ("invalid operand in the instruction", insn);
}
reg = REGNO (operands[1]);
break;
default:
- fatal_insn ("Invalid register in the move instruction", insn);
+ fatal_insn ("invalid register in the move instruction", insn);
break;
}
}
else
{
/* !!!! SCz wrong here. */
- fatal_insn ("Move insn not handled", insn);
+ fatal_insn ("move insn not handled", insn);
}
}
else
break;
default:
- fatal_insn ("Invalid register in the instruction", insn);
+ fatal_insn ("invalid register in the instruction", insn);
break;
}
}
break;
default:
- fatal_insn ("Invalid register in the move instruction", insn);
+ fatal_insn ("invalid register in the move instruction", insn);
break;
}
return;
}
else
{
- fatal_insn ("Operand 1 must be a hard register", insn);
+ fatal_insn ("operand 1 must be a hard register", insn);
}
}
if (GET_CODE (operands[2]) != CONST_INT
|| (!D_REG_P (operands[0]) && !DA_REG_P (operands[0])))
- fatal_insn ("Invalid rotate insn", insn);
+ fatal_insn ("invalid rotate insn", insn);
val = INTVAL (operands[2]);
if (code == ROTATERT)
if (this_insn_uses_z && this_insn_uses_ix && this_insn_uses_iy)
{
- fatal_insn ("Registers IX, IY and Z used in the same INSN", insn);
+ fatal_insn ("registers IX, IY and Z used in the same INSN", insn);
}
if (this_insn_uses_d)
{
if (this_insn_uses_z)
{
- fatal_insn ("Cannot do z-register replacement", insn);
+ fatal_insn ("cannot do z-register replacement", insn);
}
return 0;
}
{
INSN_CODE (insn) = -1;
if (!validate_replace_rtx (z_reg, replace_reg, insn))
- fatal_insn ("Cannot do z-register replacement", insn);
+ fatal_insn ("cannot do z-register replacement", insn);
}
/* Likewise for (REG:QI Z). */
if (!validate_replace_rtx (z_reg, replace_reg, info.last))
{
- fatal_insn ("Invalid Z register replacement for insn", insn);
+ fatal_insn ("invalid Z register replacement for insn", insn);
}
insn = NEXT_INSN (info.last);
}
}
else
{
- printf ("Insn not handled by Z replacement:\n");
+ printf ("insn not handled by Z replacement:\n");
fflush (stdout);
debug_rtx (insn);
}
- 2);
#if (MONITOR_GCC & 0x2) /* How often do long branches happen? */
if ((unsigned) (delta + 0x8000) >= 0x10000)
- warning ("Internal gcc monitor: short-branch(%x)", delta);
+ warning ("internal gcc monitor: short-branch(%x)", delta);
#endif
/* Delete the jump. */
#if (MONITOR_GCC & 0x10) /* Watch for suspicious symbolic locations. */
if (! (GET_CODE (reg) == REG
&& REGNO (reg) >= FIRST_PSEUDO_REGISTER))
- warning ("Internal gcc error: Can't express symbolic location");
+ warning ("internal gcc error: Can't express symbolic location");
#endif
return 0;
}
p++; \
else \
{ \
- error ("Invalid option `-mshort-data-%s'", m88k_short_data); \
+ error ("invalid option `-mshort-data-%s'", m88k_short_data); \
break; \
} \
m88k_gp_threshold = atoi (m88k_short_data); \
|| (mcore_stack_increment == 0
&& (mcore_stack_increment_string[0] != '0'
|| mcore_stack_increment_string[1] != 0)))
- error ("Invalid option `-mstack-increment=%s'",
+ error ("invalid option `-mstack-increment=%s'",
mcore_stack_increment_string);
}
{ {"hardlit", HARDLIT_BIT, \
N_("Inline constants if it can be done in 2 insns or less") }, \
{"no-hardlit", - HARDLIT_BIT, \
- N_("inline constants if it only takes 1 instruction") }, \
+ N_("Inline constants if it only takes 1 instruction") }, \
{"4align", - ALIGN8_BIT, \
N_("Set maximum alignment to 4") }, \
{"8align", ALIGN8_BIT, \
%{!mips1:%{!mips2:%{!mips32:%{!mlong32:-D__SIZE_TYPE__=long\\ unsigned\\ int -D__PTRDIFF_TYPE__=long\\ int}}}}} \
%{mabi=o64:\
%{mlong64:-D__SIZE_TYPE__=long\\ unsigned\\ int -D__PTRDIFF_TYPE__=long\\ int \
- %{mlong32:%e-mlong32 and -mlong64 can not both be specified.}} \
+ %{mlong32:%e-mlong32 and -mlong64 can not both be specified}} \
%{!mlong64:-D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int }} \
%{mabi=32:-D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int} \
%{mabi=meabi|!mabi=*:\
%{mlong64:-D__SIZE_TYPE__=long\\ unsigned\\ int -D__PTRDIFF_TYPE__=long\\ int \
- %{mlong32:%e-mlong32 and -mlong64 can not both be specified.}} \
+ %{mlong32:%e-mlong32 and -mlong64 can not both be specified}} \
%{!mlong64:-D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int }} \
"
%{!mips3:%{!mips4:%{!mips5:%{!mips64:%{!mlong64:-D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int}}}}}} \
%{mabi=o64:\
%{mlong64:-D__SIZE_TYPE__=long\\ unsigned\\ int -D__PTRDIFF_TYPE__=long\\ int \
- %{mlong32:%e-mlong32 and -mlong64 can not both be specified.}} \
+ %{mlong32:%e-mlong32 and -mlong64 can not both be specified}} \
%{!mlong64:-D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int }} \
%{mabi=32:-D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int} \
%{mabi=meabi|!mabi=*:\
%{mlong64:-D__SIZE_TYPE__=long\\ unsigned\\ int -D__PTRDIFF_TYPE__=long\\ int \
- %{mlong32:%e-mlong32 and -mlong64 can not both be specified.}} \
+ %{mlong32:%e-mlong32 and -mlong64 can not both be specified}} \
%{!mlong64:-D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int }} \
"
#endif /* ISA */
if (ret == 0)
{
- abort_with_insn (insn, "Bad move");
+ abort_with_insn (insn, "bad move");
return 0;
}
if (TARGET_FLOAT64)
{
if (!TARGET_64BIT)
- abort_with_insn (insn, "Bad move");
+ abort_with_insn (insn, "bad move");
#ifdef TARGET_FP_CALL_32
if (FP_CALL_GP_REG_P (regno1))
if (TARGET_FLOAT64)
{
if (!TARGET_64BIT)
- abort_with_insn (insn, "Bad move");
+ abort_with_insn (insn, "bad move");
#ifdef TARGET_FP_CALL_32
if (FP_CALL_GP_REG_P (regno0))
if (ret == 0)
{
- abort_with_insn (insn, "Bad move");
+ abort_with_insn (insn, "bad move");
return 0;
}
else if (num_regs < 1)
abort_with_insn (insn,
- "Cannot do block move, not enough scratch registers");
+ "cannot do block move, not enough scratch registers");
while (bytes > 0)
{
#else
if (mips_abi_string)
- error ("This target does not support the -mabi switch.");
+ error ("this target does not support the -mabi switch");
#endif
#ifdef MIPS_CPU_STRING_DEFAULT
if (mips_entry_string != NULL)
{
if (*mips_entry_string != '\0')
- error ("Invalid option `entry%s'", mips_entry_string);
+ error ("invalid option `entry%s'", mips_entry_string);
if (! TARGET_MIPS16)
warning ("-mentry is only meaningful with -mips-16");
/* sdbout_parms does not want this to crash for unrecognized cases. */
#if 0
else if (reg != arg_pointer_rtx)
- abort_with_insn (addr, "mips_debugger_offset called with non stack/frame/arg pointer.");
+ abort_with_insn (addr, "mips_debugger_offset called with non stack/frame/arg pointer");
#endif
return offset;
break;
default:
- error ("PRINT_OPERAND: Unknown punctuation '%c'", letter);
+ error ("PRINT_OPERAND: unknown punctuation '%c'", letter);
break;
}
{
case REG:
if (! TARGET_MIPS16 && REGNO (addr) == ARG_POINTER_REGNUM)
- abort_with_insn (addr, "Arg pointer not eliminated.");
+ abort_with_insn (addr, "arg pointer not eliminated");
fprintf (file, "0(%s)", reg_names [REGNO (addr)]);
break;
register rtx arg1 = XEXP (addr, 1);
if (! mips_split_addresses)
- abort_with_insn (addr, "PRINT_OPERAND_ADDRESS, Spurious LO_SUM.");
+ abort_with_insn (addr, "PRINT_OPERAND_ADDRESS, Spurious LO_SUM");
if (GET_CODE (arg0) != REG)
abort_with_insn (addr,
- "PRINT_OPERAND_ADDRESS, LO_SUM with #1 not REG.");
+ "PRINT_OPERAND_ADDRESS, LO_SUM with #1 not REG");
fprintf (file, "%%lo(");
print_operand_address (file, arg1);
abort_with_insn (addr, "PRINT_OPERAND_ADDRESS, invalid insn #2");
if (REGNO (reg) == ARG_POINTER_REGNUM)
- abort_with_insn (addr, "Arg pointer not eliminated.");
+ abort_with_insn (addr, "arg pointer not eliminated");
if (TARGET_MIPS16
&& GET_CODE (offset) == CONST
if (gp_offset < 0 || end_offset < 0)
internal_error
- ("gp_offset (%ld) or end_offset (%ld) is less than zero.",
+ ("gp_offset (%ld) or end_offset (%ld) is less than zero",
(long) gp_offset, (long) end_offset);
/* If we see a large frame in mips16 mode, we save the registers
if (fp_offset < 0 || end_offset < 0)
internal_error
- ("fp_offset (%ld) or end_offset (%ld) is less than zero.",
+ ("fp_offset (%ld) or end_offset (%ld) is less than zero",
(long) fp_offset, (long) end_offset);
else if (fp_offset < 32768)
pattern = RTVEC_ELT (adjust, i);
if (GET_CODE (pattern) != SET
|| GET_CODE (SET_SRC (pattern)) != ASHIFT)
- abort_with_insn (pattern, "Insn is not a shift");
+ abort_with_insn (pattern, "insn is not a shift");
PUT_CODE (SET_SRC (pattern), ASHIFTRT);
insn = emit_insn (pattern);
#define HALF_PIC_NUMBER_REFS 0
#define HALF_PIC_ENCODE(DECL)
#define HALF_PIC_DECLARE(NAME)
-#define HALF_PIC_INIT() error ("half-pic init called on systems that don't support it.")
+#define HALF_PIC_INIT() error ("half-pic init called on systems that don't support it")
#define HALF_PIC_ADDRESS_P(X) 0
#define HALF_PIC_PTR(X) X
#define HALF_PIC_FINISH(STREAM)
#define MIPS_AS_ASM_SPEC "\
%{!.s:-nocpp} %{.s: %{cpp} %{nocpp}} \
-%{pipe: %e-pipe is not supported.} \
+%{pipe: %e-pipe is not supported} \
%{K} %(subtarget_mips_as_asm_spec)"
/* SUBTARGET_MIPS_AS_ASM_SPEC is passed when using the MIPS assembler
#define SUBTARGET_CPP_SPEC "\
%{!mabi=32: %{!mabi=n32: %{!mabi=64: -D__mips_eabi}}} \
%{!msingle-float:-D__mips_soft_float} \
-%{mhard-float:%e-mhard-float not supported.} \
+%{mhard-float:%e-mhard-float not supported} \
%{msingle-float:%{msoft-float: \
- %e-msingle-float and -msoft-float can not both be specified.}}"
+ %e-msingle-float and -msoft-float can not both be specified}}"
/* The following is needed because -mips3 and -mips4 set gp64 which in
combination with abi=eabi, causes long64 to be set. */
/* by default (if not mips-something-else) produce code for the r3900 */
#define SUBTARGET_CC1_SPEC "\
-%{mhard-float:%e-mhard-float not supported.} \
+%{mhard-float:%e-mhard-float not supported} \
%{msingle-float:%{msoft-float: \
- %e-msingle-float and -msoft-float can not both be specified.}}"
+ %e-msingle-float and -msoft-float can not both be specified}}"
#define MIPS_CPU_STRING_DEFAULT "R3900"
#define MIPS_ISA_DEFAULT 1
swapped registers.) */
if (nregs > MMIX_MAX_REGS_FOR_VALUE)
- internal_error ("Too large function value type, needs %d registers,\
+ internal_error ("too large function value type, needs %d registers,\
have only %d registers for this", nregs, MMIX_MAX_REGS_FOR_VALUE);
/* FIXME: Maybe we should handle structure values like this too
/* Make sure we don't get an unaligned stack. */
if ((stack_space_to_allocate % 8) != 0)
- internal_error ("Stack frame not a multiple of 8 bytes: %d",
+ internal_error ("stack frame not a multiple of 8 bytes: %d",
stack_space_to_allocate);
if (current_function_pretend_args_size)
/* Make sure we don't get an unaligned stack. */
if ((stack_space_to_deallocate % 8) != 0)
- internal_error ("Stack frame not a multiple of octabyte: %d",
+ internal_error ("stack frame not a multiple of octabyte: %d",
stack_space_to_deallocate);
/* We will add back small offsets to the stack pointer as we go.
args_so_farp->now_varargs = 1;
}
else
- internal_error ("Neither varargs or stdarg in mmix_setup_incoming_varargs");
+ internal_error ("neither varargs or stdarg in mmix_setup_incoming_varargs");
/* We assume that one argument takes up one register here. That should
&& INTVAL (*op1p) == 256)
{
/* FIXME: Remove when I know this trigs. */
- fatal_insn ("Oops, not debugged; fixing up value:", *op1p);
+ fatal_insn ("oops, not debugged; fixing up value:", *op1p);
*codep = *codep == LT ? LE : *codep == LTU ? LEU : *codep
== GE ? GT : GTU;
*op1p = GEN_INT (255);
case 'r':
/* Store the register to output a constant to. */
if (! REG_P (x))
- fatal_insn ("MMIX Internal: Expected a register, not this.", x);
+ fatal_insn ("MMIX Internal: Expected a register, not this", x);
mmix_output_destination_register = REGNO (x);
return;
&& (GET_CODE (x) != CONST_DOUBLE
|| (GET_MODE (x) != VOIDmode && GET_MODE (x) != DFmode
&& GET_MODE (x) != SFmode)))
- fatal_insn ("MMIX Internal: Expected a constant, not this.", x);
+ fatal_insn ("MMIX Internal: Expected a constant, not this", x);
mmix_output_register_setting (stream,
mmix_output_destination_register,
mmix_intval (x), 0);
{"no-zero-extend", -TARGET_MASK_ZERO_EXTEND, ""}, \
{"knuthdiv", TARGET_MASK_KNUTH_DIVISION, \
N_("Generate divide results with reminder having the same sign as the\
- divisor (not the dividend).")}, \
+ divisor (not the dividend)")}, \
{"no-knuthdiv", -TARGET_MASK_KNUTH_DIVISION, ""}, \
{"toplevel-symbols", TARGET_MASK_TOPLEVEL_SYMBOLS, \
N_("Prepend global symbols with \":\" (for use with PREFIX)")}, \
#undef STARTFILE_SPEC
#define STARTFILE_SPEC \
"%{!posix*:%{pg:-lgcrt0.o}%{!pg: \
- %{p:%e-p profiling is no longer supported. Use -pg instead.} \
+ %{p:%e-p profiling is no longer supported. Use -pg instead} \
%{!p:-lcrt0.o}}}\
%{posix*:%{pg:-lgposixcrt0.o}%{!pg: \
- %{p:%e-p profiling is no longer supported. Use -pg instead.} \
+ %{p:%e-p profiling is no longer supported. Use -pg instead} \
%{!p:-lposixcrt0.o}}} \
-lcrtbegin.o"
}
else
{
- warning ("Unknown -mschedule= option (%s).\nValid options are 700, 7100, 7100LC, 7200, and 8000\n", pa_cpu_string);
+ warning ("unknown -mschedule= option (%s).\nValid options are 700, 7100, 7100LC, 7200, and 8000\n", pa_cpu_string);
}
/* Set the instruction set architecture. */
}
else if (pa_arch_string)
{
- warning ("Unknown -march= option (%s).\nValid options are 1.0, 1.1, and 2.0\n", pa_arch_string);
+ warning ("unknown -march= option (%s).\nValid options are 1.0, 1.1, and 2.0\n", pa_arch_string);
}
if (flag_pic && TARGET_PORTABLE_RUNTIME)
if (! TARGET_GAS && write_symbols != NO_DEBUG)
{
warning ("-g is only supported when using GAS on this processor,");
- warning ("-g option disabled.");
+ warning ("-g option disabled");
write_symbols = NO_DEBUG;
}
if (TARGET_64BIT && (target_flags & NON_POWERPC_MASKS)) \
{ \
target_flags &= ~NON_POWERPC_MASKS; \
- warning ("-maix64 and POWER architecture are incompatible."); \
+ warning ("-maix64 and POWER architecture are incompatible"); \
} \
if (TARGET_64BIT && ! TARGET_POWERPC64) \
{ \
target_flags |= MASK_POWERPC64; \
- warning ("-maix64 requires PowerPC64 architecture remain enabled."); \
+ warning ("-maix64 requires PowerPC64 architecture remain enabled"); \
} \
if (TARGET_POWERPC64 && ! TARGET_64BIT) \
{ \
- error ("-maix64 required: 64-bit computation with 32-bit addressing not yet supported."); \
+ error ("-maix64 required: 64-bit computation with 32-bit addressing not yet supported"); \
} \
} while (0);
if (TARGET_64BIT && (target_flags & NON_POWERPC_MASKS)) \
{ \
target_flags &= ~NON_POWERPC_MASKS; \
- warning ("-maix64 and POWER architecture are incompatible."); \
+ warning ("-maix64 and POWER architecture are incompatible"); \
} \
if (TARGET_64BIT && ! TARGET_POWERPC64) \
{ \
target_flags |= MASK_POWERPC64; \
- warning ("-maix64 requires PowerPC64 architecture remain enabled."); \
+ warning ("-maix64 requires PowerPC64 architecture remain enabled"); \
} \
if (TARGET_POWERPC64 && ! TARGET_64BIT) \
{ \
- error ("-maix64 required: 64-bit computation with 32-bit addressing not yet supported."); \
+ error ("-maix64 required: 64-bit computation with 32-bit addressing not yet supported"); \
} \
} while (0);
else if (! strcmp (rs6000_debug_name, "arg"))
rs6000_debug_arg = 1;
else
- error ("Unknown -mdebug-%s switch", rs6000_debug_name);
+ error ("unknown -mdebug-%s switch", rs6000_debug_name);
}
/* Set size of long double */
else if (! strcmp (rs6000_abi_string, "altivec"))
rs6000_altivec_abi = 1;
else
- error ("Unknown ABI specified: '%s'", rs6000_abi_string);
+ error ("unknown ABI specified: '%s'", rs6000_abi_string);
}
void
{"no-powerpc64", - MASK_POWERPC64, \
N_("Don't use PowerPC-64 instruction set")}, \
{"altivec", MASK_ALTIVEC , \
- N_("Use AltiVec instructions.")}, \
+ N_("Use AltiVec instructions")}, \
{"no-altivec", - MASK_ALTIVEC , \
- N_("Don't use AltiVec instructions.")}, \
+ N_("Don't use AltiVec instructions")}, \
{"new-mnemonics", MASK_NEW_MNEMONICS, \
N_("Use new mnemonics for PowerPC architecture")},\
{"old-mnemonics", -MASK_NEW_MNEMONICS, \
/* Override rs6000.h definition. */
#undef SUBTARGET_OPTIONS
#define SUBTARGET_OPTIONS \
- { "call-", &rs6000_abi_name, N_("Select ABI calling convention.") }, \
- { "sdata=", &rs6000_sdata_name, N_("Select method for sdata handling.") }
+ { "call-", &rs6000_abi_name, N_("Select ABI calling convention") }, \
+ { "sdata=", &rs6000_sdata_name, N_("Select method for sdata handling") }
/* Max # of bytes for variables to automatically be put into the .sdata
or .sdata2 sections. */
#undef SUBTARGET_SWITCHES
#define SUBTARGET_SWITCHES \
{ "bit-align", -MASK_NO_BITFIELD_TYPE, \
- N_("Align to the base type of the bitfield.") }, \
+ N_("Align to the base type of the bitfield") }, \
{ "no-bit-align", MASK_NO_BITFIELD_TYPE, \
- N_("Don't align to the base type of the bitfield.") }, \
+ N_("Don't align to the base type of the bitfield") }, \
{ "strict-align", MASK_STRICT_ALIGN, \
N_("Don't assume that unaligned accesses are handled by the system") }, \
{ "no-strict-align", -MASK_STRICT_ALIGN, \
N_("Assume that unaligned accesses are handled by the system") }, \
{ "relocatable", MASK_RELOCATABLE | MASK_MINIMAL_TOC | MASK_NO_FP_IN_TOC, \
- N_("Produce code relocatable at runtime.") }, \
+ N_("Produce code relocatable at runtime") }, \
{ "no-relocatable", -MASK_RELOCATABLE, \
- N_("Don't produce code relocatable at runtime.") }, \
+ N_("Don't produce code relocatable at runtime") }, \
{ "relocatable-lib", MASK_RELOCATABLE | MASK_MINIMAL_TOC | MASK_NO_FP_IN_TOC, \
- N_("Produce code relocatable at runtime.") }, \
+ N_("Produce code relocatable at runtime") }, \
{ "no-relocatable-lib", -MASK_RELOCATABLE, \
- N_("Don't produce code relocatable at runtime.") }, \
+ N_("Don't produce code relocatable at runtime") }, \
{ "little-endian", MASK_LITTLE_ENDIAN, \
- N_("Produce little endian code.") }, \
+ N_("Produce little endian code") }, \
{ "little", MASK_LITTLE_ENDIAN, \
- N_("Produce little endian code.") }, \
+ N_("Produce little endian code") }, \
{ "big-endian", -MASK_LITTLE_ENDIAN, \
- N_("Produce big endian code.") }, \
+ N_("Produce big endian code") }, \
{ "big", -MASK_LITTLE_ENDIAN, \
- N_("Produce big endian code.") }, \
+ N_("Produce big endian code") }, \
{ "no-toc", 0, N_("no description yet") }, \
{ "toc", MASK_MINIMAL_TOC, N_("no description yet") }, \
{ "full-toc", MASK_MINIMAL_TOC, N_("no description yet") }, \
{ "prototype", MASK_PROTOTYPE, N_("no description yet") }, \
{ "no-prototype", -MASK_PROTOTYPE, N_("no description yet") }, \
{ "no-traceback", 0, N_("no description yet") }, \
- { "eabi", MASK_EABI, N_("Use EABI.") }, \
- { "no-eabi", -MASK_EABI, N_("Don't use EABI.") }, \
+ { "eabi", MASK_EABI, N_("Use EABI") }, \
+ { "no-eabi", -MASK_EABI, N_("Don't use EABI") }, \
{ "bit-word", -MASK_NO_BITFIELD_WORD, "" }, \
{ "no-bit-word", MASK_NO_BITFIELD_WORD, \
N_("Do not allow bitfields to cross word boundaries") }, \
{ "regnames", MASK_REGNAMES, \
- N_("Use alternate register names.") }, \
+ N_("Use alternate register names") }, \
{ "no-regnames", -MASK_REGNAMES, \
- N_("Don't use alternate register names.") }, \
+ N_("Don't use alternate register names") }, \
{ "sdata", 0, N_("no description yet") }, \
{ "no-sdata", 0, N_("no description yet") }, \
{ "sim", 0, \
- N_("Link with libsim.a, libc.a and sim-crt0.o.") }, \
+ N_("Link with libsim.a, libc.a and sim-crt0.o") }, \
{ "ads", 0, \
- N_("Link with libads.a, libc.a and crt0.o.") }, \
+ N_("Link with libads.a, libc.a and crt0.o") }, \
{ "yellowknife", 0, \
- N_("Link with libyk.a, libc.a and crt0.o.") }, \
+ N_("Link with libyk.a, libc.a and crt0.o") }, \
{ "mvme", 0, \
- N_("Link with libmvme.a, libc.a and crt0.o.") }, \
+ N_("Link with libmvme.a, libc.a and crt0.o") }, \
{ "emb", 0, \
N_("Set the PPC_EMB bit in the ELF flags header") }, \
{ "vxworks", 0, N_("no description yet") }, \
else \
{ \
rs6000_current_abi = ABI_V4; \
- error ("Bad value for -mcall-%s", rs6000_abi_name); \
+ error ("bad value for -mcall-%s", rs6000_abi_name); \
} \
\
if (rs6000_sdata_name) \
else if (!strcmp (rs6000_sdata_name, "eabi")) \
rs6000_sdata = SDATA_EABI; \
else \
- error ("Bad value for -msdata=%s", rs6000_sdata_name); \
+ error ("bad value for -msdata=%s", rs6000_sdata_name); \
} \
else if (DEFAULT_ABI == ABI_V4) \
{ \
(rs6000_sdata == SDATA_EABI || rs6000_sdata == SDATA_SYSV)) \
{ \
rs6000_sdata = SDATA_DATA; \
- error ("-mrelocatable and -msdata=%s are incompatible.", \
+ error ("-mrelocatable and -msdata=%s are incompatible", \
rs6000_sdata_name); \
} \
\
(rs6000_sdata == SDATA_EABI || rs6000_sdata == SDATA_SYSV)) \
{ \
rs6000_sdata = SDATA_DATA; \
- error ("-f%s and -msdata=%s are incompatible.", \
+ error ("-f%s and -msdata=%s are incompatible", \
(flag_pic > 1) ? "PIC" : "pic", \
rs6000_sdata_name); \
} \
if (rs6000_sdata != SDATA_NONE && DEFAULT_ABI != ABI_V4) \
{ \
rs6000_sdata = SDATA_NONE; \
- error ("-msdata=%s and -mcall-%s are incompatible.", \
+ error ("-msdata=%s and -mcall-%s are incompatible", \
rs6000_sdata_name, rs6000_abi_name); \
} \
\
if (TARGET_RELOCATABLE && !TARGET_MINIMAL_TOC) \
{ \
target_flags |= MASK_MINIMAL_TOC; \
- error ("-mrelocatable and -mno-minimal-toc are incompatible."); \
+ error ("-mrelocatable and -mno-minimal-toc are incompatible"); \
} \
\
if (TARGET_RELOCATABLE && rs6000_current_abi == ABI_AIX) \
{ \
target_flags &= ~MASK_RELOCATABLE; \
- error ("-mrelocatable and -mcall-%s are incompatible.", \
+ error ("-mrelocatable and -mcall-%s are incompatible", \
rs6000_abi_name); \
} \
\
if (flag_pic > 1 && rs6000_current_abi == ABI_AIX) \
{ \
flag_pic = 0; \
- error ("-fPIC and -mcall-%s are incompatible.", \
+ error ("-fPIC and -mcall-%s are incompatible", \
rs6000_abi_name); \
} \
\
struct s390_address ad;
if (!s390_decompose_address (addr, &ad, TRUE))
- output_operand_lossage ("Cannot decompose address.\n");
+ output_operand_lossage ("cannot decompose address.\n");
if (ad.disp)
s390_output_symbolic_const (file, ad.disp);
/* Check for too large size of local variables */
if (lsize > 0x7fff0000)
- fatal_error ("Total size of local variables exceeds architecture limit.");
+ fatal_error ("total size of local variables exceeds architecture limit");
/* Profile code (-p, -a, -ax needs some literals). */
if (GET_CODE (x) == CONST_INT)
break;
else if (GET_CODE (x) != REG)
- output_operand_lossage ("Invalid %%Y operand");
+ output_operand_lossage ("invalid %%Y operand");
else if (REGNO (x) < 8)
fputs (reg_names[REGNO (x)], file);
else if (REGNO (x) >= 24 && REGNO (x) < 32)
fputs (reg_names[REGNO (x)-16], file);
else
- output_operand_lossage ("Invalid %%Y operand");
+ output_operand_lossage ("invalid %%Y operand");
return;
case 'L':
/* Print out the low order register name of a register pair. */
case IOR: fputs ("or", file); break;
case AND: fputs ("and", file); break;
case XOR: fputs ("xor", file); break;
- default: output_operand_lossage ("Invalid %%A operand");
+ default: output_operand_lossage ("invalid %%A operand");
}
return;
case IOR: fputs ("orn", file); break;
case AND: fputs ("andn", file); break;
case XOR: fputs ("xnor", file); break;
- default: output_operand_lossage ("Invalid %%B operand");
+ default: output_operand_lossage ("invalid %%B operand");
}
return;
case UNGE: fputs ("uge", file); break;
case UNEQ: fputs ("ue", file); break;
default: output_operand_lossage (code == 'c'
- ? "Invalid %%c operand"
- : "Invalid %%C operand");
+ ? "invalid %%c operand"
+ : "invalid %%C operand");
}
return;
}
case LE: fputs ("lez", file); break;
case GT: fputs ("gz", file); break;
default: output_operand_lossage (code == 'd'
- ? "Invalid %%d operand"
- : "Invalid %%D operand");
+ ? "invalid %%d operand"
+ : "invalid %%D operand");
}
return;
}
case 'f':
/* Operand must be a MEM; write its address. */
if (GET_CODE (x) != MEM)
- output_operand_lossage ("Invalid %%f operand");
+ output_operand_lossage ("invalid %%f operand");
output_address (XEXP (x, 0));
return;
if (current_function_decl == NULL_TREE)
{
- warning ("Cannot set interrupt attribute: no current function");
+ warning ("cannot set interrupt attribute: no current function");
return;
}
if (name == NULL_TREE || TREE_CODE (name) != IDENTIFIER_NODE)
{
- warning ("Cannot set interrupt attribute: no such identifier");
+ warning ("cannot set interrupt attribute: no such identifier");
return;
}
if (small_memory[i].value)
{
if (!ISDIGIT (*small_memory[i].value))
- error ("%s=%s is not numeric.",
+ error ("%s=%s is not numeric",
small_memory[i].name,
small_memory[i].value);
else
{
small_memory[i].max = atoi (small_memory[i].value);
if (small_memory[i].max > small_memory[i].physical_max)
- error ("%s=%s is too large.",
+ error ("%s=%s is too large",
small_memory[i].name,
small_memory[i].value);
}
if (count <= 2)
{
- error ("Bogus JR construction: %d\n", count);
+ error ("bogus JR construction: %d\n", count);
return NULL;
}
/* Make sure that the amount we are popping either 0 or 16 bytes. */
if (stack_bytes != 0 && stack_bytes != 16)
{
- error ("Bad amount of stack space removal: %d", stack_bytes);
+ error ("bad amount of stack space removal: %d", stack_bytes);
return NULL;
}
if (count <= 2)
{
- error ("Bogus JARL construction: %d\n", count);
+ error ("bogus JARL construction: %d\n", count);
return NULL;
}
/* Make sure that the amount we are popping either 0 or 16 bytes. */
if (stack_bytes != 0 && stack_bytes != -16)
{
- error ("Bad amount of stack space removal: %d", stack_bytes);
+ error ("bad amount of stack space removal: %d", stack_bytes);
return NULL;
}
+2001-12-03 Neil Booth <neil@daikokuya.demon.co.uk>
+
+ * typeck2.c: Remove leading capital from diagnostic messages, as
+ per GNU coding standards.
+
2001-12-03 Mumit Khan <khan@nanotech.wisc.edu>
PR c++/3394
cp_warning ("friend declaration `%#D' declares a non-template function", decl);
if (! explained)
{
- warning ("(if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning.");
+ warning ("(if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning");
explained = 1;
}
}
{ "-ftemplate-depth-",
N_("Specify maximum template instantiation depth") },
{ "-fuse-cxa-atexit",
- N_("Use __cxa_atexit to register destructors.") },
+ N_("Use __cxa_atexit to register destructors") },
{ "-fno-use-cxa-atexit", "" },
{ "-fvtable-gc",
N_("Discard unused virtual functions") },
/* Say nothing. */;
else if (where > 0)
{
- error ("Internal error #%d", where);
+ error ("internal error #%d", where);
/* Uncount this error, so internal_error will do the right thing. */
--errorcount;
if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
{
if (! TREE_CONSTANT (value) || ! TREE_STATIC (value))
- pedwarn ("ANSI C++ forbids non-constant aggregate initializer expressions");
+ pedwarn ("ISO C++ forbids non-constant aggregate initializer expressions");
}
}
#endif
/* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
I.e. a const string initializer with parens around it. That is
what N_("string") resolves to, so we make no_* be macros instead. */
-#define no_arg N_("Argument missing after %s")
-#define no_ass N_("Assertion missing after %s")
-#define no_dir N_("Directory name missing after %s")
-#define no_fil N_("File name missing after %s")
-#define no_mac N_("Macro name missing after %s")
-#define no_pth N_("Path name missing after %s")
-#define no_num N_("Number missing after %s")
-#define no_tgt N_("Target missing after %s")
+#define no_arg N_("argument missing after %s")
+#define no_ass N_("assertion missing after %s")
+#define no_dir N_("directory name missing after %s")
+#define no_fil N_("file name missing after %s")
+#define no_mac N_("macro name missing after %s")
+#define no_pth N_("path name missing after %s")
+#define no_num N_("number missing after %s")
+#define no_tgt N_("target missing after %s")
/* This is the list of all command line options, with the leading
"-" removed. It must be sorted in ASCII collating order. */
else if (CPP_OPTION (pfile, out_fname) == NULL)
CPP_OPTION (pfile, out_fname) = argv[i];
else
- cpp_fatal (pfile, "Too many filenames. Type %s --help for usage info",
+ cpp_fatal (pfile, "too many filenames. Type %s --help for usage info",
progname);
}
else
&& REG_P (x)
&& REGNO (x) < FIRST_PSEUDO_REGISTER)
internal_error
- ("Can't access real part of complex value in hard register");
+ ("can't access real part of complex value in hard register");
else if (WORDS_BIG_ENDIAN)
return gen_highpart (mode, x);
else
+Mon Dec 3 18:56:04 2001 Neil Booth <neil@daikokuya.demon.co.uk>
+
+ * com.c: Remove leading capital from diagnostic messages, as
+ per GNU coding standards.
+ * g77spec.c: Similarly.
+ * lex.c: Similarly.
+
2001-12-01 Zack Weinberg <zack@codesourcery.com>
* f/fini.c: Use xmalloc.
(int) FLOAT_TYPE_SIZE);
warning ("and pointers are %d bits wide, but g77 doesn't yet work",
(int) TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (null_pointer_node))));
- warning ("properly unless they all are 32 bits wide.");
+ warning ("properly unless they all are 32 bits wide");
warning ("Please keep this in mind before you report bugs. g77 should");
- warning ("support non-32-bit machines better as of version 0.6.");
+ warning ("support non-32-bit machines better as of version 0.6");
}
#endif
dirtmp->fname = spec;
dirtmp->got_name_map = 0;
if (spec[0] == 0)
- error ("Directory name must immediately follow -I");
+ error ("directory name must immediately follow -I");
else
append_include_chain (dirtmp, dirtmp);
}
}
if ((n_outfiles != 0) && (n_infiles == 0))
- fatal ("No input files; unwilling to write output files");
+ fatal ("no input files; unwilling to write output files");
/* If there are no input files, no need for the library. */
if (n_infiles == 0)
m[0] = c;
m[1] = '\0';
- ffebad_start_msg_lex ("Non-ANSI-C-standard escape sequence `\\%A' at %0",
+ ffebad_start_msg_lex ("Non-ISO-C-standard escape sequence `\\%A' at %0",
FFEBAD_severityPEDANTIC);
ffelex_bad_here_ (0, line, column);
ffebad_string (m);
/* `\%' is used to prevent SCCS from getting confused. */
case '%':
if (pedantic)
- pedwarn ("non-ANSI escape sequence `\\%c'", c);
+ pedwarn ("non-ISO escape sequence `\\%c'", c);
return c;
}
if (c >= 040 && c < 0177)
case EOF:
case '\n':
- error ("Badly formed directive -- no closing quote");
+ error ("badly formed directive -- no closing quote");
done = TRUE;
break;
|| c == EOF)
{
if (looking_for != 0)
- error ("Bad directive -- missing close-quote");
+ error ("bad directive -- missing close-quote");
*p++ = '\0';
*text = directive_buffer;
{
lineno = 1;
input_filename = old_input_filename;
- error ("Use `#line ...' instead of `# ...' in first line");
+ error ("use `#line ...' instead of `# ...' in first line");
}
if (num == 1)
{
lineno = 1;
input_filename = old_input_filename;
- error ("Use `#line ...' instead of `# ...' in first line");
+ error ("use `#line ...' instead of `# ...' in first line");
}
if (c == '\n' || c == EOF)
{
#ifdef ADJUST_INSN_LENGTH
ADJUST_INSN_LENGTH (insn, insn_lengths[uid]);
if (insn_lengths[uid] < 0)
- fatal_insn ("Negative insn length", insn);
+ fatal_insn ("negative insn length", insn);
#endif
}
/* If we didn't split the insn, go away. */
if (new == insn && PATTERN (new) == body)
- fatal_insn ("Could not split insn", insn);
+ fatal_insn ("could not split insn", insn);
#ifdef HAVE_ATTR_length
/* This instruction should have been split in shorten_branches,
%(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)", 0},
{".h", "@c-header", 0},
{"@c-header",
- "%{!E:%eCompilation of header file requested} \
+ "%{!E:%ecompilation of header file requested} \
%(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)", 0},
{".i", "@cpp-output", 0},
{"@cpp-output",
if (new_filename)
read_specs (new_filename, FALSE);
else if (verbose_flag)
- notice ("Could not find specs file %s\n", p1);
+ notice ("could not find specs file %s\n", p1);
continue;
}
else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
}
if (n_infiles == last_language_n_infiles && spec_lang != 0)
- error ("Warning: `-x %s' after last input file has no effect", spec_lang);
+ error ("warning: `-x %s' after last input file has no effect", spec_lang);
switches[n_switches].part1 = 0;
infiles[n_infiles].name = 0;
switch (c = *p++)
{
case 0:
- fatal ("Invalid specification! Bug in cc");
+ fatal ("invalid specification! Bug in cc");
case 'b':
obstack_grow (&obstack, input_basename, basename_length);
void
fancy_abort ()
{
- fatal ("internal gcc abort.");
+ fatal ("internal gcc abort");
}
\f
/* Output an error message and exit */
+2001-12-03 Neil Booth <neil@daikokuya.demon.co.uk>
+
+ * expr.c: Remove leading capital from diagnostic messages, as
+ per GNU coding standards.
+ * jcf-io.c: Similarly.
+ * jcf-parse.c: Similarly.
+ * jv-scan.c: Similarly.
+ * jvspec.c: Similarly.
+ * mangle.c: Similarly.
+
2001-12-02 Tang Ching-Hui <nicholas@cs.nthu.edu.tw>
Alexandre Petit-Bianco <apbianco@redhat.com>
method_name, method_signature);
if (method == NULL_TREE)
{
- error ("Class '%s' has no method named '%s' matching signature '%s'",
+ error ("class '%s' has no method named '%s' matching signature '%s'",
self_name,
IDENTIFIER_POINTER (method_name),
IDENTIFIER_POINTER (method_signature));
}
else if (field_decl == NULL_TREE)
{
- error ("Missing field '%s' in '%s'",
+ error ("missing field '%s' in '%s'",
IDENTIFIER_POINTER (field_name), self_name);
is_error = 1;
}
else if (build_java_signature (TREE_TYPE (field_decl)) != field_signature)
{
- error ("Mismatching signature for field '%s' in '%s'",
+ error ("mismatching signature for field '%s' in '%s'",
IDENTIFIER_POINTER (field_name), self_name);
is_error = 1;
}
target, tmode, modifier);
default:
- internal_error ("Can't expand %s", tree_code_name [TREE_CODE (exp)]);
+ internal_error ("can't expand %s", tree_code_name [TREE_CODE (exp)]);
}
}
if (dead_code_index != -1)
{
/* We've just reached the end of a region of dead code. */
- warning ("Unreachable bytecode from %d to before %d",
+ warning ("unreachable bytecode from %d to before %d",
dead_code_index, PC);
dead_code_index = -1;
}
if (dead_code_index != -1)
{
/* We've just reached the end of a region of dead code. */
- warning ("Unreachable bytecode from %d to the end of the method",
+ warning ("unreachable bytecode from %d to the end of the method",
dead_code_index);
}
}
if (! java && ! class && java_buf.st_mtime > class_buf.st_mtime)
{
if (flag_newer)
- warning ("Source file for class `%s' is newer than its matching class file. Source file `%s' used instead", classname, java_buffer);
+ warning ("source file for class `%s' is newer than its matching class file. Source file `%s' used instead", classname, java_buffer);
class = -1;
}
}
if (!class_loaded && verbose)
- error ("Cannot find file for class %s", IDENTIFIER_POINTER (saved));
+ error ("cannot find file for class %s", IDENTIFIER_POINTER (saved));
}
/* Parse the .class file JCF. */
-fforce-classes-archive-check was specified. */
if (!jcf->right_zip
&& (!flag_emit_class_files || flag_force_classes_archive_check))
- fatal_error ("The `java.lang.Object' that was found in `%s' didn't have the special zero-length `gnu.gcj.gcj-compiled' attribute. This generally means that your classpath is incorrectly set. Use `info gcj \"Input Options\"' to see the info page describing how to set the classpath.", jcf->filename);
+ fatal_error ("the `java.lang.Object' that was found in `%s' didn't have the special zero-length `gnu.gcj.gcj-compiled' attribute. This generally means that your classpath is incorrectly set. Use `info gcj \"Input Options\"' to see the info page describing how to set the classpath", jcf->filename);
}
else
all_class_list = tree_cons (NULL_TREE,
{
const char *saved_input_filename = input_filename;
input_filename = value;
- warning ("source file seen twice on command line and will be compiled only once.");
+ warning ("source file seen twice on command line and will be compiled only once");
input_filename = saved_input_filename;
}
else
/* Check on bad usage */
if (flag_find_main + flag_dump_class + flag_complexity > 1)
fatal_error
- ("Only one of `--print-main', `--list-class', and `--complexity' allowed");
+ ("only one of `--print-main', `--list-class', and `--complexity' allowed");
if (output_file && !(out = fopen (output_file, "w")))
- fatal_error ("Can't open output file `%s'", output_file);
+ fatal_error ("can't open output file `%s'", output_file);
ft = ftell (out);
reset_report ();
}
else
- fatal_error ("File not found `%s'", argv [i]);
+ fatal_error ("file not found `%s'", argv [i]);
}
/* Flush and close */
num_args += 3;
if (class_files_count + zip_files_count > 0)
{
- error ("Warning: already-compiled .class files ignored with -C");
+ error ("warning: already-compiled .class files ignored with -C");
num_args -= class_files_count + zip_files_count;
class_files_count = 0;
zip_files_count = 0;
}
if (enc_error)
- fatal_error ("unknown encoding: `%s'\nThis might mean that your locale's encoding is not supported\nby your system's iconv(3) implementation. If you aren't trying\nto use a particular encoding for your input file, try the\n`--encoding=UTF-8' option.", encoding);
+ fatal_error ("unknown encoding: `%s'\nThis might mean that your locale's encoding is not supported\nby your system's iconv(3) implementation. If you aren't trying\nto use a particular encoding for your input file, try the\n`--encoding=UTF-8' option", encoding);
return lex;
}
mangle_method_decl (decl);
break;
default:
- internal_error ("Can't mangle %s", tree_code_name [TREE_CODE (decl)]);
+ internal_error ("can't mangle %s", tree_code_name [TREE_CODE (decl)]);
}
return finish_mangling ();
}
static int first = 1;
if (first)
{
- error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives.", package_name);
+ error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
java_error_count++;
first = 0;
}
(TREE_CODE (op2) == INTEGER_CST &&
! TREE_INT_CST_LOW (op2) && ! TREE_INT_CST_HIGH (op2))))
{
- parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown.");
+ parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
TREE_CONSTANT (node) = 0;
}
} else if (print_deps
&& print_deps <= (system_header_p
|| (system_include_depth > 0)))
- warning ("No include path in which to find %.*s", flen, fbeg);
+ warning ("no include path in which to find %.*s", flen, fbeg);
else
error_from_errno (fname);
projects / thirdparty / gcc.git / commitdiff
