* cgraph.c: Spelling fixes - behaviour -> behavior and
neighbour -> neighbor.
* target.def: Likewise.
* sel-sched.c: Likewise.
* config/mips/mips.c: Likewise.
* config/arc/arc.md: Likewise.
* config/arm/cortex-a57.md: Likewise.
* config/arm/arm.c: Likewise.
* config/arm/neon.md: Likewise.
* config/arm/arm-c.c: Likewise.
* config/vms/vms-c.c: Likewise.
* config/s390/s390.c: Likewise.
* config/i386/znver1.md: Likewise.
* config/i386/i386.c: Likewise.
* config/ia64/hpux-unix2003.h: Likewise.
* config/msp430/msp430.md: Likewise.
* config/rx/rx.c: Likewise.
* config/rx/rx.md: Likewise.
* config/aarch64/aarch64-simd.md: Likewise.
* config/aarch64/aarch64.c: Likewise.
* config/nvptx/nvptx.c: Likewise.
* config/bfin/bfin.c: Likewise.
* config/cris/cris.opt: Likewise.
* config/rs6000/rs6000.c: Likewise.
* target.h: Likewise.
* spellcheck.c: Likewise.
* ira-build.c: Likewise.
* tree-inline.c: Likewise.
* builtins.c: Likewise.
* lra-constraints.c: Likewise.
* explow.c: Likewise.
* hwint.h: Likewise.
* targhooks.c: Likewise.
* tree-vect-data-refs.c: Likewise.
* expr.c: Likewise.
* doc/tm.texi: Likewise.
* doc/extend.texi: Likewise.
* doc/install.texi: Likewise.
* doc/md.texi: Likewise.
* tree-ssa-tail-merge.c: Likewise.
* sched-int.h: Likewise.
* match.pd: Likewise.
* sched-ebb.c: Likewise.
* target.def (omit_struct_return_reg): Likewise.
* gimple-ssa-isolate-paths.c: Likewise.
(find_implicit_erroneous_behaviour): Renamed to...
(find_implicit_erroneous_behavior): ... this.
(find_explicit_erroneous_behaviour): Renamed to...
(find_explicit_erroneous_behavior): ... this.
(gimple_ssa_isolate_erroneous_paths): Adjust caller.
gcc/cp/
* error.c: Spelling fixes - behaviour -> behavior and
neighbour -> neighbor.
* decl.c: Likewise.
* typeck.c (cp_build_binary_op): Fix up behavior spelling in
diagnostics.
* init.c (build_delete): Likewise.
gcc/objc/
* objc-act.c: Spelling fixes - behaviour -> behavior and
neighbour -> neighbor.
* objc-map.h: Likewise.
gcc/go/
* gofrontend/lex.cc: Spelling fixes - behaviour -> behavior and
neighbour -> neighbor.
* gccgo.texi: Likewise.
gcc/ada/
* prj-tree.ads: Spelling fixes - behaviour -> behavior and
neighbour -> neighbor.
* prep.adb: Likewise.
* prj.ads: Likewise.
* prepcomp.adb: Likewise.
* g-socket.ads: Likewise.
* s-imgrea.adb: Likewise.
* a-calend.adb: Likewise.
* exp_disp.adb: Likewise.
* doc/gnat_ugn/gnat_utility_programs.rst: Likewise.
* g-socket.adb: Likewise.
* sem_ch12.adb: Likewise.
* terminals.c: Likewise.
gcc/testsuite/
* objc.dg/gnu-api-2-method.m: Spelling fixes - behaviour -> behavior
and neighbour -> neighbor.
* objc.dg/attributes/method-nonnull-1.m: Likewise.
* objc.dg/gnu-api-2-class-meta.m: Likewise.
* c-c++-common/Wvarargs.c: Likewise.
* c-c++-common/goacc/host_data-5.c: Likewise.
* obj-c++.dg/gnu-api-2-class-meta.mm: Likewise.
* obj-c++.dg/attributes/method-nonnull-1.mm: Likewise.
* obj-c++.dg/gnu-api-2-method.mm: Likewise.
* gcc.target/aarch64/pr60697.c: Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vldX_lane.c: Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vqshl.c: Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vshuffle.inc: Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vrshl.c: Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vldX_dup.c: Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vstX_lane.c: Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vqrshl.c: Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vldX.c: Likewise.
* gcc.target/aarch64/aapcs64/ice_2.c: Likewise.
* gcc.target/aarch64/aapcs64/test_23.c: Likewise.
* gcc.target/aarch64/vrnd_f64_1.c: Likewise.
* g++.dg/warn/Wconversion-real-integer-3.C: Likewise.
* g++.dg/lookup/koenig5.C: Likewise.
* g++.dg/ext/no-asm-2.C: Likewise.
* gfortran.dg/bounds_check_array_ctor_3.f90: Likewise.
* gfortran.dg/bounds_check_array_ctor_7.f90: Likewise.
* gfortran.dg/used_types_16.f90: Likewise.
* gfortran.dg/assumed_rank_bounds_1.f90: Likewise.
* gfortran.dg/bounds_check_array_ctor_1.f90: Likewise.
* gfortran.dg/assumed_rank_bounds_2.f90: Likewise.
* gfortran.dg/bounds_check_array_ctor_4.f90: Likewise.
* gfortran.dg/abstract_type_6.f03: Likewise.
* gfortran.dg/bounds_check_array_ctor_5.f90: Likewise.
* gfortran.dg/used_types_15.f90: Likewise.
* gfortran.dg/bounds_check_array_ctor_8.f90: Likewise.
* gfortran.dg/exit_3.f08: Likewise.
* gfortran.dg/open_status_2.f90: Likewise.
* gfortran.dg/derived_pointer_recursion_2.f90: Likewise.
* gfortran.dg/intrinsic_std_1.f90: Likewise.
* gfortran.dg/associate_1.f03: Likewise.
* gfortran.dg/bounds_check_array_ctor_2.f90: Likewise.
* gfortran.dg/intrinsic_std_6.f90: Likewise.
* gfortran.dg/bounds_check_array_ctor_6.f90: Likewise.
* gcc.dg/builtin-object-size-1.c: Likewise.
* gcc.dg/noreturn-6.c: Likewise.
* gcc.dg/builtin-stringop-chk-1.c: Likewise.
* gcc.dg/globalalias.c: Likewise.
* gcc.dg/builtins-config.h: Likewise.
* gcc.dg/pr30457.c: Likewise.
* gcc.c-torture/compile/volatile-1.c: Likewise.
* gcc.c-torture/execute/
20101011-1.c: Likewise.
* c-c++-common/Waddress-1.c: Likewise.
From-SVN: r233358
+2016-02-12 Jakub Jelinek <jakub@redhat.com>
+
+ * cgraph.c: Spelling fixes - behaviour -> behavior and
+ neighbour -> neighbor.
+ * target.def: Likewise.
+ * sel-sched.c: Likewise.
+ * config/mips/mips.c: Likewise.
+ * config/arc/arc.md: Likewise.
+ * config/arm/cortex-a57.md: Likewise.
+ * config/arm/arm.c: Likewise.
+ * config/arm/neon.md: Likewise.
+ * config/arm/arm-c.c: Likewise.
+ * config/vms/vms-c.c: Likewise.
+ * config/s390/s390.c: Likewise.
+ * config/i386/znver1.md: Likewise.
+ * config/i386/i386.c: Likewise.
+ * config/ia64/hpux-unix2003.h: Likewise.
+ * config/msp430/msp430.md: Likewise.
+ * config/rx/rx.c: Likewise.
+ * config/rx/rx.md: Likewise.
+ * config/aarch64/aarch64-simd.md: Likewise.
+ * config/aarch64/aarch64.c: Likewise.
+ * config/nvptx/nvptx.c: Likewise.
+ * config/bfin/bfin.c: Likewise.
+ * config/cris/cris.opt: Likewise.
+ * config/rs6000/rs6000.c: Likewise.
+ * target.h: Likewise.
+ * spellcheck.c: Likewise.
+ * ira-build.c: Likewise.
+ * tree-inline.c: Likewise.
+ * builtins.c: Likewise.
+ * lra-constraints.c: Likewise.
+ * explow.c: Likewise.
+ * hwint.h: Likewise.
+ * targhooks.c: Likewise.
+ * tree-vect-data-refs.c: Likewise.
+ * expr.c: Likewise.
+ * doc/tm.texi: Likewise.
+ * doc/extend.texi: Likewise.
+ * doc/install.texi: Likewise.
+ * doc/md.texi: Likewise.
+ * tree-ssa-tail-merge.c: Likewise.
+ * sched-int.h: Likewise.
+ * match.pd: Likewise.
+ * sched-ebb.c: Likewise.
+ * target.def (omit_struct_return_reg): Likewise.
+ * gimple-ssa-isolate-paths.c: Likewise.
+ (find_implicit_erroneous_behaviour): Renamed to...
+ (find_implicit_erroneous_behavior): ... this.
+ (find_explicit_erroneous_behaviour): Renamed to...
+ (find_explicit_erroneous_behavior): ... this.
+ (gimple_ssa_isolate_erroneous_paths): Adjust caller.
+
2016-02-11 Segher Boessenkool <segher@kernel.crashing.org>
PR rtl-optimization/64682
+2016-02-12 Jakub Jelinek <jakub@redhat.com>
+
+ * prj-tree.ads: Spelling fixes - behaviour -> behavior and
+ neighbour -> neighbor.
+ * prep.adb: Likewise.
+ * prj.ads: Likewise.
+ * prepcomp.adb: Likewise.
+ * g-socket.ads: Likewise.
+ * s-imgrea.adb: Likewise.
+ * a-calend.adb: Likewise.
+ * exp_disp.adb: Likewise.
+ * doc/gnat_ugn/gnat_utility_programs.rst: Likewise.
+ * g-socket.adb: Likewise.
+ * sem_ch12.adb: Likewise.
+ * terminals.c: Likewise.
+
2016-02-08 Bernd Schmidt <bschmidt@redhat.com>
* gcc-interface/misc.c (gnat_init): Remove second argument in call to
-- procedure Split (9 or 10 parameters) -+
-- end Ada.Calendar.Formatting
- -- The behaviour of the interfacing routines is controlled via various
+ -- The behavior of the interfacing routines is controlled via various
-- flags. All new Ada 2005 types from children of Ada.Calendar are
-- emulated by a similar type. For instance, type Day_Number is replaced
-- by Integer in various routines. One ramification of this model is that
``--additional-tests`` switch.
* ``Skeletons_Default``
- is used to specify the default behaviour of test skeletons, otherwise
+ is used to specify the default behavior of test skeletons, otherwise
specified by ``--skeleton-default`` option. The value of this attribute
should be either ``pass`` or ``fail``.
-- F := not Cancelled (Bnn);
-- where F is the success flag. The status of Cancelled is negated
- -- in order to match the behaviour of the version for task types.
+ -- in order to match the behavior of the version for task types.
Append_To (Stmts,
Make_Assignment_Statement (Loc,
return;
-- On other platforms, fd_set is an FD_SETSIZE bitmap: check
- -- that Fd is within range (otherwise behaviour is undefined).
+ -- that Fd is within range (otherwise behavior is undefined).
elsif Fd < 0 or else Fd >= SOSC.FD_SETSIZE then
raise Constraint_Error
-- blocks until an event occurs. On some platforms, the select(2) system
-- can block the full process (not just the calling thread).
--
- -- Check_Selector provides the very same behaviour. The only difference is
+ -- Check_Selector provides the very same behavior. The only difference is
-- that it does not watch for exception events. Note that on some platforms
-- it is kept process blocking on purpose. The timeout parameter allows the
- -- user to have the behaviour he wants. Abort_Selector allows the safe
+ -- user to have the behavior he wants. Abort_Selector allows the safe
-- abort of a blocked Check_Selector call. A special socket is opened by
-- Create_Selector and included in each call to Check_Selector.
--
String_False : String_Id;
-- "false", as a string_id
- ---------------
- -- Behaviour --
- ---------------
+ --------------
+ -- Behavior --
+ --------------
-- Accesses to procedure specified by procedure Initialize
Scn.Scanner.Initialize_Scanner (Deffile);
Prep.Parse_Def_File;
- -- Reset the behaviour of the scanner to the default
+ -- Reset the behavior of the scanner to the default
Scn.Scanner.Set_End_Of_Line_As_Token (False);
-- For each function the condition of validity is specified. If an access
-- function is called with invalid arguments, then exception
-- Assertion_Error is raised if assertions are enabled, otherwise the
- -- behaviour is not defined and may result in a crash.
+ -- behavior is not defined and may result in a crash.
function Name_Of
(Node : Project_Node_Id;
-- Foe each Set_* procedure the condition of validity is specified. If an
-- access function is called with invalid arguments, then exception
-- Assertion_Error is raised if assertions are enabled, otherwise the
- -- behaviour is not defined and may result in a crash.
+ -- behavior is not defined and may result in a crash.
-- These are very low-level, and manipulate the tree itself directly. You
-- should look at the Create_* procedure instead if you want to use higher
-- Severity of some situations, such as: no Ada sources in a project where
-- Ada is one of the language.
--
- -- When the situation occurs, the behaviour depends on the setting:
+ -- When the situation occurs, the behavior depends on the setting:
--
-- - Silent: no action
-- - Warning: issue a warning, does not cause the tool to fail
-- an invalid bit pattern resulting from erroneous execution
-- (caused by using uninitialized variables for example).
- -- No matter what, we'll at least get reasonable behaviour,
+ -- No matter what, we'll at least get reasonable behavior,
-- converting to infinity or some other value, or causing an
-- exception to be raised is fine.
end if;
-- At this point either both nodes came from source or we approximated
- -- their source locations through neighbouring source statements.
+ -- their source locations through neighboring source statements.
T1 := Top_Level_Location (Sloc (P1));
T2 := Top_Level_Location (Sloc (P2));
/* Control whether spawnve quotes arguments as necessary to ensure
correct parsing by child process. Because not all uses of spawnve
- are careful about constructing argv arrays, we make this behaviour
+ are careful about constructing argv arrays, we make this behavior
conditional (off by default, since a similar operation is already done
in g-expect.adb by calling Normalize_Argument). */
static int Vw32_quote_process_args = 0;
{
warning_at (current_location,
OPT_Wvarargs,
- "undefined behaviour when second parameter of "
+ "undefined behavior when second parameter of "
"%<va_start%> is declared with %<register%> storage");
}
avail = AVAIL_AVAILABLE;
/* Inline functions are safe to be analyzed even if their symbol can
be overwritten at runtime. It is not meaningful to enforce any sane
- behaviour on replacing inline function by different body. */
+ behavior on replacing inline function by different body. */
else if (DECL_DECLARED_INLINE_P (decl))
avail = AVAIL_AVAILABLE;
node = node->ultimate_alias_target ();
/* Optimizers can redirect unreachable calls or calls triggering undefined
- behaviour to builtin_unreachable. */
+ behavior to builtin_unreachable. */
if (DECL_BUILT_IN_CLASS (callee->decl) == BUILT_IN_NORMAL
&& DECL_FUNCTION_CODE (callee->decl) == BUILT_IN_UNREACHABLE)
return false;
;; the lower architectural lanes of the vector, for these patterns we want
;; to always treat "hi" as referring to the higher architectural lanes.
;; Consequently, while the patterns below look inconsistent with our
-;; other big-endian patterns their behaviour is as required.
+;; other big-endian patterns their behavior is as required.
(define_expand "vec_unpacks_lo_<mode>"
[(match_operand:<VWIDE> 0 "register_operand" "")
/* All the information needed to handle a target attribute.
NAME is the name of the attribute.
- ATTR_TYPE specifies the type of behaviour of the attribute as described
+ ATTR_TYPE specifies the type of behavior of the attribute as described
in the definition of enum aarch64_attr_opt_type.
ALLOW_NEG is true if the attribute supports a "no-" form.
HANDLER is the function that takes the attribute string and whether
it is a pragma or attribute and handles the option. It is needed only
when the ATTR_TYPE is aarch64_attr_custom.
OPT_NUM is the enum specifying the option that the attribute modifies.
- This is needed for attributes that mirror the behaviour of a command-line
+ This is needed for attributes that mirror the behavior of a command-line
option, that is it has ATTR_TYPE aarch64_attr_mask, aarch64_attr_bool or
aarch64_attr_enum. */
;; Comment in final.c (insn_current_reference_address) says
;; forward branch addresses are calculated from the next insn after branch
;; and for backward branches, it is calculated from the branch insn start.
- ;; The shortening logic here is tuned to accomodate this behaviour
+ ;; The shortening logic here is tuned to accomodate this behavior
;; ??? This should be grokked by the ccfsm machinery.
(define_insn "cbranchsi4_scratch"
[(set (pc)
if (arm_arch_iwmmxt2)
builtin_define ("__IWMMXT2__");
/* ARMv6KZ was originally identified as the misspelled __ARM_ARCH_6ZK__. To
- preserve the existing behaviour, the misspelled feature macro must still be
+ preserve the existing behavior, the misspelled feature macro must still be
defined. */
if (arm_arch6kz)
builtin_define ("__ARM_ARCH_6ZK__");
shift-by-register would give. This helps reduce execution
differences between optimization levels, but it won't stop other
parts of the compiler doing different things. This is "undefined
- behaviour, in any case. */
+ behavior, in any case. */
if (INTVAL (amount) <= 0)
emit_insn (gen_movdi (out, in));
else if (INTVAL (amount) >= 64)
"ca57_mx")
;; All multiplies
-;; TODO: AArch32 and AArch64 have different behaviour
+;; TODO: AArch32 and AArch64 have different behavior
(define_insn_reservation "cortex_a57_mult32" 3
(and (eq_attr "tune" "cortexa57")
(ior (eq_attr "mul32" "yes")
; particular, denormal values are flushed to zero. This means that GCC cannot
; use those instructions for autovectorization, etc. unless
; -funsafe-math-optimizations is in effect (in which case flush-to-zero
-; behaviour is permissible). Intrinsic operations (provided by the arm_neon.h
+; behavior is permissible). Intrinsic operations (provided by the arm_neon.h
; header) must work in either case: if -funsafe-math-optimizations is given,
; intrinsics expand to "canonical" RTL where possible, otherwise intrinsics
; expand to unspecs (which may potentially limit the extent to which they might
}
\f
/* On some silicon revisions, functions shorter than a certain number of cycles
- can cause unpredictable behaviour. Work around this by adding NOPs as
+ can cause unpredictable behavior. Work around this by adding NOPs as
needed. */
static void
workaround_rts_anomaly (void)
; TARGET_MUL_BUG: Whether or not to work around multiplication
; instruction hardware bug when generating code for models where
; it may be present. From the trouble report for Etrax 100 LX:
-; "A multiply operation may cause incorrect cache behaviour
+; "A multiply operation may cause incorrect cache behavior
; under some specific circumstances. The problem can occur if
; the instruction following the multiply instruction causes a
; cache miss, and multiply operand 1 (source operand) bits
/* Search backward for non-agu definition of register number REGNO1
or register number REGNO2 in INSN's basic block until
1. Pass LEA_SEARCH_THRESHOLD instructions, or
- 2. Reach neighbour BBs boundary, or
+ 2. Reach neighbor BBs boundary, or
3. Reach agu definition.
Returns the distance between the non-agu definition point and INSN.
If no definition point, returns -1. */
;; Direct instructions can be issued to any of the four decoders.
(define_reservation "znver1-direct" "znver1-decode0|znver1-decode1|znver1-decode2|znver1-decode3")
-;; Fix me: Need to revisit this later to simulate fast path double behaviour.
+;; Fix me: Need to revisit this later to simulate fast path double behavior.
(define_reservation "znver1-double" "znver1-direct")
/* For HP-UX 11.31 and greater, use unix2003.o instead of unix98.o to
- get correct C99 snprintf behaviour with buffer overflow. */
+ get correct C99 snprintf behavior with buffer overflow. */
#undef STARTFILE_SPEC
#define STARTFILE_SPEC "%{!shared:%{static:crt0%O%s} \
/* When using branch likely (-mfix-r10000), the delay slot instruction
will be annulled on false. The normal delay slot instructions
calculate the overall result of the atomic operation and must not
- be annulled. To ensure this behaviour unconditionally use a NOP
+ be annulled. To ensure this behavior unconditionally use a NOP
in the delay slot for the branch likely case. */
if (TARGET_CB_MAYBE)
}
/* Implement TARGET_SHIFT_TRUNCATION_MASK. We want to keep the default
- behaviour of TARGET_SHIFT_TRUNCATION_MASK for non-vector modes even
+ behavior of TARGET_SHIFT_TRUNCATION_MASK for non-vector modes even
when TARGET_LOONGSON_VECTORS is true. */
static unsigned HOST_WIDE_INT
;;
;; Note - we ignore shift counts of less than one or more than 15.
;; This is permitted by the ISO C99 standard as such shifts result
-;; in "undefined" behaviour. [6.5.7 (3)]
+;; in "undefined" behavior. [6.5.7 (3)]
;; signed A << C
is true, if this is a prototyped function, rather than an old-style
C declaration. Returns the next argument number to use.
- The promotion behaviour here must match the regular GCC function
+ The promotion behavior here must match the regular GCC function
parameter marshalling machinery. */
static int
/* Process a function return TYPE to emit a PTX return as a prototype
or function prologue declaration. Returns true if return is via an
- additional pointer parameter. The promotion behaviour here must
+ additional pointer parameter. The promotion behavior here must
match the regular GCC function return mashalling. */
static bool
elt_size &= -elt_size; /* Extract LSB set. */
init_frag.size = elt_size;
- /* Avoid undefined shift behaviour by using '2'. */
+ /* Avoid undefined shift behavior by using '2'. */
init_frag.mask = ((unsigned HOST_WIDE_INT)2
<< (elt_size * BITS_PER_UNIT - 1)) - 1;
init_frag.val = 0;
because code emitted by gcc for a (non-pointer) function call
doesn't save and restore R2. Instead, R2 is managed out-of-line
by a linker generated plt call stub when the function resides in
- a shared library. This behaviour is costly to describe in DWARF,
+ a shared library. This behavior is costly to describe in DWARF,
both in terms of the size of DWARF info and the time taken in the
unwinder to interpret it. R2 changes, apart from the
calls_eh_return case earlier in this function, are handled by
static bool
rx_is_ms_bitfield_layout (const_tree record_type ATTRIBUTE_UNUSED)
{
- /* The packed attribute overrides the MS behaviour. */
+ /* The packed attribute overrides the MS behavior. */
return ! TYPE_PACKED (record_type);
}
\f
;; Note - the following set of patterns do not use the "memory_operand"
;; predicate or an "m" constraint because we do not allow symbol_refs
;; or label_refs as legitimate memory addresses. This matches the
-;; behaviour of most of the RX instructions. Only the call/branch
+;; behavior of most of the RX instructions. Only the call/branch
;; instructions are allowed to refer to symbols/labels directly.
;; The call operands are in QImode because that is the value of
;; FUNCTION_MODE
The loop is analyzed for memory accesses by calling check_dpu for
each rtx of the loop. Depending on the loop_depth and the amount of
memory accesses a new number <=nunroll is returned to improve the
- behaviour of the hardware prefetch unit. */
+ behavior of the hardware prefetch unit. */
static unsigned
s390_loop_unroll_adjust (unsigned nunroll, struct loop *loop)
{
1) extern int name;
2) int name;
3) int name = 5;
- See below for the behaviour as implemented by the native compiler.
+ See below for the behavior as implemented by the native compiler.
*/
enum extern_model_kind
+2016-02-12 Jakub Jelinek <jakub@redhat.com>
+
+ * error.c: Spelling fixes - behaviour -> behavior and
+ neighbour -> neighbor.
+ * decl.c: Likewise.
+ * typeck.c (cp_build_binary_op): Fix up behavior spelling in
+ diagnostics.
+ * init.c (build_delete): Likewise.
+
2016-02-11 Jakub Jelinek <jakub@redhat.com>
PR c/69768
/* build_delete sets the location of the destructor call to the
current location, even though the destructor is going to be
called later, at the end of the current scope. This can lead to
- a "jumpy" behaviour for users of debuggers when they step around
+ a "jumpy" behavior for users of debuggers when they step around
the end of the block. So let's unset the location of the
destructor call instead. */
protected_set_expr_location (cleanup, UNKNOWN_LOCATION);
{
const char *name;
/* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
- here will be adequate to get the desired behaviour. */
+ here will be adequate to get the desired behavior. */
cxx_pp->flags |= pp_c_flag_gnu_v3;
name = decl_as_string (decl, flags);
/* Subsequent calls to the pretty printer shouldn't use this style. */
{
const char *name;
/* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
- here will be adequate to get the desired behaviour. */
+ here will be adequate to get the desired behavior. */
cxx_pp->flags |= pp_c_flag_gnu_v3;
name = lang_decl_name (decl, v, translate);
/* Subsequent calls to the pretty printer shouldn't use this style. */
warning (OPT_Wdelete_non_virtual_dtor,
"deleting object of abstract class type %qT"
" which has non-virtual destructor"
- " will cause undefined behaviour", type);
+ " will cause undefined behavior", type);
else
warning (OPT_Wdelete_non_virtual_dtor,
"deleting object of polymorphic class type %qT"
" which has non-virtual destructor"
- " might cause undefined behaviour", type);
+ " might cause undefined behavior", type);
}
}
}
|| (TREE_CODE (orig_op1) == STRING_CST
&& !integer_zerop (cp_fully_fold (op0)))))
warning (OPT_Waddress, "comparison with string literal results "
- "in unspecified behaviour");
+ "in unspecified behavior");
build_type = boolean_type_node;
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
|| TREE_CODE (orig_op1) == STRING_CST)
{
if (complain & tf_warning)
- warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
+ warning (OPT_Waddress, "comparison with string literal results "
+ "in unspecified behavior");
}
if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
Priority Level (IPL) is copied to the current IPL which has the effect of only
enabling higher priority interrupts. To use vectored interrupt mode use
the argument @code{vector=[sw0|sw1|hw0|hw1|hw2|hw3|hw4|hw5]}, this will change
-the behaviour of the non-masked interrupt support and GCC will arrange to mask
+the behavior of the non-masked interrupt support and GCC will arrange to mask
all interrupts from sw0 up to and including the specified interrupt vector.
You can use the following attributes to modify the behavior
@option{--with-aix-soname} is currently supported by @samp{libgcc_s} only, so
this option is still experimental and not for normal use yet.
-Default is the traditional behaviour @option{--with-aix-soname=@samp{aix}}.
+Default is the traditional behavior @option{--with-aix-soname=@samp{aix}}.
@item --enable-languages=@var{lang1},@var{lang2},@dots{}
Specify that only a particular subset of compilers and
may be rejected by reservations in the subsequent insns.
@item
-@dfn{collapse-ndfa} modifies the behaviour of the generator when
+@dfn{collapse-ndfa} modifies the behavior of the generator when
producing an automaton. An additional state transition to collapse a
nondeterministic @acronym{NDFA} state to a deterministic @acronym{DFA}
state is generated. It can be triggered by passing @code{const0_rtx} to
Normally, when a function returns a structure by memory, the address
is passed as an invisible pointer argument, but the compiler also
arranges to return the address from the function like it would a normal
-pointer return value. Define this to true if that behaviour is
+pointer return value. Define this to true if that behavior is
undesirable on your target.
@end deftypevr
\f
-/* Controls the behaviour of {anti_,}adjust_stack. */
+/* Controls the behavior of {anti_,}adjust_stack. */
static bool suppress_reg_args_size;
/* A helper for adjust_stack and anti_adjust_stack. */
else
{
/* For disjoint address spaces, converting anything but a null
- pointer invokes undefined behaviour. We truncate or extend the
+ pointer invokes undefined behavior. We truncate or extend the
value as if we'd converted via integers, which handles 0 as
required, and all others as the programmer likely expects. */
#ifndef POINTERS_EXTEND_UNSIGNED
*si_p = gsi_for_stmt (stmt);
}
-/* BB when reached via incoming edge E will exhibit undefined behaviour
+/* BB when reached via incoming edge E will exhibit undefined behavior
at STMT. Isolate and optimize the path which exhibits undefined
- behaviour.
+ behavior.
Isolation is simple. Duplicate BB and redirect E to BB'.
/* There may be more than one statement in DUPLICATE which exhibits
- undefined behaviour. Ultimately we want the first such statement in
+ undefined behavior. Ultimately we want the first such statement in
DUPLCIATE so that we're able to delete as much code as possible.
- So each time we discover undefined behaviour in DUPLICATE, search for
- the statement which triggers undefined behaviour. If found, then
+ So each time we discover undefined behavior in DUPLICATE, search for
+ the statement which triggers undefined behavior. If found, then
transform the statement into a trap and delete everything after the
statement. If not found, then this particular instance was subsumed by
- an earlier instance of undefined behaviour and there's nothing to do.
+ an earlier instance of undefined behavior and there's nothing to do.
This is made more complicated by the fact that we have STMT, which is in
BB rather than in DUPLICATE. So we set up two iterators, one for each
When found isolate and optimize the path associated with the PHI
argument feeding the erroneous statement. */
static void
-find_implicit_erroneous_behaviour (void)
+find_implicit_erroneous_behavior (void)
{
basic_block bb;
}
}
-/* Look for statements which exhibit erroneous behaviour. For example
+/* Look for statements which exhibit erroneous behavior. For example
a NULL pointer dereference.
- When found, optimize the block containing the erroneous behaviour. */
+ When found, optimize the block containing the erroneous behavior. */
static void
-find_explicit_erroneous_behaviour (void)
+find_explicit_erroneous_behavior (void)
{
basic_block bb;
initialize_original_copy_tables ();
/* Search all the blocks for edges which, if traversed, will
- result in undefined behaviour. */
+ result in undefined behavior. */
cfg_altered = false;
/* First handle cases where traversal of a particular edge
- triggers undefined behaviour. These cases require creating
+ triggers undefined behavior. These cases require creating
duplicate blocks and thus new SSA_NAMEs.
We want that process complete prior to the phase where we start
back to the manager but we could still have dangling references
to the released SSA_NAME in unreachable blocks.
that any released names not have dangling references in the IL. */
- find_implicit_erroneous_behaviour ();
- find_explicit_erroneous_behaviour ();
+ find_implicit_erroneous_behavior ();
+ find_explicit_erroneous_behavior ();
free_original_copy_tables ();
+2016-02-12 Jakub Jelinek <jakub@redhat.com>
+
+ * gofrontend/lex.cc: Spelling fixes - behaviour -> behavior and
+ neighbour -> neighbor.
+ * gccgo.texi: Likewise.
+
2016-01-27 Ian Lance Taylor <iant@google.com>
* go-lang.c (go_langhook_init_options_struct): Default to
At link time you must explicitly tell @command{gccgo} which files to
link together into the executable, as is usual with @command{gcc}.
-This is different from the behaviour of other Go compilers.
+This is different from the behavior of other Go compilers.
@node C Interoperability
@chapter C Interoperability
&& (cc < '0' || cc > '9'))
{
// Check for an invalid character here, as we get better
- // error behaviour if we swallow them as part of the
+ // error behavior if we swallow them as part of the
// identifier we are building.
if ((cc >= ' ' && cc < 0x7f)
|| cc == '\t'
{
// There is no valid place for a non-ASCII character
// other than an identifier, so we get better error
- // handling behaviour if we swallow this character after
+ // handling behavior if we swallow this character after
// giving an error.
if (!issued_error)
error_at(this->location(),
from unsigned to signed preserves bit pattern, and right shift of
a signed value propagates the sign bit.
We have to convert from signed to unsigned and back, because when left
- shifting signed values, any overflow is undefined behaviour. */
+ shifting signed values, any overflow is undefined behavior. */
gcc_checking_assert (prec < HOST_BITS_PER_WIDE_INT);
int shift = HOST_BITS_PER_WIDE_INT - prec;
return ((HOST_WIDE_INT) ((unsigned HOST_WIDE_INT) src << shift)) >> shift;
minimizes the number of chain elements per allocno live range. If the
blocks would be visited in a different order, we would still compute a
correct post-ordering but it would be less likely that two nodes
- connected by an edge in the CFG are neighbours in the topsort. */
+ connected by an edge in the CFG are neighbors in the topsort. */
static vec<ira_loop_tree_node_t>
ira_loop_tree_body_rev_postorder (ira_loop_tree_node_t loop_node ATTRIBUTE_UNUSED,
reject++;
}
}
- /* We simulate the behaviour of old reload here.
+ /* We simulate the behavior of old reload here.
Although scratches need hard registers and it
might result in spilling other pseudos, no reload
insns are generated for the scratches. So it
if (insn != NULL_RTX)
{
/* Do nothing if we cannot generate right insns.
- This is analogous to reload pass behaviour. */
+ This is analogous to reload pass behavior. */
delete_insns_since (last);
end_sequence ();
return false;
/* If we have a narrowing conversion of an arithmetic operation where
both operands are widening conversions from the same type as the outer
narrowing conversion. Then convert the innermost operands to a suitable
- unsigned type (to avoid introducing undefined behaviour), perform the
+ unsigned type (to avoid introducing undefined behavior), perform the
operation and convert the result to the desired type. */
(for op (plus minus)
(simplify
/* This is another case of narrowing, specifically when there's an outer
BIT_AND_EXPR which masks off bits outside the type of the innermost
operands. Like the previous case we have to convert the operands
- to unsigned types to avoid introducing undefined behaviour for the
+ to unsigned types to avoid introducing undefined behavior for the
arithmetic operation. */
(for op (minus plus)
(simplify
+2016-02-12 Jakub Jelinek <jakub@redhat.com>
+
+ * objc-act.c: Spelling fixes - behaviour -> behavior and
+ neighbour -> neighbor.
+ * objc-map.h: Likewise.
+
2016-01-04 Jakub Jelinek <jakub@redhat.com>
Update copyright years.
(due to the code below) and so will know that +alloc is called on
the 'NSObject' class, and can perform the corresponding checks.
- Programmers can disable this behaviour by casting the results of
+ Programmers can disable this behavior by casting the results of
objc_getClass() to 'Class' (this may seem weird because
objc_getClass() is already declared to return 'Class', but the
compiler treats it as a special function). This may be useful if
OBJC_LOOKUP_NO_SUPER is clear, and no suitable class method could
be found in INTERFACE or any of its superclasses, look for an
_instance_ method of the same name in the root class as a last
- resort. This behaviour can be turned off by using
+ resort. This behavior can be turned off by using
OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS.
If a suitable method cannot be found, return NULL_TREE. */
/* Return the current key. You can only call it after you have called
objc_map_iterator_move_to_next() at least once (to move to the
first element), and only if the last call returned
- OBJC_MAP_SUCCESS. The behaviour is otherwise undefined, probably a
+ OBJC_MAP_SUCCESS. The behavior is otherwise undefined, probably a
segmentation fault. */
static inline
tree
/* Return the current value. You can only call it after you have
called objc_map_iterator_move_to_next() at least once (to move to
the first element), and only if the last call returned
- OBJC_MAP_SUCCESS. The behaviour is otherwise undefined, probably a
+ OBJC_MAP_SUCCESS. The behavior is otherwise undefined, probably a
segmentation fault. */
static inline
tree
/* Schedule a single extended basic block, defined by the boundaries
HEAD and TAIL.
- We change our expectations about scheduler behaviour depending on
+ We change our expectations about scheduler behavior depending on
whether MODULO_SCHEDULING is true. If it is, we expect that the
caller has already called set_modulo_params and created delay pairs
as appropriate. If the modulo schedule failed, we return
extern void sel_add_to_insn_priority (rtx, int);
/* True if during selective scheduling we need to emulate some of haifa
- scheduler behaviour. */
+ scheduler behavior. */
extern int sched_emulate_haifa_p;
/* Mapping from INSN_UID to INSN_LUID. In the end all other per insn data
typedef struct cmpd_local_params *cmpd_local_params_p;
typedef struct moveop_static_params *moveop_static_params_p;
-/* Set of hooks and parameters that determine behaviour specific to
+/* Set of hooks and parameters that determine behavior specific to
move_op or find_used_regs functions. */
struct code_motion_path_driver_info_def
{
{
/* We have already found an original operation on this branch, do not
go any further and just return TRUE here. If we don't stop here,
- function can have exponential behaviour even on the small code
+ function can have exponential behavior even on the small code
with many different paths (e.g. with data speculation and
recovery blocks). */
if (sched_verbose >= 6)
by inserting i characters. */
v1[0] = i + 1;
- /* Build the rest of the row by considering neighbours to
+ /* Build the rest of the row by considering neighbors to
the north, west and northwest. */
for (int j = 0; j < len_s; j++)
{
"Normally, when a function returns a structure by memory, the address\n\
is passed as an invisible pointer argument, but the compiler also\n\
arranges to return the address from the function like it would a normal\n\
-pointer return value. Define this to true if that behaviour is\n\
+pointer return value. Define this to true if that behavior is\n\
undesirable on your target.",
bool, false)
extern bool target_default_pointer_address_modes_p (void);
/* For hooks which use the MOVE_RATIO macro, this gives the legacy default
- behaviour. */
+ behavior. */
extern unsigned int get_move_ratio (bool);
struct stdarg_info;
}
/* For hooks which use the MOVE_RATIO macro, this gives the legacy default
- behaviour. SPEED_P is true if we are compiling for speed. */
+ behavior. SPEED_P is true if we are compiling for speed. */
unsigned int
get_move_ratio (bool speed_p ATTRIBUTE_UNUSED)
+2016-02-12 Jakub Jelinek <jakub@redhat.com>
+
+ * objc.dg/gnu-api-2-method.m: Spelling fixes - behaviour -> behavior
+ and neighbour -> neighbor.
+ * objc.dg/attributes/method-nonnull-1.m: Likewise.
+ * objc.dg/gnu-api-2-class-meta.m: Likewise.
+ * c-c++-common/Wvarargs.c: Likewise.
+ * c-c++-common/goacc/host_data-5.c: Likewise.
+ * obj-c++.dg/gnu-api-2-class-meta.mm: Likewise.
+ * obj-c++.dg/attributes/method-nonnull-1.mm: Likewise.
+ * obj-c++.dg/gnu-api-2-method.mm: Likewise.
+ * gcc.target/aarch64/pr60697.c: Likewise.
+ * gcc.target/aarch64/advsimd-intrinsics/vldX_lane.c: Likewise.
+ * gcc.target/aarch64/advsimd-intrinsics/vqshl.c: Likewise.
+ * gcc.target/aarch64/advsimd-intrinsics/vshuffle.inc: Likewise.
+ * gcc.target/aarch64/advsimd-intrinsics/vrshl.c: Likewise.
+ * gcc.target/aarch64/advsimd-intrinsics/vldX_dup.c: Likewise.
+ * gcc.target/aarch64/advsimd-intrinsics/vstX_lane.c: Likewise.
+ * gcc.target/aarch64/advsimd-intrinsics/vqrshl.c: Likewise.
+ * gcc.target/aarch64/advsimd-intrinsics/vldX.c: Likewise.
+ * gcc.target/aarch64/aapcs64/ice_2.c: Likewise.
+ * gcc.target/aarch64/aapcs64/test_23.c: Likewise.
+ * gcc.target/aarch64/vrnd_f64_1.c: Likewise.
+ * g++.dg/warn/Wconversion-real-integer-3.C: Likewise.
+ * g++.dg/lookup/koenig5.C: Likewise.
+ * g++.dg/ext/no-asm-2.C: Likewise.
+ * gfortran.dg/bounds_check_array_ctor_3.f90: Likewise.
+ * gfortran.dg/bounds_check_array_ctor_7.f90: Likewise.
+ * gfortran.dg/used_types_16.f90: Likewise.
+ * gfortran.dg/assumed_rank_bounds_1.f90: Likewise.
+ * gfortran.dg/bounds_check_array_ctor_1.f90: Likewise.
+ * gfortran.dg/assumed_rank_bounds_2.f90: Likewise.
+ * gfortran.dg/bounds_check_array_ctor_4.f90: Likewise.
+ * gfortran.dg/abstract_type_6.f03: Likewise.
+ * gfortran.dg/bounds_check_array_ctor_5.f90: Likewise.
+ * gfortran.dg/used_types_15.f90: Likewise.
+ * gfortran.dg/bounds_check_array_ctor_8.f90: Likewise.
+ * gfortran.dg/exit_3.f08: Likewise.
+ * gfortran.dg/open_status_2.f90: Likewise.
+ * gfortran.dg/derived_pointer_recursion_2.f90: Likewise.
+ * gfortran.dg/intrinsic_std_1.f90: Likewise.
+ * gfortran.dg/associate_1.f03: Likewise.
+ * gfortran.dg/bounds_check_array_ctor_2.f90: Likewise.
+ * gfortran.dg/intrinsic_std_6.f90: Likewise.
+ * gfortran.dg/bounds_check_array_ctor_6.f90: Likewise.
+ * gcc.dg/builtin-object-size-1.c: Likewise.
+ * gcc.dg/noreturn-6.c: Likewise.
+ * gcc.dg/builtin-stringop-chk-1.c: Likewise.
+ * gcc.dg/globalalias.c: Likewise.
+ * gcc.dg/builtins-config.h: Likewise.
+ * gcc.dg/pr30457.c: Likewise.
+ * gcc.c-torture/compile/volatile-1.c: Likewise.
+ * gcc.c-torture/execute/20101011-1.c: Likewise.
+ * c-c++-common/Waddress-1.c: Likewise.
+
2016-02-11 Jakub Jelinek <jakub@redhat.com>
PR c/69768
int
foo ()
{
- return "foo1" != (void *) 0 /* { dg-bogus "comparison with string literal results in unspecified behaviou?r" } */
- && "foo2" != (const char *) ((void *) 0) /* { dg-bogus "comparison with string literal results in unspecified behaviou?r" } */
- && "foo3" != (const char *) ((void *) (10 - 10)) /* { dg-bogus "comparison with string literal results in unspecified behaviou?r" } */
- && "foo4" != (const char *) ((void *) (&e - &e)) /* { dg-warning "comparison with string literal results in unspecified behaviou?r" "" { target c } } */
- && "foo5" != "foo6"; /* { dg-warning "comparison with string literal results in unspecified behaviou?r" } */
+ return "foo1" != (void *) 0 /* { dg-bogus "comparison with string literal results in unspecified behavior" } */
+ && "foo2" != (const char *) ((void *) 0) /* { dg-bogus "comparison with string literal results in unspecified behavior" } */
+ && "foo3" != (const char *) ((void *) (10 - 10)) /* { dg-bogus "comparison with string literal results in unspecified behavior" } */
+ && "foo4" != (const char *) ((void *) (&e - &e)) /* { dg-warning "comparison with string literal results in unspecified behavior" "" { target c } } */
+ && "foo5" != "foo6"; /* { dg-warning "comparison with string literal results in unspecified behavior" } */
}
{
va_list vp;
/* 'b' is declared with register storage, so warn. */
- va_start (vp, b); /* { dg-warning "undefined behaviour" } */
+ va_start (vp, b); /* { dg-warning "undefined behavior" } */
va_end (vp);
}
int *xp;
#pragma acc host_data use_device (x)
{
- /* This use of the present clause is undefined behaviour for OpenACC. */
+ /* This use of the present clause is undefined behavior for OpenACC. */
#pragma acc parallel present (x) copyout (xp) /* { dg-error "variable 'x' declared in enclosing 'host_data' region" } */
{
xp = x;
// Verify that the keyword asm and the GNU extension typeof are not
// recognized as keywords when using -fno-asm. Having -fno-asm affect
// a standard C++ keyword seems strange, but that is existing
-// behaviour. If that behaviour changes, this test should change.
+// behavior. If that behavior changes, this test should change.
int asm; // { dg-bogus "before .asm." }
int typeof; // { dg-bogus "before .typeof." }
// Koenig lookup is not defined as intended in the std. DR 218 gives
// an indication of what is meant. This test case encapsulates the
-// current conservative behaviour
+// current conservative behavior
// Copyright (C) 2006 Free Software Foundation, Inc.
// Contributed by Nathan Sidwell 27 Aug 2006 <nathan@codesourcery.com>
// a macro that expands to the built-in __INT_MAX__. Furthermore,
// INT_MAX is defined inside a system header.
//
- // The behaviour we want is that the diagnostic should point to
+ // The behavior we want is that the diagnostic should point to
// the locus that inside the source code here, at the relevant
// line below, even with -ftrack-macro-expansion. We don't want
// it to point to the any locus that is inside the system header.
/* The problem here was that the statements that
loaded from exception.reason where not being
- marked as having volatile behaviour which
+ marked as having volatile behavior which
caused load PRE on the tree level to go
into an infinite loop. */
# define DO_TEST 0
#elif defined (__epiphany__)
/* Epiphany does not have hardware division, and the software implementation
- has truly undefined behaviour for division by 0. */
+ has truly undefined behavior for division by 0. */
# define DO_TEST 0
#elif defined (__m68k__) && !defined(__linux__)
/* Attempting to trap division-by-zero in this way isn't likely to work on
# define DO_TEST 0
# else
# include <signal.h>
- /* ARM division-by-zero behaviour is to call a helper function, which
+ /* ARM division-by-zero behavior is to call a helper function, which
can do several different things, depending on requirements. Emulate
- the behaviour of other targets here by raising SIGFPE. */
+ the behavior of other targets here by raising SIGFPE. */
int __attribute__((used))
__aeabi_idiv0 (int return_value)
{
/* My understanding of ISO C99 6.5.6 is that a conforming
program will not end up with p equal to &buf[0]
through &buf[7], i.e. calling this function with say
- UINTPTR_MAX / 4 results in undefined behaviour.
+ UINTPTR_MAX / 4 results in undefined behavior.
If that's true, then the maximum number of remaining
bytes from p until end of the object is 56, otherwise
it would be 64 (or conservative (size_t) -1 == unknown). */
memset (p, 'd', 0);
q = strcpy (p, ""); /* { dg-warning "will always overflow" "strcpy" } */
- /* This invokes undefined behaviour, since we are past the end of buf1. */
+ /* This invokes undefined behavior, since we are past the end of buf1. */
p = p + 10;
memset (p, 'd', 1); /* { dg-warning "will always overflow" "memset" } */
&& ! defined (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__))
/* MacOS versions before 10.3 don't have many C99 functions.
But, if you're including this file, you probably want to test the
- newer behaviour, so: */
+ newer behavior, so: */
#error forgot to set -mmacosx-version-min.
#elif (defined(__APPLE__) && defined(__ppc__) \
&& __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1030)
#if defined(_NEWLIB_VERSION) || defined(__UCLIBC__)
#elif defined(__sun) && __STDC_VERSION__ - 0 < 199901L
/* If you're including this file, you probably want to test the newer
- behaviour, so ensure the right flags were used for each test: */
+ behavior, so ensure the right flags were used for each test: */
#error forgot to set -std=c99.
#elif defined(__sun) && ! defined (_STDC_C99)
/* Solaris up to 9 doesn't have the entire C99 runtime.
/* This test checks that local aliases behave sanely. This is necessary for code correctness
of aliases introduced by ipa-visibility pass.
- This test expose weird behaviour of AIX's .set pseudo-op where the global symbol is created,
+ This test expose weird behavior of AIX's .set pseudo-op where the global symbol is created,
but all uses of the alias are syntactically replaced by uses of the target. This means that
both counters are increased to 2. */
/* { dg-do compile } */
-/* Check for volatile behaviour. */
+/* Check for volatile behavior. */
extern int xxx (void);
volatile extern int xxx (void); /* { dg-error "not compatible" } */
{
va_list ap;
- va_start(ap, paramN); /* { dg-warning "undefined behaviour when second parameter of 'va_start' is declared with 'register' storage" } */
+ va_start(ap, paramN); /* { dg-warning "undefined behavior when second parameter of 'va_start' is declared with 'register' storage" } */
/* Undefined by C99 7.15.1.1p2: */
(void) va_arg(ap, char); /* { dg-warning "'char' is promoted to 'int' when passed through '...'" "promoted" } */
/* Test AAPCS layout
- Larger than machine-supported vector size. The behaviour is unspecified by
+ Larger than machine-supported vector size. The behavior is unspecified by
the AAPCS64 document; the implementation opts for pass by reference. */
/* { dg-do compile { target aarch64*-*-* } } */
/* Test AAPCS64 layout.
- Larger than machine-supported vector size. The behaviour is unspecified by
+ Larger than machine-supported vector size. The behavior is unspecified by
the AAPCS64 document; the implementation opts for pass by reference. */
/* { dg-do run { target aarch64*-*-* } } */
/* We need to use a temporary result buffer (result_bis), because
the one used for other tests is not large enough. A subset of the
result data is moved from result_bis to result, and it is this
- subset which is used to check the actual behaviour. The next
+ subset which is used to check the actual behavior. The next
macro enables to move another chunk of data from result_bis to
result. */
#define TEST_VLDX(Q, T1, T2, W, N, X) \
/* We need to use a temporary result buffer (result_bis), because
the one used for other tests is not large enough. A subset of the
result data is moved from result_bis to result, and it is this
- subset which is used to check the actual behaviour. The next
+ subset which is used to check the actual behavior. The next
macro enables to move another chunk of data from result_bis to
result. */
#define TEST_VLDX_DUP(Q, T1, T2, W, N, X) \
/* We need to use a temporary result buffer (result_bis), because
the one used for other tests is not large enough. A subset of the
result data is moved from result_bis to result, and it is this
- subset which is used to check the actual behaviour. The next
+ subset which is used to check the actual behavior. The next
macro enables to move another chunk of data from result_bis to
result. */
/* We also use another extra input buffer (buffer_src), which we
/* Choose init value arbitrarily, will be used as shift amount */
/* Use values equal to or one-less-than the type width to check
- behaviour on limits. */
+ behavior on limits. */
VDUP(vector_shift, , int, s, 8, 8, 7);
VDUP(vector_shift, , int, s, 16, 4, 15);
VDUP(vector_shift, , int, s, 32, 2, 31);
/* Choose init value arbitrarily, will be used as shift amount */
/* Use values equal or one-less-than the type width to check
- behaviour on limits. */
+ behavior on limits. */
/* 64-bits vectors first. */
/* Shift 8-bits lanes by 7... */
/* Choose init value arbitrarily, will be used as shift amount. */
/* Use values equal to one-less-than the type width to check
- behaviour on limits. */
+ behavior on limits. */
VDUP(vector_shift, , int, s, 8, 8, 7);
VDUP(vector_shift, , int, s, 16, 4, 15);
VDUP(vector_shift, , int, s, 32, 2, 31);
/* We need to use a temporary result buffer (result_bis), because
the one used for other tests is not large enough. A subset of the
result data is moved from result_bis to result, and it is this
- subset which is used to check the actual behaviour. The next
+ subset which is used to check the actual behavior. The next
macro enables to move another chunk of data from result_bis to
result. */
#define TEST_VSHUFFLE(INSN, Q, T1, T2, W, N) \
/* We need to use a temporary result buffer (result_bis), because
the one used for other tests is not large enough. A subset of the
result data is moved from result_bis to result, and it is this
- subset which is used to check the actual behaviour. The next
+ subset which is used to check the actual behavior. The next
macro enables to move another chunk of data from result_bis to
result. */
/* We also use another extra input buffer (buffer_src), which we
}
}
}
-int search_neighbours(FILE *log,t_forcerec *fr,
+int search_neighbors(FILE *log,t_forcerec *fr,
rvec x[],matrix box,
t_topology *top,t_groups *grps,
t_commrec *cr,t_nsborder *nsb,
};
/* Set floating point control register
- to have predictable vrndx and vrndi behaviour. */
+ to have predictable vrndx and vrndi behavior. */
set_rounding_mode (FPROUNDING_ZERO);
run_round_tests (tests, expectations);
TYPE, ABSTRACT :: top
CONTAINS
PROCEDURE(xxx), DEFERRED :: proc_a ! { dg-error "must be explicit" }
- ! some useful default behaviour
+ ! some useful default behavior
PROCEDURE :: proc_c => top_c ! { dg-error "must be a module procedure" }
END TYPE top
-! Concrete middle class with useful behaviour
+! Concrete middle class with useful behavior
TYPE, EXTENDS(top) :: middle
CONTAINS
! do nothing, empty proc just to make middle concrete
PROCEDURE :: proc_a => dummy_middle_a ! { dg-error "must be a module procedure" }
- ! some useful default behaviour
+ ! some useful default behavior
PROCEDURE :: proc_b => middle_b ! { dg-error "must be a module procedure" }
END TYPE middle
! useful proc to satisfy deferred procedure in top. Because we've
! extended middle we wouldn't get told off if we forgot this.
PROCEDURE :: proc_a => bottom_a ! { dg-error "must be a module procedure" }
- ! calls middle%proc_b and then provides extra behaviour
+ ! calls middle%proc_b and then provides extra behavior
PROCEDURE :: proc_b => bottom_b
- ! calls top_c and then provides extra behaviour
+ ! calls top_c and then provides extra behavior
PROCEDURE :: proc_c => bottom_c
END TYPE bottom
contains
END ASSOCIATE
END ASSOCIATE myname ! Matching end-label.
- ! Correct behaviour when shadowing already existing names.
+ ! Correct behavior when shadowing already existing names.
ASSOCIATE (a => 1 * b, b => 1 * a, x => 1, y => 2)
IF (ABS (a - 3.0) > 1.0e-3 .OR. ABS (b + 2.0) > 1.0e-3) CALL abort ()
ASSOCIATE (x => 1 * y, y => 1 * x)
! { dg-do run }
!
-! Test the behaviour of lbound, ubound of shape with assumed rank arguments
+! Test the behavior of lbound, ubound of shape with assumed rank arguments
! in an array context (without DIM argument).
!
! { dg-do run }
!
-! Test the behaviour of lbound, ubound of shape with assumed rank arguments
+! Test the behavior of lbound, ubound of shape with assumed rank arguments
! in an array context (without DIM argument).
!
! { dg-shouldfail "foo" }
!
! PR 36112
-! Check correct bounds-checking behaviour for character-array-constructors.
+! Check correct bounds-checking behavior for character-array-constructors.
call test ("this is long")
contains
! { dg-shouldfail "foo" }
!
! PR 36112
-! Check correct bounds-checking behaviour for character-array-constructors.
+! Check correct bounds-checking behavior for character-array-constructors.
call test ("this is long")
contains
! { dg-do compile }
!
! PR 36112
-! Check correct bounds-checking behaviour for character-array-constructors.
+! Check correct bounds-checking behavior for character-array-constructors.
! This should not need any -fbounds-check and is enabled all the time.
character(len=128) :: arr(2) = (/ "abc", "foobar" /) ! { dg-error "Different CHARACTER lengths" }
! { dg-shouldfail "foo" }
!
! PR 36112
-! Check correct bounds-checking behaviour for character-array-constructors.
+! Check correct bounds-checking behavior for character-array-constructors.
call test ("short", "this is long")
contains
! { dg-do compile }
!
! PR 36112
-! Check correct bounds-checking behaviour for character-array-constructors.
+! Check correct bounds-checking behavior for character-array-constructors.
! No need for -fbounds-check, enabled unconditionally.
character(len=5) :: s = "hello"
! { dg-shouldfail "foo" }
!
! PR 36112
-! Check correct bounds-checking behaviour for character-array-constructors.
+! Check correct bounds-checking behavior for character-array-constructors.
call test ("short", "also5")
contains
! { dg-shouldfail "foo" }
!
! PR 36112
-! Check correct bounds-checking behaviour for character-array-constructors.
+! Check correct bounds-checking behavior for character-array-constructors.
call test ("short")
contains
! { dg-shouldfail "foo" }
!
! PR 36112
-! Check correct bounds-checking behaviour for character-array-constructors.
+! Check correct bounds-checking behavior for character-array-constructors.
call test ("short")
contains
END TYPE
TYPE :: atom_private
- TYPE(atom_list) :: neighbours
+ TYPE(atom_list) :: neighbors
LOGICAL :: initialized = .true.
END TYPE
! { dg-options "-std=f2008 -fall-intrinsics" }
! PR fortran/44602
-! Check for correct behaviour of EXIT / CYCLE combined with non-loop
+! Check for correct behavior of EXIT / CYCLE combined with non-loop
! constructs at run-time.
! Contributed by Daniel Kraft, d@domob.eu.
!
! PR fortran/33141
-! Check for the expected behaviour when an intrinsic function/subroutine is
+! Check for the expected behavior when an intrinsic function/subroutine is
! called that is not available in the defined standard or that is a GNU
! extension:
! There should be a warning emitted on the call, and the reference should be
!
! PR fortran/33141
-! Check for the expected behaviour when an intrinsic function/subroutine is
+! Check for the expected behavior when an intrinsic function/subroutine is
! called that is not available in the defined standard or that is a GNU
! extension:
! There should be a warning emitted on the call, and the reference should be
! PR 24945
! Test reopening file without status specifier or with
! status='unknown'. The standard says that these two must behave
-! identically, but the actual behaviour is processor dependent.
+! identically, but the actual behavior is processor dependent.
program open_status_2
open(10, file="f", form='unformatted', status='unknown')
open(10, file="f", form='unformatted', status='unknown')
END TYPE
TYPE :: dummy_atom
- TYPE(dummy_atom_list) :: neighbours
+ TYPE(dummy_atom_list) :: neighbors
END TYPE
TYPE :: dummy_atom_model
END TYPE\r
\r
TYPE :: dummy_atom_private\r
- TYPE(dummy_atom_list) :: neighbours\r
+ TYPE(dummy_atom_list) :: neighbors\r
END TYPE\r
END MODULE\r
\r
+ (void) insertObject: (id)object atIndex: (size_t)index andObject: (id)anotherObject atIndex: (size_t)anotherIndex __attribute__ ((nonnull (1, 3)));
- (void) insertObject: (id)object atIndex: (size_t)index andObject: (id)anotherObject atIndex: (size_t)anotherIndex __attribute__ ((nonnull (1, 3)));
-/* Test the behaviour with invalid code. */
+/* Test the behavior with invalid code. */
+ (void) removeObject: (id)object __attribute__ ((nonnull (0))); /* { dg-error "out-of-range" } */
- (void) removeObject: (id)object __attribute__ ((nonnull (0))); /* { dg-error "out-of-range" } */
Functions that manipulate instances, instance variables, properties
and protocols at the moment must take a normal class as argument;
calling them with a meta class as argument is of no particular use
- and generally produces a behaviour that is undocumented and/or
+ and generally produces a behavior that is undocumented and/or
undefined (and this is true with all runtimes). As in the future
- this behaviour may be defined or documented (for example, if class
+ this behavior may be defined or documented (for example, if class
variables are implemented as instance variables of meta classes) we
avoid testing it for compatibility with future runtimes. */
/* Swap the methods. */
method_exchangeImplementations (method_a, method_b);
- /* Check that behaviour has changed. */
+ /* Check that behavior has changed. */
if ([object variable] != nil || [object constant] != object)
abort ();
/* Swap the methods again. */
method_exchangeImplementations (method_a, method_b);
- /* Check that behaviour is back to normal. */
+ /* Check that behavior is back to normal. */
if ([object variable] != object || [object constant] != nil)
abort ();
}
if (method_setImplementation (method_a, original_imp_b) != original_imp_a)
abort ();
- /* Check that behaviour has changed. */
+ /* Check that behavior has changed. */
if ([object variable] != nil || [object constant] != nil)
abort ();
if (method_setImplementation (method_a, original_imp_a) != original_imp_b)
abort ();
- /* Check that behaviour is back to normal. */
+ /* Check that behavior is back to normal. */
if ([object variable] != object || [object constant] != nil)
abort ();
}
+ (void) insertObject: (id)object atIndex: (size_t)index andObject: (id)anotherObject atIndex: (size_t)anotherIndex __attribute__ ((nonnull (1, 3)));
- (void) insertObject: (id)object atIndex: (size_t)index andObject: (id)anotherObject atIndex: (size_t)anotherIndex __attribute__ ((nonnull (1, 3)));
-/* Test the behaviour with invalid code. */
+/* Test the behavior with invalid code. */
+ (void) removeObject: (id)object __attribute__ ((nonnull (0))); /* { dg-error "out-of-range" } */
- (void) removeObject: (id)object __attribute__ ((nonnull (0))); /* { dg-error "out-of-range" } */
Functions that manipulate instances, instance variables, properties
and protocols at the moment must take a normal class as argument;
calling them with a meta class as argument is of no particular use
- and generally produces a behaviour that is undocumented and/or
+ and generally produces a behavior that is undocumented and/or
undefined (and this is true with all runtimes). As in the future
- this behaviour may be defined or documented (for example, if class
+ this behavior may be defined or documented (for example, if class
variables are implemented as instance variables of meta classes) we
avoid testing it for compatibility with future runtimes. */
/* Swap the methods. */
method_exchangeImplementations (method_a, method_b);
- /* Check that behaviour has changed. */
+ /* Check that behavior has changed. */
if ([object variable] != nil || [object constant] != object)
abort ();
/* Swap the methods again. */
method_exchangeImplementations (method_a, method_b);
- /* Check that behaviour is back to normal. */
+ /* Check that behavior is back to normal. */
if ([object variable] != object || [object constant] != nil)
abort ();
}
if (method_setImplementation (method_a, original_imp_b) != original_imp_a)
abort ();
- /* Check that behaviour has changed. */
+ /* Check that behavior has changed. */
if ([object variable] != nil || [object constant] != nil)
abort ();
if (method_setImplementation (method_a, original_imp_a) != original_imp_b)
abort ();
- /* Check that behaviour is back to normal. */
+ /* Check that behavior is back to normal. */
if ([object variable] != object || [object constant] != nil)
abort ();
}
if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))
/* For extern inline functions that get redefined we always
- silently ignored always_inline flag. Better behaviour would
+ silently ignored always_inline flag. Better behavior would
be to be able to keep both bodies and use extern inline body
for inlining, but we can't do that because frontends overwrite
the body. */
if (BB_CLUSTER (bb1) != NULL && BB_CLUSTER (bb1) == BB_CLUSTER (bb2))
continue;
- /* Limit quadratic behaviour. */
+ /* Limit quadratic behavior. */
nr_comparisons++;
if (nr_comparisons > max_comparisons)
break;
comp_alias_ddrs.qsort (comp_dr_with_seg_len_pair);
/* Third, we scan the sorted dr pairs and check if we can combine
- alias checks of two neighbouring dr pairs. */
+ alias checks of two neighboring dr pairs. */
for (size_t i = 1; i < comp_alias_ddrs.length (); ++i)
{
/* Deal with two ddrs (dr_a1, dr_b1) and (dr_a2, dr_b2). */
projects / thirdparty / gcc.git / commitdiff
